#define EXTERN extern
#include "mfd.h"
void
#ifdef HAVE_PROTOTYPES
initialize ( void )
#else
initialize ( )
#endif
{
integer i ;
integer k ;
xchr [32 ]= ' ' ;
xchr [33 ]= '!' ;
xchr [34 ]= '"' ;
xchr [35 ]= '#' ;
xchr [36 ]= '$' ;
xchr [37 ]= '%' ;
xchr [38 ]= '&' ;
xchr [39 ]= '\'' ;
xchr [40 ]= '(' ;
xchr [41 ]= ')' ;
xchr [42 ]= '*' ;
xchr [43 ]= '+' ;
xchr [44 ]= ',' ;
xchr [45 ]= '-' ;
xchr [46 ]= '.' ;
xchr [47 ]= '/' ;
xchr [48 ]= '0' ;
xchr [49 ]= '1' ;
xchr [50 ]= '2' ;
xchr [51 ]= '3' ;
xchr [52 ]= '4' ;
xchr [53 ]= '5' ;
xchr [54 ]= '6' ;
xchr [55 ]= '7' ;
xchr [56 ]= '8' ;
xchr [57 ]= '9' ;
xchr [58 ]= ':' ;
xchr [59 ]= ';' ;
xchr [60 ]= '<' ;
xchr [61 ]= '=' ;
xchr [62 ]= '>' ;
xchr [63 ]= '?' ;
xchr [64 ]= '@' ;
xchr [65 ]= 'A' ;
xchr [66 ]= 'B' ;
xchr [67 ]= 'C' ;
xchr [68 ]= 'D' ;
xchr [69 ]= 'E' ;
xchr [70 ]= 'F' ;
xchr [71 ]= 'G' ;
xchr [72 ]= 'H' ;
xchr [73 ]= 'I' ;
xchr [74 ]= 'J' ;
xchr [75 ]= 'K' ;
xchr [76 ]= 'L' ;
xchr [77 ]= 'M' ;
xchr [78 ]= 'N' ;
xchr [79 ]= 'O' ;
xchr [80 ]= 'P' ;
xchr [81 ]= 'Q' ;
xchr [82 ]= 'R' ;
xchr [83 ]= 'S' ;
xchr [84 ]= 'T' ;
xchr [85 ]= 'U' ;
xchr [86 ]= 'V' ;
xchr [87 ]= 'W' ;
xchr [88 ]= 'X' ;
xchr [89 ]= 'Y' ;
xchr [90 ]= 'Z' ;
xchr [91 ]= '[' ;
xchr [92 ]= '\\' ;
xchr [93 ]= ']' ;
xchr [94 ]= '^' ;
xchr [95 ]= '_' ;
xchr [96 ]= '`' ;
xchr [97 ]= 'a' ;
xchr [98 ]= 'b' ;
xchr [99 ]= 'c' ;
xchr [100 ]= 'd' ;
xchr [101 ]= 'e' ;
xchr [102 ]= 'f' ;
xchr [103 ]= 'g' ;
xchr [104 ]= 'h' ;
xchr [105 ]= 'i' ;
xchr [106 ]= 'j' ;
xchr [107 ]= 'k' ;
xchr [108 ]= 'l' ;
xchr [109 ]= 'm' ;
xchr [110 ]= 'n' ;
xchr [111 ]= 'o' ;
xchr [112 ]= 'p' ;
xchr [113 ]= 'q' ;
xchr [114 ]= 'r' ;
xchr [115 ]= 's' ;
xchr [116 ]= 't' ;
xchr [117 ]= 'u' ;
xchr [118 ]= 'v' ;
xchr [119 ]= 'w' ;
xchr [120 ]= 'x' ;
xchr [121 ]= 'y' ;
xchr [122 ]= 'z' ;
xchr [123 ]= '{' ;
xchr [124 ]= '|' ;
xchr [125 ]= '}' ;
xchr [126 ]= '~' ;
{register integer for_end; i = 0 ;for_end = 31 ; if ( i <= for_end) do
xchr [i ]= chr ( i ) ;
while ( i++ < for_end ) ;}
{register integer for_end; i = 127 ;for_end = 255 ; if ( i <= for_end) do
xchr [i ]= chr ( i ) ;
while ( i++ < for_end ) ;}
{register integer for_end; i = 0 ;for_end = 255 ; if ( i <= for_end) do
xord [chr ( i ) ]= 127 ;
while ( i++ < for_end ) ;}
{register integer for_end; i = 128 ;for_end = 255 ; if ( i <= for_end) do
xord [xchr [i ]]= i ;
while ( i++ < for_end ) ;}
{register integer for_end; i = 0 ;for_end = 126 ; if ( i <= for_end) do
xord [xchr [i ]]= i ;
while ( i++ < for_end ) ;}
if ( interactionoption == 4 )
interaction = 3 ;
else interaction = interactionoption ;
deletionsallowed = true ;
errorcount = 0 ;
helpptr = 0 ;
useerrhelp = false ;
errhelp = 0 ;
interrupt = 0 ;
OKtointerrupt = true ;
aritherror = false ;
twotothe [0 ]= 1 ;
{register integer for_end; k = 1 ;for_end = 30 ; if ( k <= for_end) do
twotothe [k ]= 2 * twotothe [k - 1 ];
while ( k++ < for_end ) ;}
speclog [1 ]= 93032640L ;
speclog [2 ]= 38612034L ;
speclog [3 ]= 17922280L ;
speclog [4 ]= 8662214L ;
speclog [5 ]= 4261238L ;
speclog [6 ]= 2113709L ;
speclog [7 ]= 1052693L ;
speclog [8 ]= 525315L ;
speclog [9 ]= 262400L ;
speclog [10 ]= 131136L ;
speclog [11 ]= 65552L ;
speclog [12 ]= 32772L ;
speclog [13 ]= 16385 ;
{register integer for_end; k = 14 ;for_end = 27 ; if ( k <= for_end) do
speclog [k ]= twotothe [27 - k ];
while ( k++ < for_end ) ;}
speclog [28 ]= 1 ;
specatan [1 ]= 27855475L ;
specatan [2 ]= 14718068L ;
specatan [3 ]= 7471121L ;
specatan [4 ]= 3750058L ;
specatan [5 ]= 1876857L ;
specatan [6 ]= 938658L ;
specatan [7 ]= 469357L ;
specatan [8 ]= 234682L ;
specatan [9 ]= 117342L ;
specatan [10 ]= 58671L ;
specatan [11 ]= 29335 ;
specatan [12 ]= 14668 ;
specatan [13 ]= 7334 ;
specatan [14 ]= 3667 ;
specatan [15 ]= 1833 ;
specatan [16 ]= 917 ;
specatan [17 ]= 458 ;
specatan [18 ]= 229 ;
specatan [19 ]= 115 ;
specatan [20 ]= 57 ;
specatan [21 ]= 29 ;
specatan [22 ]= 14 ;
specatan [23 ]= 7 ;
specatan [24 ]= 4 ;
specatan [25 ]= 2 ;
specatan [26 ]= 1 ;
;
#ifdef TEXMF_DEBUG
wasmemend = 0 ;
waslomax = 0 ;
washimin = memmax ;
panicking = false ;
#endif /* TEXMF_DEBUG */
{register integer for_end; k = 1 ;for_end = 41 ; if ( k <= for_end) do
internal [k ]= 0 ;
while ( k++ < for_end ) ;}
intptr = 41 ;
{register integer for_end; k = 48 ;for_end = 57 ; if ( k <= for_end) do
charclass [k ]= 0 ;
while ( k++ < for_end ) ;}
charclass [46 ]= 1 ;
charclass [32 ]= 2 ;
charclass [37 ]= 3 ;
charclass [34 ]= 4 ;
charclass [44 ]= 5 ;
charclass [59 ]= 6 ;
charclass [40 ]= 7 ;
charclass [41 ]= 8 ;
{register integer for_end; k = 65 ;for_end = 90 ; if ( k <= for_end) do
charclass [k ]= 9 ;
while ( k++ < for_end ) ;}
{register integer for_end; k = 97 ;for_end = 122 ; if ( k <= for_end) do
charclass [k ]= 9 ;
while ( k++ < for_end ) ;}
charclass [95 ]= 9 ;
charclass [60 ]= 10 ;
charclass [61 ]= 10 ;
charclass [62 ]= 10 ;
charclass [58 ]= 10 ;
charclass [124 ]= 10 ;
charclass [96 ]= 11 ;
charclass [39 ]= 11 ;
charclass [43 ]= 12 ;
charclass [45 ]= 12 ;
charclass [47 ]= 13 ;
charclass [42 ]= 13 ;
charclass [92 ]= 13 ;
charclass [33 ]= 14 ;
charclass [63 ]= 14 ;
charclass [35 ]= 15 ;
charclass [38 ]= 15 ;
charclass [64 ]= 15 ;
charclass [36 ]= 15 ;
charclass [94 ]= 16 ;
charclass [126 ]= 16 ;
charclass [91 ]= 17 ;
charclass [93 ]= 18 ;
charclass [123 ]= 19 ;
charclass [125 ]= 19 ;
{register integer for_end; k = 0 ;for_end = 31 ; if ( k <= for_end) do
charclass [k ]= 20 ;
while ( k++ < for_end ) ;}
{register integer for_end; k = 127 ;for_end = 255 ; if ( k <= for_end) do
charclass [k ]= 20 ;
while ( k++ < for_end ) ;}
charclass [9 ]= 2 ;
charclass [12 ]= 2 ;
hash [1 ].lhfield = 0 ;
hash [1 ].v.RH = 0 ;
eqtb [1 ].lhfield = 41 ;
eqtb [1 ].v.RH = 0 ;
{register integer for_end; k = 2 ;for_end = 9769 ; if ( k <= for_end) do
{
hash [k ]= hash [1 ];
eqtb [k ]= eqtb [1 ];
}
while ( k++ < for_end ) ;}
bignodesize [13 ]= 12 ;
bignodesize [14 ]= 4 ;
saveptr = 0 ;
octantdir [1 ]= 547 ;
octantdir [5 ]= 548 ;
octantdir [6 ]= 549 ;
octantdir [2 ]= 550 ;
octantdir [4 ]= 551 ;
octantdir [8 ]= 552 ;
octantdir [7 ]= 553 ;
octantdir [3 ]= 554 ;
maxroundingptr = 0 ;
octantcode [1 ]= 1 ;
octantcode [2 ]= 5 ;
octantcode [3 ]= 6 ;
octantcode [4 ]= 2 ;
octantcode [5 ]= 4 ;
octantcode [6 ]= 8 ;
octantcode [7 ]= 7 ;
octantcode [8 ]= 3 ;
{register integer for_end; k = 1 ;for_end = 8 ; if ( k <= for_end) do
octantnumber [octantcode [k ]]= k ;
while ( k++ < for_end ) ;}
revturns = false ;
xcorr [1 ]= 0 ;
ycorr [1 ]= 0 ;
xycorr [1 ]= 0 ;
xcorr [5 ]= 0 ;
ycorr [5 ]= 0 ;
xycorr [5 ]= 1 ;
xcorr [6 ]= -1 ;
ycorr [6 ]= 1 ;
xycorr [6 ]= 0 ;
xcorr [2 ]= 1 ;
ycorr [2 ]= 0 ;
xycorr [2 ]= 1 ;
xcorr [4 ]= 0 ;
ycorr [4 ]= 1 ;
xycorr [4 ]= 1 ;
xcorr [8 ]= 0 ;
ycorr [8 ]= 1 ;
xycorr [8 ]= 0 ;
xcorr [7 ]= 1 ;
ycorr [7 ]= 0 ;
xycorr [7 ]= 1 ;
xcorr [3 ]= -1 ;
ycorr [3 ]= 1 ;
xycorr [3 ]= 0 ;
{register integer for_end; k = 1 ;for_end = 8 ; if ( k <= for_end) do
zcorr [k ]= xycorr [k ]- xcorr [k ];
while ( k++ < for_end ) ;}
screenstarted = false ;
screenOK = false ;
{register integer for_end; k = 0 ;for_end = 15 ; if ( k <= for_end) do
{
windowopen [k ]= false ;
windowtime [k ]= 0 ;
}
while ( k++ < for_end ) ;}
fixneeded = false ;
watchcoefs = true ;
condptr = 0 ;
iflimit = 0 ;
curif = 0 ;
ifline = 0 ;
loopptr = 0 ;
curexp = 0 ;
varflag = 0 ;
startsym = 0 ;
longhelpseen = false ;
{register integer for_end; k = 0 ;for_end = 255 ; if ( k <= for_end) do
{
tfmwidth [k ]= 0 ;
tfmheight [k ]= 0 ;
tfmdepth [k ]= 0 ;
tfmitalcorr [k ]= 0 ;
charexists [k ]= false ;
chartag [k ]= 0 ;
charremainder [k ]= 0 ;
skiptable [k ]= ligtablesize ;
}
while ( k++ < for_end ) ;}
{register integer for_end; k = 1 ;for_end = headersize ; if ( k <=
for_end) do
headerbyte [k ]= -1 ;
while ( k++ < for_end ) ;}
bc = 255 ;
ec = 0 ;
nl = 0 ;
nk = 0 ;
ne = 0 ;
np = 0 ;
internal [41 ]= -65536L ;
bchlabel = ligtablesize ;
labelloc [0 ]= -1 ;
labelptr = 0 ;
gfprevptr = 0 ;
totalchars = 0 ;
halfbuf = gfbufsize / 2 ;
gflimit = gfbufsize ;
gfptr = 0 ;
gfoffset = 0 ;
baseident = 0 ;
editnamestart = 0 ;
}
void
#ifdef HAVE_PROTOTYPES
println ( void )
#else
println ( )
#endif
{
switch ( selector )
{case 3 :
{
putc ('\n', stdout );
putc ('\n', logfile );
termoffset = 0 ;
fileoffset = 0 ;
}
break ;
case 2 :
{
putc ('\n', logfile );
fileoffset = 0 ;
}
break ;
case 1 :
{
putc ('\n', stdout );
termoffset = 0 ;
}
break ;
case 0 :
case 4 :
case 5 :
;
break ;
}
}
void
#ifdef HAVE_PROTOTYPES
zprintvisiblechar ( ASCIIcode s )
#else
zprintvisiblechar ( s )
ASCIIcode s ;
#endif
{
switch ( selector )
{case 3 :
{
putc ( xchr [s ], stdout );
putc ( xchr [s ], logfile );
incr ( termoffset ) ;
incr ( fileoffset ) ;
if ( termoffset == maxprintline )
{
putc ('\n', stdout );
termoffset = 0 ;
}
if ( fileoffset == maxprintline )
{
putc ('\n', logfile );
fileoffset = 0 ;
}
}
break ;
case 2 :
{
putc ( xchr [s ], logfile );
incr ( fileoffset ) ;
if ( fileoffset == maxprintline )
println () ;
}
break ;
case 1 :
{
putc ( xchr [s ], stdout );
incr ( termoffset ) ;
if ( termoffset == maxprintline )
println () ;
}
break ;
case 0 :
;
break ;
case 4 :
if ( tally < trickcount )
trickbuf [tally % errorline ]= s ;
break ;
case 5 :
{
if ( poolptr < poolsize )
{
strpool [poolptr ]= s ;
incr ( poolptr ) ;
}
}
break ;
}
incr ( tally ) ;
}
void
#ifdef HAVE_PROTOTYPES
zprintchar ( ASCIIcode s )
#else
zprintchar ( s )
ASCIIcode s ;
#endif
{
/* 10 */ ASCIIcode k ;
unsigned char l ;
k = s ;
if ( ( k < 32 ) || ( k > 126 ) )
{
if ( selector > 4 )
{
printvisiblechar ( s ) ;
goto lab10 ;
}
printvisiblechar ( 94 ) ;
printvisiblechar ( 94 ) ;
if ( s < 64 )
printvisiblechar ( s + 64 ) ;
else if ( s < 128 )
printvisiblechar ( s - 64 ) ;
else {
l = s / 16 ;
if ( l < 10 )
printvisiblechar ( l + 48 ) ;
else printvisiblechar ( l + 87 ) ;
l = s % 16 ;
if ( l < 10 )
printvisiblechar ( l + 48 ) ;
else printvisiblechar ( l + 87 ) ;
}
}
else printvisiblechar ( s ) ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zprint ( integer s )
#else
zprint ( s )
integer s ;
#endif
{
poolpointer j ;
if ( ( s < 0 ) || ( s >= strptr ) )
s = 259 ;
if ( ( s < 256 ) )
printchar ( s ) ;
else {
j = strstart [s ];
while ( j < strstart [s + 1 ]) {
printchar ( strpool [j ]) ;
incr ( j ) ;
}
}
}
void
#ifdef HAVE_PROTOTYPES
zprintnl ( strnumber s )
#else
zprintnl ( s )
strnumber s ;
#endif
{
if ( ( ( termoffset > 0 ) && ( odd ( selector ) ) ) || ( ( fileoffset > 0
) && ( selector >= 2 ) ) )
println () ;
print ( s ) ;
}
void
#ifdef HAVE_PROTOTYPES
zprintthedigs ( eightbits k )
#else
zprintthedigs ( k )
eightbits k ;
#endif
{
while ( k > 0 ) {
decr ( k ) ;
printchar ( 48 + dig [k ]) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zprintint ( integer n )
#else
zprintint ( n )
integer n ;
#endif
{
char k ;
integer m ;
k = 0 ;
if ( n < 0 )
{
printchar ( 45 ) ;
if ( n > -100000000L )
n = - (integer) n ;
else {
m = -1 - n ;
n = m / 10 ;
m = ( m % 10 ) + 1 ;
k = 1 ;
if ( m < 10 )
dig [0 ]= m ;
else {
dig [0 ]= 0 ;
incr ( n ) ;
}
}
}
do {
dig [k ]= n % 10 ;
n = n / 10 ;
incr ( k ) ;
} while ( ! ( n == 0 ) ) ;
printthedigs ( k ) ;
}
void
#ifdef HAVE_PROTOTYPES
zprintscaled ( scaled s )
#else
zprintscaled ( s )
scaled s ;
#endif
{
scaled delta ;
if ( s < 0 )
{
printchar ( 45 ) ;
s = - (integer) s ;
}
printint ( s / 65536L ) ;
s = 10 * ( s % 65536L ) + 5 ;
if ( s != 5 )
{
delta = 10 ;
printchar ( 46 ) ;
do {
if ( delta > 65536L )
s = s + 32768L - ( delta / 2 ) ;
printchar ( 48 + ( s / 65536L ) ) ;
s = 10 * ( s % 65536L ) ;
delta = delta * 10 ;
} while ( ! ( s <= delta ) ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zprinttwo ( scaled x , scaled y )
#else
zprinttwo ( x , y )
scaled x ;
scaled y ;
#endif
{
printchar ( 40 ) ;
printscaled ( x ) ;
printchar ( 44 ) ;
printscaled ( y ) ;
printchar ( 41 ) ;
}
void
#ifdef HAVE_PROTOTYPES
zprinttype ( smallnumber t )
#else
zprinttype ( t )
smallnumber t ;
#endif
{
switch ( t )
{case 1 :
print ( 322 ) ;
break ;
case 2 :
print ( 323 ) ;
break ;
case 3 :
print ( 324 ) ;
break ;
case 4 :
print ( 325 ) ;
break ;
case 5 :
print ( 326 ) ;
break ;
case 6 :
print ( 327 ) ;
break ;
case 7 :
print ( 328 ) ;
break ;
case 8 :
print ( 329 ) ;
break ;
case 9 :
print ( 330 ) ;
break ;
case 10 :
print ( 331 ) ;
break ;
case 11 :
print ( 332 ) ;
break ;
case 12 :
print ( 333 ) ;
break ;
case 13 :
print ( 334 ) ;
break ;
case 14 :
print ( 335 ) ;
break ;
case 16 :
print ( 336 ) ;
break ;
case 17 :
print ( 337 ) ;
break ;
case 18 :
print ( 338 ) ;
break ;
case 15 :
print ( 339 ) ;
break ;
case 19 :
print ( 340 ) ;
break ;
case 20 :
print ( 341 ) ;
break ;
case 21 :
print ( 342 ) ;
break ;
case 22 :
print ( 343 ) ;
break ;
case 23 :
print ( 344 ) ;
break ;
default:
print ( 345 ) ;
break ;
}
}
void
#ifdef HAVE_PROTOTYPES
begindiagnostic ( void )
#else
begindiagnostic ( )
#endif
{
oldsetting = selector ;
if ( ( internal [13 ]<= 0 ) && ( selector == 3 ) )
{
decr ( selector ) ;
if ( history == 0 )
history = 1 ;
}
}
void
#ifdef HAVE_PROTOTYPES
zenddiagnostic ( boolean blankline )
#else
zenddiagnostic ( blankline )
boolean blankline ;
#endif
{
printnl ( 283 ) ;
if ( blankline )
println () ;
selector = oldsetting ;
}
void
#ifdef HAVE_PROTOTYPES
zprintdiagnostic ( strnumber s , strnumber t , boolean nuline )
#else
zprintdiagnostic ( s , t , nuline )
strnumber s ;
strnumber t ;
boolean nuline ;
#endif
{
begindiagnostic () ;
if ( nuline )
printnl ( s ) ;
else print ( s ) ;
print ( 449 ) ;
printint ( line ) ;
print ( t ) ;
printchar ( 58 ) ;
}
void
#ifdef HAVE_PROTOTYPES
zprintfilename ( integer n , integer a , integer e )
#else
zprintfilename ( n , a , e )
integer n ;
integer a ;
integer e ;
#endif
{
print ( a ) ;
print ( n ) ;
print ( e ) ;
}
#ifdef TEXMF_DEBUG
#endif /* TEXMF_DEBUG */
void
#ifdef HAVE_PROTOTYPES
zflushstring ( strnumber s )
#else
zflushstring ( s )
strnumber s ;
#endif
{
if ( s < strptr - 1 )
strref [s ]= 0 ;
else do {
decr ( strptr ) ;
} while ( ! ( strref [strptr - 1 ]!= 0 ) ) ;
poolptr = strstart [strptr ];
}
void
#ifdef HAVE_PROTOTYPES
jumpout ( void )
#else
jumpout ( )
#endif
{
closefilesandterminate () ;
{
fflush ( stdout ) ;
readyalready = 0 ;
if ( ( history != 0 ) && ( history != 1 ) )
uexit ( 1 ) ;
else uexit ( 0 ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
error ( void )
#else
error ( )
#endif
{
/* 22 10 */ ASCIIcode c ;
integer s1, s2, s3 ;
poolpointer j ;
if ( history < 2 )
history = 2 ;
printchar ( 46 ) ;
showcontext () ;
if ( interaction == 3 )
while ( true ) {
lab22: clearforerrorprompt () ;
{
;
print ( 263 ) ;
terminput () ;
}
if ( last == first )
goto lab10 ;
c = buffer [first ];
if ( c >= 97 )
c = c - 32 ;
switch ( c )
{case 48 :
case 49 :
case 50 :
case 51 :
case 52 :
case 53 :
case 54 :
case 55 :
case 56 :
case 57 :
if ( deletionsallowed )
{
s1 = curcmd ;
s2 = curmod ;
s3 = cursym ;
OKtointerrupt = false ;
if ( ( last > first + 1 ) && ( buffer [first + 1 ]>= 48 ) && (
buffer [first + 1 ]<= 57 ) )
c = c * 10 + buffer [first + 1 ]- 48 * 11 ;
else c = c - 48 ;
while ( c > 0 ) {
getnext () ;
if ( curcmd == 39 )
{
if ( strref [curmod ]< 127 )
if ( strref [curmod ]> 1 )
decr ( strref [curmod ]) ;
else flushstring ( curmod ) ;
}
decr ( c ) ;
}
curcmd = s1 ;
curmod = s2 ;
cursym = s3 ;
OKtointerrupt = true ;
{
helpptr = 2 ;
helpline [1 ]= 276 ;
helpline [0 ]= 277 ;
}
showcontext () ;
goto lab22 ;
}
break ;
;
#ifdef TEXMF_DEBUG
case 68 :
{
debughelp () ;
goto lab22 ;
}
break ;
#endif /* TEXMF_DEBUG */
case 69 :
if ( fileptr > 0 )
{
editnamestart = strstart [inputstack [fileptr ].namefield ];
editnamelength = strstart [inputstack [fileptr ].namefield + 1 ]-
strstart [inputstack [fileptr ].namefield ];
editline = line ;
jumpout () ;
}
break ;
case 72 :
{
if ( useerrhelp )
{
j = strstart [errhelp ];
while ( j < strstart [errhelp + 1 ]) {
if ( strpool [j ]!= 37 )
print ( strpool [j ]) ;
else if ( j + 1 == strstart [errhelp + 1 ])
println () ;
else if ( strpool [j + 1 ]!= 37 )
println () ;
else {
incr ( j ) ;
printchar ( 37 ) ;
}
incr ( j ) ;
}
useerrhelp = false ;
}
else {
if ( helpptr == 0 )
{
helpptr = 2 ;
helpline [1 ]= 278 ;
helpline [0 ]= 279 ;
}
do {
decr ( helpptr ) ;
print ( helpline [helpptr ]) ;
println () ;
} while ( ! ( helpptr == 0 ) ) ;
}
{
helpptr = 4 ;
helpline [3 ]= 280 ;
helpline [2 ]= 279 ;
helpline [1 ]= 281 ;
helpline [0 ]= 282 ;
}
goto lab22 ;
}
break ;
case 73 :
{
beginfilereading () ;
if ( last > first + 1 )
{
curinput .locfield = first + 1 ;
buffer [first ]= 32 ;
}
else {
{
;
print ( 275 ) ;
terminput () ;
}
curinput .locfield = first ;
}
first = last + 1 ;
curinput .limitfield = last ;
goto lab10 ;
}
break ;
case 81 :
case 82 :
case 83 :
{
errorcount = 0 ;
interaction = 0 + c - 81 ;
print ( 270 ) ;
switch ( c )
{case 81 :
{
print ( 271 ) ;
decr ( selector ) ;
}
break ;
case 82 :
print ( 272 ) ;
break ;
case 83 :
print ( 273 ) ;
break ;
}
print ( 274 ) ;
println () ;
fflush ( stdout ) ;
goto lab10 ;
}
break ;
case 88 :
{
interaction = 2 ;
jumpout () ;
}
break ;
default:
;
break ;
}
{
print ( 264 ) ;
printnl ( 265 ) ;
printnl ( 266 ) ;
if ( fileptr > 0 )
print ( 267 ) ;
if ( deletionsallowed )
printnl ( 268 ) ;
printnl ( 269 ) ;
}
}
incr ( errorcount ) ;
if ( errorcount == 100 )
{
printnl ( 262 ) ;
history = 3 ;
jumpout () ;
}
if ( interaction > 0 )
decr ( selector ) ;
if ( useerrhelp )
{
printnl ( 283 ) ;
j = strstart [errhelp ];
while ( j < strstart [errhelp + 1 ]) {
if ( strpool [j ]!= 37 )
print ( strpool [j ]) ;
else if ( j + 1 == strstart [errhelp + 1 ])
println () ;
else if ( strpool [j + 1 ]!= 37 )
println () ;
else {
incr ( j ) ;
printchar ( 37 ) ;
}
incr ( j ) ;
}
}
else while ( helpptr > 0 ) {
decr ( helpptr ) ;
printnl ( helpline [helpptr ]) ;
}
println () ;
if ( interaction > 0 )
incr ( selector ) ;
println () ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zfatalerror ( strnumber s )
#else
zfatalerror ( s )
strnumber s ;
#endif
{
normalizeselector () ;
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 284 ) ;
}
{
helpptr = 1 ;
helpline [0 ]= s ;
}
{
if ( interaction == 3 )
interaction = 2 ;
if ( logopened )
error () ;
;
#ifdef TEXMF_DEBUG
if ( interaction > 0 )
debughelp () ;
#endif /* TEXMF_DEBUG */
history = 3 ;
jumpout () ;
}
}
void
#ifdef HAVE_PROTOTYPES
zoverflow ( strnumber s , integer n )
#else
zoverflow ( s , n )
strnumber s ;
integer n ;
#endif
{
normalizeselector () ;
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 285 ) ;
}
print ( s ) ;
printchar ( 61 ) ;
printint ( n ) ;
printchar ( 93 ) ;
{
helpptr = 2 ;
helpline [1 ]= 286 ;
helpline [0 ]= 287 ;
}
{
if ( interaction == 3 )
interaction = 2 ;
if ( logopened )
error () ;
;
#ifdef TEXMF_DEBUG
if ( interaction > 0 )
debughelp () ;
#endif /* TEXMF_DEBUG */
history = 3 ;
jumpout () ;
}
}
void
#ifdef HAVE_PROTOTYPES
zconfusion ( strnumber s )
#else
zconfusion ( s )
strnumber s ;
#endif
{
normalizeselector () ;
if ( history < 2 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 288 ) ;
}
print ( s ) ;
printchar ( 41 ) ;
{
helpptr = 1 ;
helpline [0 ]= 289 ;
}
}
else {
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 290 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 291 ;
helpline [0 ]= 292 ;
}
}
{
if ( interaction == 3 )
interaction = 2 ;
if ( logopened )
error () ;
;
#ifdef TEXMF_DEBUG
if ( interaction > 0 )
debughelp () ;
#endif /* TEXMF_DEBUG */
history = 3 ;
jumpout () ;
}
}
boolean
#ifdef HAVE_PROTOTYPES
initterminal ( void )
#else
initterminal ( )
#endif
{
/* 10 */ register boolean Result; topenin () ;
if ( last > first )
{
curinput .locfield = first ;
while ( ( curinput .locfield < last ) && ( buffer [curinput .locfield ]
== ' ' ) ) incr ( curinput .locfield ) ;
if ( curinput .locfield < last )
{
Result = true ;
goto lab10 ;
}
}
while ( true ) {
;
Fputs( stdout , "**" ) ;
fflush ( stdout ) ;
if ( ! inputln ( stdin , true ) )
{
putc ('\n', stdout );
Fputs( stdout , "! End of file on the terminal... why?" ) ;
Result = false ;
goto lab10 ;
}
curinput .locfield = first ;
while ( ( curinput .locfield < last ) && ( buffer [curinput .locfield ]
== 32 ) ) incr ( curinput .locfield ) ;
if ( curinput .locfield < last )
{
Result = true ;
goto lab10 ;
}
fprintf( stdout , "%s\n", "Please type the name of your input file." ) ;
}
lab10: ;
return Result ;
}
strnumber
#ifdef HAVE_PROTOTYPES
makestring ( void )
#else
makestring ( )
#endif
{
register strnumber Result; if ( strptr == maxstrptr )
{
if ( strptr == maxstrings )
overflow ( 258 , maxstrings - initstrptr ) ;
incr ( maxstrptr ) ;
}
strref [strptr ]= 1 ;
incr ( strptr ) ;
strstart [strptr ]= poolptr ;
Result = strptr - 1 ;
return Result ;
}
boolean
#ifdef HAVE_PROTOTYPES
zstreqbuf ( strnumber s , integer k )
#else
zstreqbuf ( s , k )
strnumber s ;
integer k ;
#endif
{
/* 45 */ register boolean Result; poolpointer j ;
boolean result ;
j = strstart [s ];
while ( j < strstart [s + 1 ]) {
if ( strpool [j ]!= buffer [k ])
{
result = false ;
goto lab45 ;
}
incr ( j ) ;
incr ( k ) ;
}
result = true ;
lab45: Result = result ;
return Result ;
}
integer
#ifdef HAVE_PROTOTYPES
zstrvsstr ( strnumber s , strnumber t )
#else
zstrvsstr ( s , t )
strnumber s ;
strnumber t ;
#endif
{
/* 10 */ register integer Result; poolpointer j, k ;
integer ls, lt ;
integer l ;
ls = ( strstart [s + 1 ]- strstart [s ]) ;
lt = ( strstart [t + 1 ]- strstart [t ]) ;
if ( ls <= lt )
l = ls ;
else l = lt ;
j = strstart [s ];
k = strstart [t ];
while ( l > 0 ) {
if ( strpool [j ]!= strpool [k ])
{
Result = strpool [j ]- strpool [k ];
goto lab10 ;
}
incr ( j ) ;
incr ( k ) ;
decr ( l ) ;
}
Result = ls - lt ;
lab10: ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zprintdd ( integer n )
#else
zprintdd ( n )
integer n ;
#endif
{
n = abs ( n ) % 100 ;
printchar ( 48 + ( n / 10 ) ) ;
printchar ( 48 + ( n % 10 ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
terminput ( void )
#else
terminput ( )
#endif
{
integer k ;
fflush ( stdout ) ;
if ( ! inputln ( stdin , true ) )
fatalerror ( 260 ) ;
termoffset = 0 ;
decr ( selector ) ;
if ( last != first )
{register integer for_end; k = first ;for_end = last - 1 ; if ( k <=
for_end) do
print ( buffer [k ]) ;
while ( k++ < for_end ) ;}
println () ;
buffer [last ]= 37 ;
incr ( selector ) ;
}
void
#ifdef HAVE_PROTOTYPES
normalizeselector ( void )
#else
normalizeselector ( )
#endif
{
if ( logopened )
selector = 3 ;
else selector = 1 ;
if ( jobname == 0 )
openlogfile () ;
if ( interaction == 0 )
decr ( selector ) ;
}
void
#ifdef HAVE_PROTOTYPES
pauseforinstructions ( void )
#else
pauseforinstructions ( )
#endif
{
if ( OKtointerrupt )
{
interaction = 3 ;
if ( ( selector == 2 ) || ( selector == 0 ) )
incr ( selector ) ;
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 293 ) ;
}
{
helpptr = 3 ;
helpline [2 ]= 294 ;
helpline [1 ]= 295 ;
helpline [0 ]= 296 ;
}
deletionsallowed = false ;
error () ;
deletionsallowed = true ;
interrupt = 0 ;
}
}
void
#ifdef HAVE_PROTOTYPES
zmissingerr ( strnumber s )
#else
zmissingerr ( s )
strnumber s ;
#endif
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 297 ) ;
}
print ( s ) ;
print ( 298 ) ;
}
void
#ifdef HAVE_PROTOTYPES
cleararith ( void )
#else
cleararith ( )
#endif
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 299 ) ;
}
{
helpptr = 4 ;
helpline [3 ]= 300 ;
helpline [2 ]= 301 ;
helpline [1 ]= 302 ;
helpline [0 ]= 303 ;
}
error () ;
aritherror = false ;
}
integer
#ifdef HAVE_PROTOTYPES
zslowadd ( integer x , integer y )
#else
zslowadd ( x , y )
integer x ;
integer y ;
#endif
{
register integer Result; if ( x >= 0 )
if ( y <= 2147483647L - x )
Result = x + y ;
else {
aritherror = true ;
Result = 2147483647L ;
}
else if ( - (integer) y <= 2147483647L + x )
Result = x + y ;
else {
aritherror = true ;
Result = -2147483647L ;
}
return Result ;
}
scaled
#ifdef HAVE_PROTOTYPES
zrounddecimals ( smallnumber k )
#else
zrounddecimals ( k )
smallnumber k ;
#endif
{
register scaled Result; integer a ;
a = 0 ;
while ( k > 0 ) {
decr ( k ) ;
a = ( a + dig [k ]* 131072L ) / 10 ;
}
Result = halfp ( a + 1 ) ;
return Result ;
}
#ifdef FIXPT
fraction
#ifdef HAVE_PROTOTYPES
zmakefraction ( integer p , integer q )
#else
zmakefraction ( p , q )
integer p ;
integer q ;
#endif
{
register fraction Result; integer f ;
integer n ;
boolean negative ;
integer becareful ;
if ( p >= 0 )
negative = false ;
else {
p = - (integer) p ;
negative = true ;
}
if ( q <= 0 )
{
;
#ifdef TEXMF_DEBUG
if ( q == 0 )
confusion ( 47 ) ;
#endif /* TEXMF_DEBUG */
q = - (integer) q ;
negative = ! negative ;
}
n = p / q ;
p = p % q ;
if ( n >= 8 )
{
aritherror = true ;
if ( negative )
Result = -2147483647L ;
else Result = 2147483647L ;
}
else {
n = ( n - 1 ) * 268435456L ;
f = 1 ;
do {
becareful = p - q ;
p = becareful + p ;
if ( p >= 0 )
f = f + f + 1 ;
else {
f = f + f ;
p = p + q ;
}
} while ( ! ( f >= 268435456L ) ) ;
becareful = p - q ;
if ( becareful + p >= 0 )
incr ( f ) ;
if ( negative )
Result = - (integer) ( f + n ) ;
else Result = f + n ;
}
return Result ;
}
#endif /* FIXPT */
#ifdef FIXPT
integer
#ifdef HAVE_PROTOTYPES
ztakefraction ( integer q , fraction f )
#else
ztakefraction ( q , f )
integer q ;
fraction f ;
#endif
{
register integer Result; integer p ;
boolean negative ;
integer n ;
integer becareful ;
if ( f >= 0 )
negative = false ;
else {
f = - (integer) f ;
negative = true ;
}
if ( q < 0 )
{
q = - (integer) q ;
negative = ! negative ;
}
if ( f < 268435456L )
n = 0 ;
else {
n = f / 268435456L ;
f = f % 268435456L ;
if ( q <= 2147483647L / n )
n = n * q ;
else {
aritherror = true ;
n = 2147483647L ;
}
}
f = f + 268435456L ;
p = 134217728L ;
if ( q < 1073741824L )
do {
if ( odd ( f ) )
p = halfp ( p + q ) ;
else p = halfp ( p ) ;
f = halfp ( f ) ;
} while ( ! ( f == 1 ) ) ;
else do {
if ( odd ( f ) )
p = p + halfp ( q - p ) ;
else p = halfp ( p ) ;
f = halfp ( f ) ;
} while ( ! ( f == 1 ) ) ;
becareful = n - 2147483647L ;
if ( becareful + p > 0 )
{
aritherror = true ;
n = 2147483647L - p ;
}
if ( negative )
Result = - (integer) ( n + p ) ;
else Result = n + p ;
return Result ;
}
#endif /* FIXPT */
#ifdef FIXPT
integer
#ifdef HAVE_PROTOTYPES
ztakescaled ( integer q , scaled f )
#else
ztakescaled ( q , f )
integer q ;
scaled f ;
#endif
{
register integer Result; integer p ;
boolean negative ;
integer n ;
integer becareful ;
if ( f >= 0 )
negative = false ;
else {
f = - (integer) f ;
negative = true ;
}
if ( q < 0 )
{
q = - (integer) q ;
negative = ! negative ;
}
if ( f < 65536L )
n = 0 ;
else {
n = f / 65536L ;
f = f % 65536L ;
if ( q <= 2147483647L / n )
n = n * q ;
else {
aritherror = true ;
n = 2147483647L ;
}
}
f = f + 65536L ;
p = 32768L ;
if ( q < 1073741824L )
do {
if ( odd ( f ) )
p = halfp ( p + q ) ;
else p = halfp ( p ) ;
f = halfp ( f ) ;
} while ( ! ( f == 1 ) ) ;
else do {
if ( odd ( f ) )
p = p + halfp ( q - p ) ;
else p = halfp ( p ) ;
f = halfp ( f ) ;
} while ( ! ( f == 1 ) ) ;
becareful = n - 2147483647L ;
if ( becareful + p > 0 )
{
aritherror = true ;
n = 2147483647L - p ;
}
if ( negative )
Result = - (integer) ( n + p ) ;
else Result = n + p ;
return Result ;
}
#endif /* FIXPT */
#ifdef FIXPT
scaled
#ifdef HAVE_PROTOTYPES
zmakescaled ( integer p , integer q )
#else
zmakescaled ( p , q )
integer p ;
integer q ;
#endif
{
register scaled Result; integer f ;
integer n ;
boolean negative ;
integer becareful ;
if ( p >= 0 )
negative = false ;
else {
p = - (integer) p ;
negative = true ;
}
if ( q <= 0 )
{
;
#ifdef TEXMF_DEBUG
if ( q == 0 )
confusion ( 47 ) ;
#endif /* TEXMF_DEBUG */
q = - (integer) q ;
negative = ! negative ;
}
n = p / q ;
p = p % q ;
if ( n >= 32768L )
{
aritherror = true ;
if ( negative )
Result = -2147483647L ;
else Result = 2147483647L ;
}
else {
n = ( n - 1 ) * 65536L ;
f = 1 ;
do {
becareful = p - q ;
p = becareful + p ;
if ( p >= 0 )
f = f + f + 1 ;
else {
f = f + f ;
p = p + q ;
}
} while ( ! ( f >= 65536L ) ) ;
becareful = p - q ;
if ( becareful + p >= 0 )
incr ( f ) ;
if ( negative )
Result = - (integer) ( f + n ) ;
else Result = f + n ;
}
return Result ;
}
#endif /* FIXPT */
fraction
#ifdef HAVE_PROTOTYPES
zvelocity ( fraction st , fraction ct , fraction sf , fraction cf , scaled t )
#else
zvelocity ( st , ct , sf , cf , t )
fraction st ;
fraction ct ;
fraction sf ;
fraction cf ;
scaled t ;
#endif
{
register fraction Result; integer acc, num, denom ;
acc = takefraction ( st - ( sf / 16 ) , sf - ( st / 16 ) ) ;
acc = takefraction ( acc , ct - cf ) ;
num = 536870912L + takefraction ( acc , 379625062L ) ;
denom = 805306368L + takefraction ( ct , 497706707L ) + takefraction ( cf ,
307599661L ) ;
if ( t != 65536L )
num = makescaled ( num , t ) ;
if ( num / 4 >= denom )
Result = 1073741824L ;
else Result = makefraction ( num , denom ) ;
return Result ;
}
integer
#ifdef HAVE_PROTOTYPES
zabvscd ( integer a , integer b , integer c , integer d )
#else
zabvscd ( a , b , c , d )
integer a ;
integer b ;
integer c ;
integer d ;
#endif
{
/* 10 */ register integer Result; integer q, r ;
if ( a < 0 )
{
a = - (integer) a ;
b = - (integer) b ;
}
if ( c < 0 )
{
c = - (integer) c ;
d = - (integer) d ;
}
if ( d <= 0 )
{
if ( b >= 0 )
if ( ( ( a == 0 ) || ( b == 0 ) ) && ( ( c == 0 ) || ( d == 0 ) ) )
{
Result = 0 ;
goto lab10 ;
}
else {
Result = 1 ;
goto lab10 ;
}
if ( d == 0 )
if ( a == 0 )
{
Result = 0 ;
goto lab10 ;
}
else {
Result = -1 ;
goto lab10 ;
}
q = a ;
a = c ;
c = q ;
q = - (integer) b ;
b = - (integer) d ;
d = q ;
}
else if ( b <= 0 )
{
if ( b < 0 )
if ( a > 0 )
{
Result = -1 ;
goto lab10 ;
}
if ( c == 0 )
{
Result = 0 ;
goto lab10 ;
}
else {
Result = -1 ;
goto lab10 ;
}
}
while ( true ) {
q = a / d ;
r = c / b ;
if ( q != r )
if ( q > r )
{
Result = 1 ;
goto lab10 ;
}
else {
Result = -1 ;
goto lab10 ;
}
q = a % d ;
r = c % b ;
if ( r == 0 )
if ( q == 0 )
{
Result = 0 ;
goto lab10 ;
}
else {
Result = 1 ;
goto lab10 ;
}
if ( q == 0 )
{
Result = -1 ;
goto lab10 ;
}
a = b ;
b = q ;
c = d ;
d = r ;
}
lab10: ;
return Result ;
}
scaled
#ifdef HAVE_PROTOTYPES
zsquarert ( scaled x )
#else
zsquarert ( x )
scaled x ;
#endif
{
register scaled Result; smallnumber k ;
integer y, q ;
if ( x <= 0 )
{
if ( x < 0 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 304 ) ;
}
printscaled ( x ) ;
print ( 305 ) ;
{
helpptr = 2 ;
helpline [1 ]= 306 ;
helpline [0 ]= 307 ;
}
error () ;
}
Result = 0 ;
}
else {
k = 23 ;
q = 2 ;
while ( x < 536870912L ) {
decr ( k ) ;
x = x + x + x + x ;
}
if ( x < 1073741824L )
y = 0 ;
else {
x = x - 1073741824L ;
y = 1 ;
}
do {
x = x + x ;
y = y + y ;
if ( x >= 1073741824L )
{
x = x - 1073741824L ;
incr ( y ) ;
}
x = x + x ;
y = y + y - q ;
q = q + q ;
if ( x >= 1073741824L )
{
x = x - 1073741824L ;
incr ( y ) ;
}
if ( y > q )
{
y = y - q ;
q = q + 2 ;
}
else if ( y <= 0 )
{
q = q - 2 ;
y = y + q ;
}
decr ( k ) ;
} while ( ! ( k == 0 ) ) ;
Result = halfp ( q ) ;
}
return Result ;
}
integer
#ifdef HAVE_PROTOTYPES
zpythadd ( integer a , integer b )
#else
zpythadd ( a , b )
integer a ;
integer b ;
#endif
{
/* 30 */ register integer Result; fraction r ;
boolean big ;
a = abs ( a ) ;
b = abs ( b ) ;
if ( a < b )
{
r = b ;
b = a ;
a = r ;
}
if ( b > 0 )
{
if ( a < 536870912L )
big = false ;
else {
a = a / 4 ;
b = b / 4 ;
big = true ;
}
while ( true ) {
r = makefraction ( b , a ) ;
r = takefraction ( r , r ) ;
if ( r == 0 )
goto lab30 ;
r = makefraction ( r , 1073741824L + r ) ;
a = a + takefraction ( a + a , r ) ;
b = takefraction ( b , r ) ;
}
lab30: ;
if ( big )
if ( a < 536870912L )
a = a + a + a + a ;
else {
aritherror = true ;
a = 2147483647L ;
}
}
Result = a ;
return Result ;
}
integer
#ifdef HAVE_PROTOTYPES
zpythsub ( integer a , integer b )
#else
zpythsub ( a , b )
integer a ;
integer b ;
#endif
{
/* 30 */ register integer Result; fraction r ;
boolean big ;
a = abs ( a ) ;
b = abs ( b ) ;
if ( a <= b )
{
if ( a < b )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 308 ) ;
}
printscaled ( a ) ;
print ( 309 ) ;
printscaled ( b ) ;
print ( 305 ) ;
{
helpptr = 2 ;
helpline [1 ]= 306 ;
helpline [0 ]= 307 ;
}
error () ;
}
a = 0 ;
}
else {
if ( a < 1073741824L )
big = false ;
else {
a = halfp ( a ) ;
b = halfp ( b ) ;
big = true ;
}
while ( true ) {
r = makefraction ( b , a ) ;
r = takefraction ( r , r ) ;
if ( r == 0 )
goto lab30 ;
r = makefraction ( r , 1073741824L - r ) ;
a = a - takefraction ( a + a , r ) ;
b = takefraction ( b , r ) ;
}
lab30: ;
if ( big )
a = a + a ;
}
Result = a ;
return Result ;
}
scaled
#ifdef HAVE_PROTOTYPES
zmlog ( scaled x )
#else
zmlog ( x )
scaled x ;
#endif
{
register scaled Result; integer y, z ;
integer k ;
if ( x <= 0 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 310 ) ;
}
printscaled ( x ) ;
print ( 305 ) ;
{
helpptr = 2 ;
helpline [1 ]= 311 ;
helpline [0 ]= 307 ;
}
error () ;
Result = 0 ;
}
else {
y = 1302456860L ;
z = 6581195L ;
while ( x < 1073741824L ) {
x = x + x ;
y = y - 93032639L ;
z = z - 48782L ;
}
y = y + ( z / 65536L ) ;
k = 2 ;
while ( x > 1073741828L ) {
z = ( ( x - 1 ) / twotothe [k ]) + 1 ;
while ( x < 1073741824L + z ) {
z = halfp ( z + 1 ) ;
k = k + 1 ;
}
y = y + speclog [k ];
x = x - z ;
}
Result = y / 8 ;
}
return Result ;
}
scaled
#ifdef HAVE_PROTOTYPES
zmexp ( scaled x )
#else
zmexp ( x )
scaled x ;
#endif
{
register scaled Result; smallnumber k ;
integer y, z ;
if ( x > 174436200L )
{
aritherror = true ;
Result = 2147483647L ;
}
else if ( x < -197694359L )
Result = 0 ;
else {
if ( x <= 0 )
{
z = -8 * x ;
y = 1048576L ;
}
else {
if ( x <= 127919879L )
z = 1023359037L - 8 * x ;
else z = 8 * ( 174436200L - x ) ;
y = 2147483647L ;
}
k = 1 ;
while ( z > 0 ) {
while ( z >= speclog [k ]) {
z = z - speclog [k ];
y = y - 1 - ( ( y - twotothe [k - 1 ]) / twotothe [k ]) ;
}
incr ( k ) ;
}
if ( x <= 127919879L )
Result = ( y + 8 ) / 16 ;
else Result = y ;
}
return Result ;
}
angle
#ifdef HAVE_PROTOTYPES
znarg ( integer x , integer y )
#else
znarg ( x , y )
integer x ;
integer y ;
#endif
{
register angle Result; angle z ;
integer t ;
smallnumber k ;
char octant ;
if ( x >= 0 )
octant = 1 ;
else {
x = - (integer) x ;
octant = 2 ;
}
if ( y < 0 )
{
y = - (integer) y ;
octant = octant + 2 ;
}
if ( x < y )
{
t = y ;
y = x ;
x = t ;
octant = octant + 4 ;
}
if ( x == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 312 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 313 ;
helpline [0 ]= 307 ;
}
error () ;
Result = 0 ;
}
else {
while ( x >= 536870912L ) {
x = halfp ( x ) ;
y = halfp ( y ) ;
}
z = 0 ;
if ( y > 0 )
{
while ( x < 268435456L ) {
x = x + x ;
y = y + y ;
}
k = 0 ;
do {
y = y + y ;
incr ( k ) ;
if ( y > x )
{
z = z + specatan [k ];
t = x ;
x = x + ( y / twotothe [k + k ]) ;
y = y - t ;
}
} while ( ! ( k == 15 ) ) ;
do {
y = y + y ;
incr ( k ) ;
if ( y > x )
{
z = z + specatan [k ];
y = y - x ;
}
} while ( ! ( k == 26 ) ) ;
}
switch ( octant )
{case 1 :
Result = z ;
break ;
case 5 :
Result = 94371840L - z ;
break ;
case 6 :
Result = 94371840L + z ;
break ;
case 2 :
Result = 188743680L - z ;
break ;
case 4 :
Result = z - 188743680L ;
break ;
case 8 :
Result = - (integer) z - 94371840L ;
break ;
case 7 :
Result = z - 94371840L ;
break ;
case 3 :
Result = - (integer) z ;
break ;
}
}
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
znsincos ( angle z )
#else
znsincos ( z )
angle z ;
#endif
{
smallnumber k ;
char q ;
fraction r ;
integer x, y, t ;
while ( z < 0 ) z = z + 377487360L ;
z = z % 377487360L ;
q = z / 47185920L ;
z = z % 47185920L ;
x = 268435456L ;
y = x ;
if ( ! odd ( q ) )
z = 47185920L - z ;
k = 1 ;
while ( z > 0 ) {
if ( z >= specatan [k ])
{
z = z - specatan [k ];
t = x ;
x = t + y / twotothe [k ];
y = y - t / twotothe [k ];
}
incr ( k ) ;
}
if ( y < 0 )
y = 0 ;
switch ( q )
{case 0 :
;
break ;
case 1 :
{
t = x ;
x = y ;
y = t ;
}
break ;
case 2 :
{
t = x ;
x = - (integer) y ;
y = t ;
}
break ;
case 3 :
x = - (integer) x ;
break ;
case 4 :
{
x = - (integer) x ;
y = - (integer) y ;
}
break ;
case 5 :
{
t = x ;
x = - (integer) y ;
y = - (integer) t ;
}
break ;
case 6 :
{
t = x ;
x = y ;
y = - (integer) t ;
}
break ;
case 7 :
y = - (integer) y ;
break ;
}
r = pythadd ( x , y ) ;
ncos = makefraction ( x , r ) ;
nsin = makefraction ( y , r ) ;
}
void
#ifdef HAVE_PROTOTYPES
newrandoms ( void )
#else
newrandoms ( )
#endif
{
char k ;
fraction x ;
{register integer for_end; k = 0 ;for_end = 23 ; if ( k <= for_end) do
{
x = randoms [k ]- randoms [k + 31 ];
if ( x < 0 )
x = x + 268435456L ;
randoms [k ]= x ;
}
while ( k++ < for_end ) ;}
{register integer for_end; k = 24 ;for_end = 54 ; if ( k <= for_end) do
{
x = randoms [k ]- randoms [k - 24 ];
if ( x < 0 )
x = x + 268435456L ;
randoms [k ]= x ;
}
while ( k++ < for_end ) ;}
jrandom = 54 ;
}
void
#ifdef HAVE_PROTOTYPES
zinitrandoms ( scaled seed )
#else
zinitrandoms ( seed )
scaled seed ;
#endif
{
fraction j, jj, k ;
char i ;
j = abs ( seed ) ;
while ( j >= 268435456L ) j = halfp ( j ) ;
k = 1 ;
{register integer for_end; i = 0 ;for_end = 54 ; if ( i <= for_end) do
{
jj = k ;
k = j - k ;
j = jj ;
if ( k < 0 )
k = k + 268435456L ;
randoms [( i * 21 ) % 55 ]= j ;
}
while ( i++ < for_end ) ;}
newrandoms () ;
newrandoms () ;
newrandoms () ;
}
scaled
#ifdef HAVE_PROTOTYPES
zunifrand ( scaled x )
#else
zunifrand ( x )
scaled x ;
#endif
{
register scaled Result; scaled y ;
if ( jrandom == 0 )
newrandoms () ;
else decr ( jrandom ) ;
y = takefraction ( abs ( x ) , randoms [jrandom ]) ;
if ( y == abs ( x ) )
Result = 0 ;
else if ( x > 0 )
Result = y ;
else Result = - (integer) y ;
return Result ;
}
scaled
#ifdef HAVE_PROTOTYPES
normrand ( void )
#else
normrand ( )
#endif
{
register scaled Result; integer x, u, l ;
do {
do { if ( jrandom == 0 )
newrandoms () ;
else decr ( jrandom ) ;
x = takefraction ( 112429L , randoms [jrandom ]- 134217728L ) ;
if ( jrandom == 0 )
newrandoms () ;
else decr ( jrandom ) ;
u = randoms [jrandom ];
} while ( ! ( abs ( x ) < u ) ) ;
x = makefraction ( x , u ) ;
l = 139548960L - mlog ( u ) ;
} while ( ! ( abvscd ( 1024 , l , x , x ) >= 0 ) ) ;
Result = x ;
return Result ;
}
#ifdef TEXMF_DEBUG
void
#ifdef HAVE_PROTOTYPES
zprintword ( memoryword w )
#else
zprintword ( w )
memoryword w ;
#endif
{
printint ( w .cint ) ;
printchar ( 32 ) ;
printscaled ( w .cint ) ;
printchar ( 32 ) ;
printscaled ( w .cint / 4096 ) ;
println () ;
printint ( w .hhfield .lhfield ) ;
printchar ( 61 ) ;
printint ( w .hhfield .b0 ) ;
printchar ( 58 ) ;
printint ( w .hhfield .b1 ) ;
printchar ( 59 ) ;
printint ( w .hhfield .v.RH ) ;
printchar ( 32 ) ;
printint ( w .qqqq .b0 ) ;
printchar ( 58 ) ;
printint ( w .qqqq .b1 ) ;
printchar ( 58 ) ;
printint ( w .qqqq .b2 ) ;
printchar ( 58 ) ;
printint ( w .qqqq .b3 ) ;
}
#endif /* TEXMF_DEBUG */
void
#ifdef HAVE_PROTOTYPES
zshowtokenlist ( integer p , integer q , integer l , integer nulltally )
#else
zshowtokenlist ( p , q , l , nulltally )
integer p ;
integer q ;
integer l ;
integer nulltally ;
#endif
{
/* 10 */ smallnumber class, c ;
integer r, v ;
class = 3 ;
tally = nulltally ;
while ( ( p != 0 ) && ( tally < l ) ) {
if ( p == q )
{
firstcount = tally ;
trickcount = tally + 1 + errorline - halferrorline ;
if ( trickcount < errorline )
trickcount = errorline ;
}
c = 9 ;
if ( ( p < 0 ) || ( p > memend ) )
{
print ( 492 ) ;
goto lab10 ;
}
if ( p < himemmin )
if ( mem [p ].hhfield .b1 == 12 )
if ( mem [p ].hhfield .b0 == 16 )
{
if ( class == 0 )
printchar ( 32 ) ;
v = mem [p + 1 ].cint ;
if ( v < 0 )
{
if ( class == 17 )
printchar ( 32 ) ;
printchar ( 91 ) ;
printscaled ( v ) ;
printchar ( 93 ) ;
c = 18 ;
}
else {
printscaled ( v ) ;
c = 0 ;
}
}
else if ( mem [p ].hhfield .b0 != 4 )
print ( 495 ) ;
else {
printchar ( 34 ) ;
print ( mem [p + 1 ].cint ) ;
printchar ( 34 ) ;
c = 4 ;
}
else if ( ( mem [p ].hhfield .b1 != 11 ) || ( mem [p ].hhfield .b0 < 1
) || ( mem [p ].hhfield .b0 > 19 ) )
print ( 495 ) ;
else {
gpointer = p ;
printcapsule () ;
c = 8 ;
}
else {
r = mem [p ].hhfield .lhfield ;
if ( r >= 9770 )
{
if ( r < 9920 )
{
print ( 497 ) ;
r = r - ( 9770 ) ;
}
else if ( r < 10070 )
{
print ( 498 ) ;
r = r - ( 9920 ) ;
}
else {
print ( 499 ) ;
r = r - ( 10070 ) ;
}
printint ( r ) ;
printchar ( 41 ) ;
c = 8 ;
}
else if ( r < 1 )
if ( r == 0 )
{
if ( class == 17 )
printchar ( 32 ) ;
print ( 496 ) ;
c = 18 ;
}
else print ( 493 ) ;
else {
r = hash [r ].v.RH ;
if ( ( r < 0 ) || ( r >= strptr ) )
print ( 494 ) ;
else {
c = charclass [strpool [strstart [r ]]];
if ( c == class )
switch ( c )
{case 9 :
printchar ( 46 ) ;
break ;
case 5 :
case 6 :
case 7 :
case 8 :
;
break ;
default:
printchar ( 32 ) ;
break ;
}
print ( r ) ;
}
}
}
class = c ;
p = mem [p ].hhfield .v.RH ;
}
if ( p != 0 )
print ( 491 ) ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
runaway ( void )
#else
runaway ( )
#endif
{
if ( scannerstatus > 2 )
{
printnl ( 634 ) ;
switch ( scannerstatus )
{case 3 :
print ( 635 ) ;
break ;
case 4 :
case 5 :
print ( 636 ) ;
break ;
case 6 :
print ( 637 ) ;
break ;
}
println () ;
showtokenlist ( mem [memtop - 2 ].hhfield .v.RH , 0 , errorline - 10 , 0
) ;
}
}
halfword
#ifdef HAVE_PROTOTYPES
getavail ( void )
#else
getavail ( )
#endif
{
register halfword Result; halfword p ;
p = avail ;
if ( p != 0 )
avail = mem [avail ].hhfield .v.RH ;
else if ( memend < memmax )
{
incr ( memend ) ;
p = memend ;
}
else {
decr ( himemmin ) ;
p = himemmin ;
if ( himemmin <= lomemmax )
{
runaway () ;
overflow ( 314 , memmax + 1 ) ;
}
}
mem [p ].hhfield .v.RH = 0 ;
;
#ifdef STAT
incr ( dynused ) ;
#endif /* STAT */
Result = p ;
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
zgetnode ( integer s )
#else
zgetnode ( s )
integer s ;
#endif
{
/* 40 10 20 */ register halfword Result; halfword p ;
halfword q ;
integer r ;
integer t, tt ;
lab20: p = rover ;
do {
q = p + mem [p ].hhfield .lhfield ;
while ( ( mem [q ].hhfield .v.RH == 268435455L ) ) {
t = mem [q + 1 ].hhfield .v.RH ;
tt = mem [q + 1 ].hhfield .lhfield ;
if ( q == rover )
rover = t ;
mem [t + 1 ].hhfield .lhfield = tt ;
mem [tt + 1 ].hhfield .v.RH = t ;
q = q + mem [q ].hhfield .lhfield ;
}
r = q - s ;
if ( r > toint ( p + 1 ) )
{
mem [p ].hhfield .lhfield = r - p ;
rover = p ;
goto lab40 ;
}
if ( r == p )
if ( mem [p + 1 ].hhfield .v.RH != p )
{
rover = mem [p + 1 ].hhfield .v.RH ;
t = mem [p + 1 ].hhfield .lhfield ;
mem [rover + 1 ].hhfield .lhfield = t ;
mem [t + 1 ].hhfield .v.RH = rover ;
goto lab40 ;
}
mem [p ].hhfield .lhfield = q - p ;
p = mem [p + 1 ].hhfield .v.RH ;
} while ( ! ( p == rover ) ) ;
if ( s == 1073741824L )
{
Result = 268435455L ;
goto lab10 ;
}
if ( lomemmax + 2 < himemmin )
if ( lomemmax + 2 <= 268435455L )
{
if ( himemmin - lomemmax >= 1998 )
t = lomemmax + 1000 ;
else t = lomemmax + 1 + ( himemmin - lomemmax ) / 2 ;
if ( t > 268435455L )
t = 268435455L ;
p = mem [rover + 1 ].hhfield .lhfield ;
q = lomemmax ;
mem [p + 1 ].hhfield .v.RH = q ;
mem [rover + 1 ].hhfield .lhfield = q ;
mem [q + 1 ].hhfield .v.RH = rover ;
mem [q + 1 ].hhfield .lhfield = p ;
mem [q ].hhfield .v.RH = 268435455L ;
mem [q ].hhfield .lhfield = t - lomemmax ;
lomemmax = t ;
mem [lomemmax ].hhfield .v.RH = 0 ;
mem [lomemmax ].hhfield .lhfield = 0 ;
rover = q ;
goto lab20 ;
}
overflow ( 314 , memmax + 1 ) ;
lab40: mem [r ].hhfield .v.RH = 0 ;
;
#ifdef STAT
varused = varused + s ;
#endif /* STAT */
Result = r ;
lab10: ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zfreenode ( halfword p , halfword s )
#else
zfreenode ( p , s )
halfword p ;
halfword s ;
#endif
{
halfword q ;
mem [p ].hhfield .lhfield = s ;
mem [p ].hhfield .v.RH = 268435455L ;
q = mem [rover + 1 ].hhfield .lhfield ;
mem [p + 1 ].hhfield .lhfield = q ;
mem [p + 1 ].hhfield .v.RH = rover ;
mem [rover + 1 ].hhfield .lhfield = p ;
mem [q + 1 ].hhfield .v.RH = p ;
;
#ifdef STAT
varused = varused - s ;
#endif /* STAT */
}
void
#ifdef HAVE_PROTOTYPES
zflushlist ( halfword p )
#else
zflushlist ( p )
halfword p ;
#endif
{
/* 30 */ halfword q, r ;
if ( p >= himemmin )
if ( p != memtop )
{
r = p ;
do {
q = r ;
r = mem [r ].hhfield .v.RH ;
;
#ifdef STAT
decr ( dynused ) ;
#endif /* STAT */
if ( r < himemmin )
goto lab30 ;
} while ( ! ( r == memtop ) ) ;
lab30: mem [q ].hhfield .v.RH = avail ;
avail = p ;
}
}
void
#ifdef HAVE_PROTOTYPES
zflushnodelist ( halfword p )
#else
zflushnodelist ( p )
halfword p ;
#endif
{
halfword q ;
while ( p != 0 ) {
q = p ;
p = mem [p ].hhfield .v.RH ;
if ( q < himemmin )
freenode ( q , 2 ) ;
else {
mem [q ].hhfield .v.RH = avail ;
avail = q ;
;
#ifdef STAT
decr ( dynused ) ;
#endif /* STAT */
}
}
}
#ifdef TEXMF_DEBUG
void
#ifdef HAVE_PROTOTYPES
zcheckmem ( boolean printlocs )
#else
zcheckmem ( printlocs )
boolean printlocs ;
#endif
{
/* 31 32 */ halfword p, q, r ;
boolean clobbered ;
{register integer for_end; p = 0 ;for_end = lomemmax ; if ( p <= for_end)
do
freearr [p ]= false ;
while ( p++ < for_end ) ;}
{register integer for_end; p = himemmin ;for_end = memend ; if ( p <=
for_end) do
freearr [p ]= false ;
while ( p++ < for_end ) ;}
p = avail ;
q = 0 ;
clobbered = false ;
while ( p != 0 ) {
if ( ( p > memend ) || ( p < himemmin ) )
clobbered = true ;
else if ( freearr [p ])
clobbered = true ;
if ( clobbered )
{
printnl ( 315 ) ;
printint ( q ) ;
goto lab31 ;
}
freearr [p ]= true ;
q = p ;
p = mem [q ].hhfield .v.RH ;
}
lab31: ;
p = rover ;
q = 0 ;
clobbered = false ;
do {
if ( ( p >= lomemmax ) )
clobbered = true ;
else if ( ( mem [p + 1 ].hhfield .v.RH >= lomemmax ) )
clobbered = true ;
else if ( ! ( ( mem [p ].hhfield .v.RH == 268435455L ) ) || ( mem [p ]
.hhfield .lhfield < 2 ) || ( p + mem [p ].hhfield .lhfield > lomemmax )
|| ( mem [mem [p + 1 ].hhfield .v.RH + 1 ].hhfield .lhfield != p ) )
clobbered = true ;
if ( clobbered )
{
printnl ( 316 ) ;
printint ( q ) ;
goto lab32 ;
}
{register integer for_end; q = p ;for_end = p + mem [p ].hhfield
.lhfield - 1 ; if ( q <= for_end) do
{
if ( freearr [q ])
{
printnl ( 317 ) ;
printint ( q ) ;
goto lab32 ;
}
freearr [q ]= true ;
}
while ( q++ < for_end ) ;}
q = p ;
p = mem [p + 1 ].hhfield .v.RH ;
} while ( ! ( p == rover ) ) ;
lab32: ;
p = 0 ;
while ( p <= lomemmax ) {
if ( ( mem [p ].hhfield .v.RH == 268435455L ) )
{
printnl ( 318 ) ;
printint ( p ) ;
}
while ( ( p <= lomemmax ) && ! freearr [p ]) incr ( p ) ;
while ( ( p <= lomemmax ) && freearr [p ]) incr ( p ) ;
}
q = 13 ;
p = mem [q ].hhfield .v.RH ;
while ( p != 13 ) {
if ( mem [p + 1 ].hhfield .lhfield != q )
{
printnl ( 595 ) ;
printint ( p ) ;
}
p = mem [p + 1 ].hhfield .v.RH ;
r = 19 ;
do {
if ( mem [mem [p ].hhfield .lhfield + 1 ].cint >= mem [r + 1 ]
.cint )
{
printnl ( 596 ) ;
printint ( p ) ;
}
r = mem [p ].hhfield .lhfield ;
q = p ;
p = mem [q ].hhfield .v.RH ;
} while ( ! ( r == 0 ) ) ;
}
if ( printlocs )
{
printnl ( 319 ) ;
{register integer for_end; p = 0 ;for_end = lomemmax ; if ( p <=
for_end) do
if ( ! freearr [p ]&& ( ( p > waslomax ) || wasfree [p ]) )
{
printchar ( 32 ) ;
printint ( p ) ;
}
while ( p++ < for_end ) ;}
{register integer for_end; p = himemmin ;for_end = memend ; if ( p <=
for_end) do
if ( ! freearr [p ]&& ( ( p < washimin ) || ( p > wasmemend ) ||
wasfree [p ]) )
{
printchar ( 32 ) ;
printint ( p ) ;
}
while ( p++ < for_end ) ;}
}
{register integer for_end; p = 0 ;for_end = lomemmax ; if ( p <= for_end)
do
wasfree [p ]= freearr [p ];
while ( p++ < for_end ) ;}
{register integer for_end; p = himemmin ;for_end = memend ; if ( p <=
for_end) do
wasfree [p ]= freearr [p ];
while ( p++ < for_end ) ;}
wasmemend = memend ;
waslomax = lomemmax ;
washimin = himemmin ;
}
#endif /* TEXMF_DEBUG */
#ifdef TEXMF_DEBUG
void
#ifdef HAVE_PROTOTYPES
zsearchmem ( halfword p )
#else
zsearchmem ( p )
halfword p ;
#endif
{
integer q ;
{register integer for_end; q = 0 ;for_end = lomemmax ; if ( q <= for_end)
do
{
if ( mem [q ].hhfield .v.RH == p )
{
printnl ( 320 ) ;
printint ( q ) ;
printchar ( 41 ) ;
}
if ( mem [q ].hhfield .lhfield == p )
{
printnl ( 321 ) ;
printint ( q ) ;
printchar ( 41 ) ;
}
}
while ( q++ < for_end ) ;}
{register integer for_end; q = himemmin ;for_end = memend ; if ( q <=
for_end) do
{
if ( mem [q ].hhfield .v.RH == p )
{
printnl ( 320 ) ;
printint ( q ) ;
printchar ( 41 ) ;
}
if ( mem [q ].hhfield .lhfield == p )
{
printnl ( 321 ) ;
printint ( q ) ;
printchar ( 41 ) ;
}
}
while ( q++ < for_end ) ;}
{register integer for_end; q = 1 ;for_end = 9769 ; if ( q <= for_end) do
{
if ( eqtb [q ].v.RH == p )
{
printnl ( 457 ) ;
printint ( q ) ;
printchar ( 41 ) ;
}
}
while ( q++ < for_end ) ;}
}
#endif /* TEXMF_DEBUG */
void
#ifdef HAVE_PROTOTYPES
zprintop ( quarterword c )
#else
zprintop ( c )
quarterword c ;
#endif
{
if ( c <= 15 )
printtype ( c ) ;
else switch ( c )
{case 30 :
print ( 346 ) ;
break ;
case 31 :
print ( 347 ) ;
break ;
case 32 :
print ( 348 ) ;
break ;
case 33 :
print ( 349 ) ;
break ;
case 34 :
print ( 350 ) ;
break ;
case 35 :
print ( 351 ) ;
break ;
case 36 :
print ( 352 ) ;
break ;
case 37 :
print ( 353 ) ;
break ;
case 38 :
print ( 354 ) ;
break ;
case 39 :
print ( 355 ) ;
break ;
case 40 :
print ( 356 ) ;
break ;
case 41 :
print ( 357 ) ;
break ;
case 42 :
print ( 358 ) ;
break ;
case 43 :
print ( 359 ) ;
break ;
case 44 :
print ( 360 ) ;
break ;
case 45 :
print ( 361 ) ;
break ;
case 46 :
print ( 362 ) ;
break ;
case 47 :
print ( 363 ) ;
break ;
case 48 :
print ( 364 ) ;
break ;
case 49 :
print ( 365 ) ;
break ;
case 50 :
print ( 366 ) ;
break ;
case 51 :
print ( 367 ) ;
break ;
case 52 :
print ( 368 ) ;
break ;
case 53 :
print ( 369 ) ;
break ;
case 54 :
print ( 370 ) ;
break ;
case 55 :
print ( 371 ) ;
break ;
case 56 :
print ( 372 ) ;
break ;
case 57 :
print ( 373 ) ;
break ;
case 58 :
print ( 374 ) ;
break ;
case 59 :
print ( 375 ) ;
break ;
case 60 :
print ( 376 ) ;
break ;
case 61 :
print ( 377 ) ;
break ;
case 62 :
print ( 378 ) ;
break ;
case 63 :
print ( 379 ) ;
break ;
case 64 :
print ( 380 ) ;
break ;
case 65 :
print ( 381 ) ;
break ;
case 66 :
print ( 382 ) ;
break ;
case 67 :
print ( 383 ) ;
break ;
case 68 :
print ( 384 ) ;
break ;
case 69 :
printchar ( 43 ) ;
break ;
case 70 :
printchar ( 45 ) ;
break ;
case 71 :
printchar ( 42 ) ;
break ;
case 72 :
printchar ( 47 ) ;
break ;
case 73 :
print ( 385 ) ;
break ;
case 74 :
print ( 309 ) ;
break ;
case 75 :
print ( 386 ) ;
break ;
case 76 :
print ( 387 ) ;
break ;
case 77 :
printchar ( 60 ) ;
break ;
case 78 :
print ( 388 ) ;
break ;
case 79 :
printchar ( 62 ) ;
break ;
case 80 :
print ( 389 ) ;
break ;
case 81 :
printchar ( 61 ) ;
break ;
case 82 :
print ( 390 ) ;
break ;
case 83 :
print ( 38 ) ;
break ;
case 84 :
print ( 391 ) ;
break ;
case 85 :
print ( 392 ) ;
break ;
case 86 :
print ( 393 ) ;
break ;
case 87 :
print ( 394 ) ;
break ;
case 88 :
print ( 395 ) ;
break ;
case 89 :
print ( 396 ) ;
break ;
case 90 :
print ( 397 ) ;
break ;
case 91 :
print ( 398 ) ;
break ;
case 92 :
print ( 399 ) ;
break ;
case 94 :
print ( 400 ) ;
break ;
case 95 :
print ( 401 ) ;
break ;
case 96 :
print ( 402 ) ;
break ;
case 97 :
print ( 403 ) ;
break ;
case 98 :
print ( 404 ) ;
break ;
case 99 :
print ( 405 ) ;
break ;
case 100 :
print ( 406 ) ;
break ;
default:
print ( 407 ) ;
break ;
}
}
void
#ifdef HAVE_PROTOTYPES
fixdateandtime ( void )
#else
fixdateandtime ( )
#endif
{
dateandtime ( internal [17 ], internal [16 ], internal [15 ],
internal [14 ]) ;
internal [17 ]= internal [17 ]* 65536L ;
internal [16 ]= internal [16 ]* 65536L ;
internal [15 ]= internal [15 ]* 65536L ;
internal [14 ]= internal [14 ]* 65536L ;
}
halfword
#ifdef HAVE_PROTOTYPES
zidlookup ( integer j , integer l )
#else
zidlookup ( j , l )
integer j ;
integer l ;
#endif
{
/* 40 */ register halfword Result; integer h ;
halfword p ;
halfword k ;
if ( l == 1 )
{
p = buffer [j ]+ 1 ;
hash [p ].v.RH = p - 1 ;
goto lab40 ;
}
h = buffer [j ];
{register integer for_end; k = j + 1 ;for_end = j + l - 1 ; if ( k <=
for_end) do
{
h = h + h + buffer [k ];
while ( h >= 7919 ) h = h - 7919 ;
}
while ( k++ < for_end ) ;}
p = h + 257 ;
while ( true ) {
if ( hash [p ].v.RH > 0 )
if ( ( strstart [hash [p ].v.RH + 1 ]- strstart [hash [p ].v.RH ])
== l )
if ( streqbuf ( hash [p ].v.RH , j ) )
goto lab40 ;
if ( hash [p ].lhfield == 0 )
{
if ( hash [p ].v.RH > 0 )
{
do {
if ( ( hashused == 257 ) )
overflow ( 456 , 9500 ) ;
decr ( hashused ) ;
} while ( ! ( hash [hashused ].v.RH == 0 ) ) ;
hash [p ].lhfield = hashused ;
p = hashused ;
}
{
if ( poolptr + l > maxpoolptr )
{
if ( poolptr + l > poolsize )
overflow ( 257 , poolsize - initpoolptr ) ;
maxpoolptr = poolptr + l ;
}
}
{register integer for_end; k = j ;for_end = j + l - 1 ; if ( k <=
for_end) do
{
strpool [poolptr ]= buffer [k ];
incr ( poolptr ) ;
}
while ( k++ < for_end ) ;}
hash [p ].v.RH = makestring () ;
strref [hash [p ].v.RH ]= 127 ;
;
#ifdef STAT
incr ( stcount ) ;
#endif /* STAT */
goto lab40 ;
}
p = hash [p ].lhfield ;
}
lab40: Result = p ;
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
znewnumtok ( scaled v )
#else
znewnumtok ( v )
scaled v ;
#endif
{
register halfword Result; halfword p ;
p = getnode ( 2 ) ;
mem [p + 1 ].cint = v ;
mem [p ].hhfield .b0 = 16 ;
mem [p ].hhfield .b1 = 12 ;
Result = p ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zflushtokenlist ( halfword p )
#else
zflushtokenlist ( p )
halfword p ;
#endif
{
halfword q ;
while ( p != 0 ) {
q = p ;
p = mem [p ].hhfield .v.RH ;
if ( q >= himemmin )
{
mem [q ].hhfield .v.RH = avail ;
avail = q ;
;
#ifdef STAT
decr ( dynused ) ;
#endif /* STAT */
}
else {
switch ( mem [q ].hhfield .b0 )
{case 1 :
case 2 :
case 16 :
;
break ;
case 4 :
{
if ( strref [mem [q + 1 ].cint ]< 127 )
if ( strref [mem [q + 1 ].cint ]> 1 )
decr ( strref [mem [q + 1 ].cint ]) ;
else flushstring ( mem [q + 1 ].cint ) ;
}
break ;
case 3 :
case 5 :
case 7 :
case 12 :
case 10 :
case 6 :
case 9 :
case 8 :
case 11 :
case 14 :
case 13 :
case 17 :
case 18 :
case 19 :
{
gpointer = q ;
tokenrecycle () ;
}
break ;
default:
confusion ( 490 ) ;
break ;
}
freenode ( q , 2 ) ;
}
}
}
void
#ifdef HAVE_PROTOTYPES
zdeletemacref ( halfword p )
#else
zdeletemacref ( p )
halfword p ;
#endif
{
if ( mem [p ].hhfield .lhfield == 0 )
flushtokenlist ( p ) ;
else decr ( mem [p ].hhfield .lhfield ) ;
}
void
#ifdef HAVE_PROTOTYPES
zprintcmdmod ( integer c , integer m )
#else
zprintcmdmod ( c , m )
integer c ;
integer m ;
#endif
{
switch ( c )
{case 18 :
print ( 461 ) ;
break ;
case 77 :
print ( 460 ) ;
break ;
case 59 :
print ( 463 ) ;
break ;
case 72 :
print ( 462 ) ;
break ;
case 79 :
print ( 459 ) ;
break ;
case 32 :
print ( 464 ) ;
break ;
case 81 :
print ( 58 ) ;
break ;
case 82 :
print ( 44 ) ;
break ;
case 57 :
print ( 465 ) ;
break ;
case 19 :
print ( 466 ) ;
break ;
case 60 :
print ( 467 ) ;
break ;
case 27 :
print ( 468 ) ;
break ;
case 11 :
print ( 469 ) ;
break ;
case 80 :
print ( 458 ) ;
break ;
case 84 :
print ( 452 ) ;
break ;
case 26 :
print ( 470 ) ;
break ;
case 6 :
print ( 471 ) ;
break ;
case 9 :
print ( 472 ) ;
break ;
case 70 :
print ( 473 ) ;
break ;
case 73 :
print ( 474 ) ;
break ;
case 13 :
print ( 475 ) ;
break ;
case 46 :
print ( 123 ) ;
break ;
case 63 :
print ( 91 ) ;
break ;
case 14 :
print ( 476 ) ;
break ;
case 15 :
print ( 477 ) ;
break ;
case 69 :
print ( 478 ) ;
break ;
case 28 :
print ( 479 ) ;
break ;
case 47 :
print ( 407 ) ;
break ;
case 24 :
print ( 480 ) ;
break ;
case 7 :
printchar ( 92 ) ;
break ;
case 65 :
print ( 125 ) ;
break ;
case 64 :
print ( 93 ) ;
break ;
case 12 :
print ( 481 ) ;
break ;
case 8 :
print ( 482 ) ;
break ;
case 83 :
print ( 59 ) ;
break ;
case 17 :
print ( 483 ) ;
break ;
case 78 :
print ( 484 ) ;
break ;
case 74 :
print ( 485 ) ;
break ;
case 35 :
print ( 486 ) ;
break ;
case 58 :
print ( 487 ) ;
break ;
case 71 :
print ( 488 ) ;
break ;
case 75 :
print ( 489 ) ;
break ;
case 16 :
if ( m <= 2 )
if ( m == 1 )
print ( 651 ) ;
else if ( m < 1 )
print ( 453 ) ;
else print ( 652 ) ;
else if ( m == 53 )
print ( 653 ) ;
else if ( m == 44 )
print ( 654 ) ;
else print ( 655 ) ;
break ;
case 4 :
if ( m <= 1 )
if ( m == 1 )
print ( 658 ) ;
else print ( 454 ) ;
else if ( m == 9770 )
print ( 656 ) ;
else print ( 657 ) ;
break ;
case 61 :
switch ( m )
{case 1 :
print ( 660 ) ;
break ;
case 2 :
printchar ( 64 ) ;
break ;
case 3 :
print ( 661 ) ;
break ;
default:
print ( 659 ) ;
break ;
}
break ;
case 56 :
if ( m >= 9770 )
if ( m == 9770 )
print ( 672 ) ;
else if ( m == 9920 )
print ( 673 ) ;
else print ( 674 ) ;
else if ( m < 2 )
print ( 675 ) ;
else if ( m == 2 )
print ( 676 ) ;
else print ( 677 ) ;
break ;
case 3 :
if ( m == 0 )
print ( 687 ) ;
else print ( 613 ) ;
break ;
case 1 :
case 2 :
switch ( m )
{case 1 :
print ( 714 ) ;
break ;
case 2 :
print ( 451 ) ;
break ;
case 3 :
print ( 715 ) ;
break ;
default:
print ( 716 ) ;
break ;
}
break ;
case 33 :
case 34 :
case 37 :
case 55 :
case 45 :
case 50 :
case 36 :
case 43 :
case 54 :
case 48 :
case 51 :
case 52 :
printop ( m ) ;
break ;
case 30 :
printtype ( m ) ;
break ;
case 85 :
if ( m == 0 )
print ( 908 ) ;
else print ( 909 ) ;
break ;
case 23 :
switch ( m )
{case 0 :
print ( 271 ) ;
break ;
case 1 :
print ( 272 ) ;
break ;
case 2 :
print ( 273 ) ;
break ;
default:
print ( 915 ) ;
break ;
}
break ;
case 21 :
if ( m == 0 )
print ( 916 ) ;
else print ( 917 ) ;
break ;
case 22 :
switch ( m )
{case 0 :
print ( 931 ) ;
break ;
case 1 :
print ( 932 ) ;
break ;
case 2 :
print ( 933 ) ;
break ;
case 3 :
print ( 934 ) ;
break ;
default:
print ( 935 ) ;
break ;
}
break ;
case 31 :
case 62 :
{
if ( c == 31 )
print ( 938 ) ;
else print ( 939 ) ;
print ( 940 ) ;
print ( hash [m ].v.RH ) ;
}
break ;
case 41 :
if ( m == 0 )
print ( 941 ) ;
else print ( 942 ) ;
break ;
case 10 :
print ( 943 ) ;
break ;
case 53 :
case 44 :
case 49 :
{
printcmdmod ( 16 , c ) ;
print ( 944 ) ;
println () ;
showtokenlist ( mem [mem [m ].hhfield .v.RH ].hhfield .v.RH , 0 ,
1000 , 0 ) ;
}
break ;
case 5 :
print ( 945 ) ;
break ;
case 40 :
print ( intname [m ]) ;
break ;
case 68 :
if ( m == 1 )
print ( 952 ) ;
else if ( m == 0 )
print ( 953 ) ;
else print ( 954 ) ;
break ;
case 66 :
if ( m == 6 )
print ( 955 ) ;
else print ( 956 ) ;
break ;
case 67 :
if ( m == 0 )
print ( 957 ) ;
else print ( 958 ) ;
break ;
case 25 :
if ( m < 1 )
print ( 988 ) ;
else if ( m == 1 )
print ( 989 ) ;
else print ( 990 ) ;
break ;
case 20 :
switch ( m )
{case 0 :
print ( 1000 ) ;
break ;
case 1 :
print ( 1001 ) ;
break ;
case 2 :
print ( 1002 ) ;
break ;
case 3 :
print ( 1003 ) ;
break ;
default:
print ( 1004 ) ;
break ;
}
break ;
case 76 :
switch ( m )
{case 0 :
print ( 1022 ) ;
break ;
case 1 :
print ( 1023 ) ;
break ;
case 2 :
print ( 1025 ) ;
break ;
case 3 :
print ( 1027 ) ;
break ;
case 5 :
print ( 1024 ) ;
break ;
case 6 :
print ( 1026 ) ;
break ;
case 7 :
print ( 1028 ) ;
break ;
case 11 :
print ( 1029 ) ;
break ;
default:
print ( 1030 ) ;
break ;
}
break ;
case 29 :
if ( m == 16 )
print ( 1055 ) ;
else print ( 1054 ) ;
break ;
default:
print ( 600 ) ;
break ;
}
}
void
#ifdef HAVE_PROTOTYPES
zshowmacro ( halfword p , integer q , integer l )
#else
zshowmacro ( p , q , l )
halfword p ;
integer q ;
integer l ;
#endif
{
/* 10 */ halfword r ;
p = mem [p ].hhfield .v.RH ;
while ( mem [p ].hhfield .lhfield > 7 ) {
r = mem [p ].hhfield .v.RH ;
mem [p ].hhfield .v.RH = 0 ;
showtokenlist ( p , 0 , l , 0 ) ;
mem [p ].hhfield .v.RH = r ;
p = r ;
if ( l > 0 )
l = l - tally ;
else goto lab10 ;
}
tally = 0 ;
switch ( mem [p ].hhfield .lhfield )
{case 0 :
print ( 500 ) ;
break ;
case 1 :
case 2 :
case 3 :
{
printchar ( 60 ) ;
printcmdmod ( 56 , mem [p ].hhfield .lhfield ) ;
print ( 501 ) ;
}
break ;
case 4 :
print ( 502 ) ;
break ;
case 5 :
print ( 503 ) ;
break ;
case 6 :
print ( 504 ) ;
break ;
case 7 :
print ( 505 ) ;
break ;
}
showtokenlist ( mem [p ].hhfield .v.RH , q , l - tally , 0 ) ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zinitbignode ( halfword p )
#else
zinitbignode ( p )
halfword p ;
#endif
{
halfword q ;
smallnumber s ;
s = bignodesize [mem [p ].hhfield .b0 ];
q = getnode ( s ) ;
do {
s = s - 2 ;
{
mem [q + s ].hhfield .b0 = 19 ;
serialno = serialno + 64 ;
mem [q + s + 1 ].cint = serialno ;
}
mem [q + s ].hhfield .b1 = halfp ( s ) + 5 ;
mem [q + s ].hhfield .v.RH = 0 ;
} while ( ! ( s == 0 ) ) ;
mem [q ].hhfield .v.RH = p ;
mem [p + 1 ].cint = q ;
}
halfword
#ifdef HAVE_PROTOTYPES
idtransform ( void )
#else
idtransform ( )
#endif
{
register halfword Result; halfword p, q, r ;
p = getnode ( 2 ) ;
mem [p ].hhfield .b0 = 13 ;
mem [p ].hhfield .b1 = 11 ;
mem [p + 1 ].cint = 0 ;
initbignode ( p ) ;
q = mem [p + 1 ].cint ;
r = q + 12 ;
do {
r = r - 2 ;
mem [r ].hhfield .b0 = 16 ;
mem [r + 1 ].cint = 0 ;
} while ( ! ( r == q ) ) ;
mem [q + 5 ].cint = 65536L ;
mem [q + 11 ].cint = 65536L ;
Result = p ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
znewroot ( halfword x )
#else
znewroot ( x )
halfword x ;
#endif
{
halfword p ;
p = getnode ( 2 ) ;
mem [p ].hhfield .b0 = 0 ;
mem [p ].hhfield .b1 = 0 ;
mem [p ].hhfield .v.RH = x ;
eqtb [x ].v.RH = p ;
}
void
#ifdef HAVE_PROTOTYPES
zprintvariablename ( halfword p )
#else
zprintvariablename ( p )
halfword p ;
#endif
{
/* 40 10 */ halfword q ;
halfword r ;
while ( mem [p ].hhfield .b1 >= 5 ) {
switch ( mem [p ].hhfield .b1 )
{case 5 :
printchar ( 120 ) ;
break ;
case 6 :
printchar ( 121 ) ;
break ;
case 7 :
print ( 508 ) ;
break ;
case 8 :
print ( 509 ) ;
break ;
case 9 :
print ( 510 ) ;
break ;
case 10 :
print ( 511 ) ;
break ;
case 11 :
{
print ( 512 ) ;
printint ( p - 0 ) ;
goto lab10 ;
}
break ;
}
print ( 513 ) ;
p = mem [p - 2 * ( mem [p ].hhfield .b1 - 5 ) ].hhfield .v.RH ;
}
q = 0 ;
while ( mem [p ].hhfield .b1 > 1 ) {
if ( mem [p ].hhfield .b1 == 3 )
{
r = newnumtok ( mem [p + 2 ].cint ) ;
do {
p = mem [p ].hhfield .v.RH ;
} while ( ! ( mem [p ].hhfield .b1 == 4 ) ) ;
}
else if ( mem [p ].hhfield .b1 == 2 )
{
p = mem [p ].hhfield .v.RH ;
goto lab40 ;
}
else {
if ( mem [p ].hhfield .b1 != 4 )
confusion ( 507 ) ;
r = getavail () ;
mem [r ].hhfield .lhfield = mem [p + 2 ].hhfield .lhfield ;
}
mem [r ].hhfield .v.RH = q ;
q = r ;
lab40: p = mem [p + 2 ].hhfield .v.RH ;
}
r = getavail () ;
mem [r ].hhfield .lhfield = mem [p ].hhfield .v.RH ;
mem [r ].hhfield .v.RH = q ;
if ( mem [p ].hhfield .b1 == 1 )
print ( 506 ) ;
showtokenlist ( r , 0 , 2147483647L , tally ) ;
flushtokenlist ( r ) ;
lab10: ;
}
boolean
#ifdef HAVE_PROTOTYPES
zinteresting ( halfword p )
#else
zinteresting ( p )
halfword p ;
#endif
{
register boolean Result; smallnumber t ;
if ( internal [3 ]> 0 )
Result = true ;
else {
t = mem [p ].hhfield .b1 ;
if ( t >= 5 )
if ( t != 11 )
t = mem [mem [p - 2 * ( t - 5 ) ].hhfield .v.RH ].hhfield .b1 ;
Result = ( t != 11 ) ;
}
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
znewstructure ( halfword p )
#else
znewstructure ( p )
halfword p ;
#endif
{
register halfword Result; halfword q, r ;
switch ( mem [p ].hhfield .b1 )
{case 0 :
{
q = mem [p ].hhfield .v.RH ;
r = getnode ( 2 ) ;
eqtb [q ].v.RH = r ;
}
break ;
case 3 :
{
q = p ;
do {
q = mem [q ].hhfield .v.RH ;
} while ( ! ( mem [q ].hhfield .b1 == 4 ) ) ;
q = mem [q + 2 ].hhfield .v.RH ;
r = q + 1 ;
do {
q = r ;
r = mem [r ].hhfield .v.RH ;
} while ( ! ( r == p ) ) ;
r = getnode ( 3 ) ;
mem [q ].hhfield .v.RH = r ;
mem [r + 2 ].cint = mem [p + 2 ].cint ;
}
break ;
case 4 :
{
q = mem [p + 2 ].hhfield .v.RH ;
r = mem [q + 1 ].hhfield .lhfield ;
do {
q = r ;
r = mem [r ].hhfield .v.RH ;
} while ( ! ( r == p ) ) ;
r = getnode ( 3 ) ;
mem [q ].hhfield .v.RH = r ;
mem [r + 2 ]= mem [p + 2 ];
if ( mem [p + 2 ].hhfield .lhfield == 0 )
{
q = mem [p + 2 ].hhfield .v.RH + 1 ;
while ( mem [q ].hhfield .v.RH != p ) q = mem [q ].hhfield .v.RH ;
mem [q ].hhfield .v.RH = r ;
}
}
break ;
default:
confusion ( 514 ) ;
break ;
}
mem [r ].hhfield .v.RH = mem [p ].hhfield .v.RH ;
mem [r ].hhfield .b0 = 21 ;
mem [r ].hhfield .b1 = mem [p ].hhfield .b1 ;
mem [r + 1 ].hhfield .lhfield = p ;
mem [p ].hhfield .b1 = 2 ;
q = getnode ( 3 ) ;
mem [p ].hhfield .v.RH = q ;
mem [r + 1 ].hhfield .v.RH = q ;
mem [q + 2 ].hhfield .v.RH = r ;
mem [q ].hhfield .b0 = 0 ;
mem [q ].hhfield .b1 = 4 ;
mem [q ].hhfield .v.RH = 17 ;
mem [q + 2 ].hhfield .lhfield = 0 ;
Result = r ;
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
zfindvariable ( halfword t )
#else
zfindvariable ( t )
halfword t ;
#endif
{
/* 10 */ register halfword Result; halfword p, q, r, s ;
halfword pp, qq, rr, ss ;
integer n ;
memoryword saveword ;
p = mem [t ].hhfield .lhfield ;
t = mem [t ].hhfield .v.RH ;
if ( eqtb [p ].lhfield % 86 != 41 )
{
Result = 0 ;
goto lab10 ;
}
if ( eqtb [p ].v.RH == 0 )
newroot ( p ) ;
p = eqtb [p ].v.RH ;
pp = p ;
while ( t != 0 ) {
if ( mem [pp ].hhfield .b0 != 21 )
{
if ( mem [pp ].hhfield .b0 > 21 )
{
Result = 0 ;
goto lab10 ;
}
ss = newstructure ( pp ) ;
if ( p == pp )
p = ss ;
pp = ss ;
}
if ( mem [p ].hhfield .b0 != 21 )
p = newstructure ( p ) ;
if ( t < himemmin )
{
n = mem [t + 1 ].cint ;
pp = mem [mem [pp + 1 ].hhfield .lhfield ].hhfield .v.RH ;
q = mem [mem [p + 1 ].hhfield .lhfield ].hhfield .v.RH ;
saveword = mem [q + 2 ];
mem [q + 2 ].cint = 2147483647L ;
s = p + 1 ;
do {
r = s ;
s = mem [s ].hhfield .v.RH ;
} while ( ! ( n <= mem [s + 2 ].cint ) ) ;
if ( n == mem [s + 2 ].cint )
p = s ;
else {
p = getnode ( 3 ) ;
mem [r ].hhfield .v.RH = p ;
mem [p ].hhfield .v.RH = s ;
mem [p + 2 ].cint = n ;
mem [p ].hhfield .b1 = 3 ;
mem [p ].hhfield .b0 = 0 ;
}
mem [q + 2 ]= saveword ;
}
else {
n = mem [t ].hhfield .lhfield ;
ss = mem [pp + 1 ].hhfield .lhfield ;
do {
rr = ss ;
ss = mem [ss ].hhfield .v.RH ;
} while ( ! ( n <= mem [ss + 2 ].hhfield .lhfield ) ) ;
if ( n < mem [ss + 2 ].hhfield .lhfield )
{
qq = getnode ( 3 ) ;
mem [rr ].hhfield .v.RH = qq ;
mem [qq ].hhfield .v.RH = ss ;
mem [qq + 2 ].hhfield .lhfield = n ;
mem [qq ].hhfield .b1 = 4 ;
mem [qq ].hhfield .b0 = 0 ;
mem [qq + 2 ].hhfield .v.RH = pp ;
ss = qq ;
}
if ( p == pp )
{
p = ss ;
pp = ss ;
}
else {
pp = ss ;
s = mem [p + 1 ].hhfield .lhfield ;
do {
r = s ;
s = mem [s ].hhfield .v.RH ;
} while ( ! ( n <= mem [s + 2 ].hhfield .lhfield ) ) ;
if ( n == mem [s + 2 ].hhfield .lhfield )
p = s ;
else {
q = getnode ( 3 ) ;
mem [r ].hhfield .v.RH = q ;
mem [q ].hhfield .v.RH = s ;
mem [q + 2 ].hhfield .lhfield = n ;
mem [q ].hhfield .b1 = 4 ;
mem [q ].hhfield .b0 = 0 ;
mem [q + 2 ].hhfield .v.RH = p ;
p = q ;
}
}
}
t = mem [t ].hhfield .v.RH ;
}
if ( mem [pp ].hhfield .b0 >= 21 )
if ( mem [pp ].hhfield .b0 == 21 )
pp = mem [pp + 1 ].hhfield .lhfield ;
else {
Result = 0 ;
goto lab10 ;
}
if ( mem [p ].hhfield .b0 == 21 )
p = mem [p + 1 ].hhfield .lhfield ;
if ( mem [p ].hhfield .b0 == 0 )
{
if ( mem [pp ].hhfield .b0 == 0 )
{
mem [pp ].hhfield .b0 = 15 ;
mem [pp + 1 ].cint = 0 ;
}
mem [p ].hhfield .b0 = mem [pp ].hhfield .b0 ;
mem [p + 1 ].cint = 0 ;
}
Result = p ;
lab10: ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zprintpath ( halfword h , strnumber s , boolean nuline )
#else
zprintpath ( h , s , nuline )
halfword h ;
strnumber s ;
boolean nuline ;
#endif
{
/* 30 31 */ halfword p, q ;
printdiagnostic ( 516 , s , nuline ) ;
println () ;
p = h ;
do {
q = mem [p ].hhfield .v.RH ;
if ( ( p == 0 ) || ( q == 0 ) )
{
printnl ( 259 ) ;
goto lab30 ;
}
printtwo ( mem [p + 1 ].cint , mem [p + 2 ].cint ) ;
switch ( mem [p ].hhfield .b1 )
{case 0 :
{
if ( mem [p ].hhfield .b0 == 4 )
print ( 517 ) ;
if ( ( mem [q ].hhfield .b0 != 0 ) || ( q != h ) )
q = 0 ;
goto lab31 ;
}
break ;
case 1 :
{
print ( 523 ) ;
printtwo ( mem [p + 5 ].cint , mem [p + 6 ].cint ) ;
print ( 522 ) ;
if ( mem [q ].hhfield .b0 != 1 )
print ( 524 ) ;
else printtwo ( mem [q + 3 ].cint , mem [q + 4 ].cint ) ;
goto lab31 ;
}
break ;
case 4 :
if ( ( mem [p ].hhfield .b0 != 1 ) && ( mem [p ].hhfield .b0 != 4 )
)
print ( 517 ) ;
break ;
case 3 :
case 2 :
{
if ( mem [p ].hhfield .b0 == 4 )
print ( 524 ) ;
if ( mem [p ].hhfield .b1 == 3 )
{
print ( 520 ) ;
printscaled ( mem [p + 5 ].cint ) ;
}
else {
nsincos ( mem [p + 5 ].cint ) ;
printchar ( 123 ) ;
printscaled ( ncos ) ;
printchar ( 44 ) ;
printscaled ( nsin ) ;
}
printchar ( 125 ) ;
}
break ;
default:
print ( 259 ) ;
break ;
}
if ( mem [q ].hhfield .b0 <= 1 )
print ( 518 ) ;
else if ( ( mem [p + 6 ].cint != 65536L ) || ( mem [q + 4 ].cint !=
65536L ) )
{
print ( 521 ) ;
if ( mem [p + 6 ].cint < 0 )
print ( 463 ) ;
printscaled ( abs ( mem [p + 6 ].cint ) ) ;
if ( mem [p + 6 ].cint != mem [q + 4 ].cint )
{
print ( 522 ) ;
if ( mem [q + 4 ].cint < 0 )
print ( 463 ) ;
printscaled ( abs ( mem [q + 4 ].cint ) ) ;
}
}
lab31: ;
p = q ;
if ( ( p != h ) || ( mem [h ].hhfield .b0 != 0 ) )
{
printnl ( 519 ) ;
if ( mem [p ].hhfield .b0 == 2 )
{
nsincos ( mem [p + 3 ].cint ) ;
printchar ( 123 ) ;
printscaled ( ncos ) ;
printchar ( 44 ) ;
printscaled ( nsin ) ;
printchar ( 125 ) ;
}
else if ( mem [p ].hhfield .b0 == 3 )
{
print ( 520 ) ;
printscaled ( mem [p + 3 ].cint ) ;
printchar ( 125 ) ;
}
}
} while ( ! ( p == h ) ) ;
if ( mem [h ].hhfield .b0 != 0 )
print ( 384 ) ;
lab30: enddiagnostic ( true ) ;
}
void
#ifdef HAVE_PROTOTYPES
zprintweight ( halfword q , integer xoff )
#else
zprintweight ( q , xoff )
halfword q ;
integer xoff ;
#endif
{
integer w, m ;
integer d ;
d = mem [q ].hhfield .lhfield ;
w = d % 8 ;
m = ( d / 8 ) - mem [curedges + 3 ].hhfield .lhfield ;
if ( fileoffset > maxprintline - 9 )
printnl ( 32 ) ;
else printchar ( 32 ) ;
printint ( m + xoff ) ;
while ( w > 4 ) {
printchar ( 43 ) ;
decr ( w ) ;
}
while ( w < 4 ) {
printchar ( 45 ) ;
incr ( w ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zprintedges ( strnumber s , boolean nuline , integer xoff , integer yoff )
#else
zprintedges ( s , nuline , xoff , yoff )
strnumber s ;
boolean nuline ;
integer xoff ;
integer yoff ;
#endif
{
halfword p, q, r ;
integer n ;
printdiagnostic ( 531 , s , nuline ) ;
p = mem [curedges ].hhfield .lhfield ;
n = mem [curedges + 1 ].hhfield .v.RH - 4096 ;
while ( p != curedges ) {
q = mem [p + 1 ].hhfield .lhfield ;
r = mem [p + 1 ].hhfield .v.RH ;
if ( ( q > 1 ) || ( r != memtop ) )
{
printnl ( 532 ) ;
printint ( n + yoff ) ;
printchar ( 58 ) ;
while ( q > 1 ) {
printweight ( q , xoff ) ;
q = mem [q ].hhfield .v.RH ;
}
print ( 533 ) ;
while ( r != memtop ) {
printweight ( r , xoff ) ;
r = mem [r ].hhfield .v.RH ;
}
}
p = mem [p ].hhfield .lhfield ;
decr ( n ) ;
}
enddiagnostic ( true ) ;
}
void
#ifdef HAVE_PROTOTYPES
zunskew ( scaled x , scaled y , smallnumber octant )
#else
zunskew ( x , y , octant )
scaled x ;
scaled y ;
smallnumber octant ;
#endif
{
switch ( octant )
{case 1 :
{
curx = x + y ;
cury = y ;
}
break ;
case 5 :
{
curx = y ;
cury = x + y ;
}
break ;
case 6 :
{
curx = - (integer) y ;
cury = x + y ;
}
break ;
case 2 :
{
curx = - (integer) x - y ;
cury = y ;
}
break ;
case 4 :
{
curx = - (integer) x - y ;
cury = - (integer) y ;
}
break ;
case 8 :
{
curx = - (integer) y ;
cury = - (integer) x - y ;
}
break ;
case 7 :
{
curx = y ;
cury = - (integer) x - y ;
}
break ;
case 3 :
{
curx = x + y ;
cury = - (integer) y ;
}
break ;
}
}
void
#ifdef HAVE_PROTOTYPES
zprintpen ( halfword p , strnumber s , boolean nuline )
#else
zprintpen ( p , s , nuline )
halfword p ;
strnumber s ;
boolean nuline ;
#endif
{
boolean nothingprinted ;
char k ;
halfword h ;
integer m, n ;
halfword w, ww ;
printdiagnostic ( 568 , s , nuline ) ;
nothingprinted = true ;
println () ;
{register integer for_end; k = 1 ;for_end = 8 ; if ( k <= for_end) do
{
octant = octantcode [k ];
h = p + octant ;
n = mem [h ].hhfield .lhfield ;
w = mem [h ].hhfield .v.RH ;
if ( ! odd ( k ) )
w = mem [w ].hhfield .lhfield ;
{register integer for_end; m = 1 ;for_end = n + 1 ; if ( m <= for_end)
do
{
if ( odd ( k ) )
ww = mem [w ].hhfield .v.RH ;
else ww = mem [w ].hhfield .lhfield ;
if ( ( mem [ww + 1 ].cint != mem [w + 1 ].cint ) || ( mem [ww +
2 ].cint != mem [w + 2 ].cint ) )
{
if ( nothingprinted )
nothingprinted = false ;
else printnl ( 570 ) ;
unskew ( mem [ww + 1 ].cint , mem [ww + 2 ].cint , octant ) ;
printtwo ( curx , cury ) ;
}
w = ww ;
}
while ( m++ < for_end ) ;}
}
while ( k++ < for_end ) ;}
if ( nothingprinted )
{
w = mem [p + 1 ].hhfield .v.RH ;
printtwo ( mem [w + 1 ].cint + mem [w + 2 ].cint , mem [w + 2 ].cint
) ;
}
printnl ( 569 ) ;
enddiagnostic ( true ) ;
}
void
#ifdef HAVE_PROTOTYPES
zprintdependency ( halfword p , smallnumber t )
#else
zprintdependency ( p , t )
halfword p ;
smallnumber t ;
#endif
{
/* 10 */ integer v ;
halfword pp, q ;
pp = p ;
while ( true ) {
v = abs ( mem [p + 1 ].cint ) ;
q = mem [p ].hhfield .lhfield ;
if ( q == 0 )
{
if ( ( v != 0 ) || ( p == pp ) )
{
if ( mem [p + 1 ].cint > 0 )
if ( p != pp )
printchar ( 43 ) ;
printscaled ( mem [p + 1 ].cint ) ;
}
goto lab10 ;
}
if ( mem [p + 1 ].cint < 0 )
printchar ( 45 ) ;
else if ( p != pp )
printchar ( 43 ) ;
if ( t == 17 )
v = roundfraction ( v ) ;
if ( v != 65536L )
printscaled ( v ) ;
if ( mem [q ].hhfield .b0 != 19 )
confusion ( 586 ) ;
printvariablename ( q ) ;
v = mem [q + 1 ].cint % 64 ;
while ( v > 0 ) {
print ( 587 ) ;
v = v - 2 ;
}
p = mem [p ].hhfield .v.RH ;
}
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zprintdp ( smallnumber t , halfword p , smallnumber verbosity )
#else
zprintdp ( t , p , verbosity )
smallnumber t ;
halfword p ;
smallnumber verbosity ;
#endif
{
halfword q ;
q = mem [p ].hhfield .v.RH ;
if ( ( mem [q ].hhfield .lhfield == 0 ) || ( verbosity > 0 ) )
printdependency ( p , t ) ;
else print ( 760 ) ;
}
halfword
#ifdef HAVE_PROTOTYPES
stashcurexp ( void )
#else
stashcurexp ( )
#endif
{
register halfword Result; halfword p ;
switch ( curtype )
{case 3 :
case 5 :
case 7 :
case 12 :
case 10 :
case 13 :
case 14 :
case 17 :
case 18 :
case 19 :
p = curexp ;
break ;
default:
{
p = getnode ( 2 ) ;
mem [p ].hhfield .b1 = 11 ;
mem [p ].hhfield .b0 = curtype ;
mem [p + 1 ].cint = curexp ;
}
break ;
}
curtype = 1 ;
mem [p ].hhfield .v.RH = 1 ;
Result = p ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zunstashcurexp ( halfword p )
#else
zunstashcurexp ( p )
halfword p ;
#endif
{
curtype = mem [p ].hhfield .b0 ;
switch ( curtype )
{case 3 :
case 5 :
case 7 :
case 12 :
case 10 :
case 13 :
case 14 :
case 17 :
case 18 :
case 19 :
curexp = p ;
break ;
default:
{
curexp = mem [p + 1 ].cint ;
freenode ( p , 2 ) ;
}
break ;
}
}
void
#ifdef HAVE_PROTOTYPES
zprintexp ( halfword p , smallnumber verbosity )
#else
zprintexp ( p , verbosity )
halfword p ;
smallnumber verbosity ;
#endif
{
boolean restorecurexp ;
smallnumber t ;
integer v ;
halfword q ;
if ( p != 0 )
restorecurexp = false ;
else {
p = stashcurexp () ;
restorecurexp = true ;
}
t = mem [p ].hhfield .b0 ;
if ( t < 17 )
v = mem [p + 1 ].cint ;
else if ( t < 19 )
v = mem [p + 1 ].hhfield .v.RH ;
switch ( t )
{case 1 :
print ( 322 ) ;
break ;
case 2 :
if ( v == 30 )
print ( 346 ) ;
else print ( 347 ) ;
break ;
case 3 :
case 5 :
case 7 :
case 12 :
case 10 :
case 15 :
{
printtype ( t ) ;
if ( v != 0 )
{
printchar ( 32 ) ;
while ( ( mem [v ].hhfield .b1 == 11 ) && ( v != p ) ) v = mem [v +
1 ].cint ;
printvariablename ( v ) ;
}
}
break ;
case 4 :
{
printchar ( 34 ) ;
print ( v ) ;
printchar ( 34 ) ;
}
break ;
case 6 :
case 8 :
case 9 :
case 11 :
if ( verbosity <= 1 )
printtype ( t ) ;
else {
if ( selector == 3 )
if ( internal [13 ]<= 0 )
{
selector = 1 ;
printtype ( t ) ;
print ( 758 ) ;
selector = 3 ;
}
switch ( t )
{case 6 :
printpen ( v , 283 , false ) ;
break ;
case 8 :
printpath ( v , 759 , false ) ;
break ;
case 9 :
printpath ( v , 283 , false ) ;
break ;
case 11 :
{
curedges = v ;
printedges ( 283 , false , 0 , 0 ) ;
}
break ;
}
}
break ;
case 13 :
case 14 :
if ( v == 0 )
printtype ( t ) ;
else {
printchar ( 40 ) ;
q = v + bignodesize [t ];
do {
if ( mem [v ].hhfield .b0 == 16 )
printscaled ( mem [v + 1 ].cint ) ;
else if ( mem [v ].hhfield .b0 == 19 )
printvariablename ( v ) ;
else printdp ( mem [v ].hhfield .b0 , mem [v + 1 ].hhfield .v.RH ,
verbosity ) ;
v = v + 2 ;
if ( v != q )
printchar ( 44 ) ;
} while ( ! ( v == q ) ) ;
printchar ( 41 ) ;
}
break ;
case 16 :
printscaled ( v ) ;
break ;
case 17 :
case 18 :
printdp ( t , v , verbosity ) ;
break ;
case 19 :
printvariablename ( p ) ;
break ;
default:
confusion ( 757 ) ;
break ;
}
if ( restorecurexp )
unstashcurexp ( p ) ;
}
void
#ifdef HAVE_PROTOTYPES
zdisperr ( halfword p , strnumber s )
#else
zdisperr ( p , s )
halfword p ;
strnumber s ;
#endif
{
if ( interaction == 3 )
;
printnl ( 761 ) ;
printexp ( p , 1 ) ;
if ( s != 283 )
{
printnl ( 261 ) ;
print ( s ) ;
}
}
halfword
#ifdef HAVE_PROTOTYPES
zpplusfq ( halfword p , integer f , halfword q , smallnumber t , smallnumber
tt )
#else
zpplusfq ( p , f , q , t , tt )
halfword p ;
integer f ;
halfword q ;
smallnumber t ;
smallnumber tt ;
#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 {
if ( tt == 17 )
v = mem [p + 1 ].cint + takefraction ( f , mem [q + 1 ].cint ) ;
else v = mem [p + 1 ].cint + takescaled ( f , mem [q + 1 ].cint ) ;
mem [p + 1 ].cint = v ;
s = p ;
p = mem [p ].hhfield .v.RH ;
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 ;
}
pp = mem [p ].hhfield .lhfield ;
q = mem [q ].hhfield .v.RH ;
qq = mem [q ].hhfield .lhfield ;
}
else if ( mem [pp + 1 ].cint < mem [qq + 1 ].cint )
{
if ( tt == 17 )
v = takefraction ( f , mem [q + 1 ].cint ) ;
else v = takescaled ( f , mem [q + 1 ].cint ) ;
if ( abs ( v ) > halfp ( threshold ) )
{
s = getnode ( 2 ) ;
mem [s ].hhfield .lhfield = qq ;
mem [s + 1 ].cint = v ;
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 {
mem [r ].hhfield .v.RH = p ;
r = p ;
p = mem [p ].hhfield .v.RH ;
pp = mem [p ].hhfield .lhfield ;
}
lab30: if ( t == 17 )
mem [p + 1 ].cint = slowadd ( mem [p + 1 ].cint , takefraction ( mem [q
+ 1 ].cint , f ) ) ;
else mem [p + 1 ].cint = slowadd ( mem [p + 1 ].cint , takescaled ( mem
[q + 1 ].cint , f ) ) ;
mem [r ].hhfield .v.RH = p ;
depfinal = p ;
Result = mem [memtop - 1 ].hhfield .v.RH ;
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
zpoverv ( halfword p , scaled v , smallnumber t0 , smallnumber t1 )
#else
zpoverv ( p , v , t0 , t1 )
halfword p ;
scaled v ;
smallnumber t0 ;
smallnumber t1 ;
#endif
{
register halfword Result; halfword r, s ;
integer w ;
integer threshold ;
boolean scalingdown ;
if ( t0 != t1 )
scalingdown = true ;
else scalingdown = false ;
if ( t1 == 17 )
threshold = 1342 ;
else threshold = 4 ;
r = memtop - 1 ;
while ( mem [p ].hhfield .lhfield != 0 ) {
if ( scalingdown )
if ( abs ( v ) < 524288L )
w = makescaled ( mem [p + 1 ].cint , v * 4096 ) ;
else w = makescaled ( roundfraction ( mem [p + 1 ].cint ) , v ) ;
else w = makescaled ( mem [p + 1 ].cint , v ) ;
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 ;
mem [p + 1 ].cint = makescaled ( mem [p + 1 ].cint , v ) ;
Result = mem [memtop - 1 ].hhfield .v.RH ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zvaltoobig ( scaled x )
#else
zvaltoobig ( x )
scaled x ;
#endif
{
if ( internal [40 ]> 0 )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 588 ) ;
}
printscaled ( x ) ;
printchar ( 41 ) ;
{
helpptr = 4 ;
helpline [3 ]= 589 ;
helpline [2 ]= 590 ;
helpline [1 ]= 591 ;
helpline [0 ]= 592 ;
}
error () ;
}
}
void
#ifdef HAVE_PROTOTYPES
zmakeknown ( halfword p , halfword q )
#else
zmakeknown ( p , q )
halfword p ;
halfword q ;
#endif
{
char t ;
mem [mem [q ].hhfield .v.RH + 1 ].hhfield .lhfield = mem [p + 1 ]
.hhfield .lhfield ;
mem [mem [p + 1 ].hhfield .lhfield ].hhfield .v.RH = mem [q ].hhfield
.v.RH ;
t = mem [p ].hhfield .b0 ;
mem [p ].hhfield .b0 = 16 ;
mem [p + 1 ].cint = mem [q + 1 ].cint ;
freenode ( q , 2 ) ;
if ( abs ( mem [p + 1 ].cint ) >= 268435456L )
valtoobig ( mem [p + 1 ].cint ) ;
if ( internal [2 ]> 0 )
if ( interesting ( p ) )
{
begindiagnostic () ;
printnl ( 593 ) ;
printvariablename ( p ) ;
printchar ( 61 ) ;
printscaled ( mem [p + 1 ].cint ) ;
enddiagnostic ( false ) ;
}
if ( curexp == p )
if ( curtype == t )
{
curtype = 16 ;
curexp = mem [p + 1 ].cint ;
freenode ( p , 2 ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
fixdependencies ( void )
#else
fixdependencies ( )
#endif
{
/* 30 */ halfword p, q, r, s, t ;
halfword x ;
r = mem [13 ].hhfield .v.RH ;
s = 0 ;
while ( r != 13 ) {
t = r ;
r = t + 1 ;
while ( true ) {
q = mem [r ].hhfield .v.RH ;
x = mem [q ].hhfield .lhfield ;
if ( x == 0 )
goto lab30 ;
if ( mem [x ].hhfield .b0 <= 1 )
{
if ( mem [x ].hhfield .b0 < 1 )
{
p = getavail () ;
mem [p ].hhfield .v.RH = s ;
s = p ;
mem [s ].hhfield .lhfield = x ;
mem [x ].hhfield .b0 = 1 ;
}
mem [q + 1 ].cint = mem [q + 1 ].cint / 4 ;
if ( mem [q + 1 ].cint == 0 )
{
mem [r ].hhfield .v.RH = mem [q ].hhfield .v.RH ;
freenode ( q , 2 ) ;
q = r ;
}
}
r = q ;
}
lab30: ;
r = mem [q ].hhfield .v.RH ;
if ( q == mem [t + 1 ].hhfield .v.RH )
makeknown ( t , q ) ;
}
while ( s != 0 ) {
p = mem [s ].hhfield .v.RH ;
x = mem [s ].hhfield .lhfield ;
{
mem [s ].hhfield .v.RH = avail ;
avail = s ;
;
#ifdef STAT
decr ( dynused ) ;
#endif /* STAT */
}
s = p ;
mem [x ].hhfield .b0 = 19 ;
mem [x + 1 ].cint = mem [x + 1 ].cint + 2 ;
}
fixneeded = false ;
}
void
#ifdef HAVE_PROTOTYPES
ztossknotlist ( halfword p )
#else
ztossknotlist ( p )
halfword p ;
#endif
{
halfword q ;
halfword r ;
q = p ;
do {
r = mem [q ].hhfield .v.RH ;
freenode ( q , 7 ) ;
q = r ;
} while ( ! ( q == p ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
ztossedges ( halfword h )
#else
ztossedges ( h )
halfword h ;
#endif
{
halfword p, q ;
q = mem [h ].hhfield .v.RH ;
while ( q != h ) {
flushlist ( mem [q + 1 ].hhfield .v.RH ) ;
if ( mem [q + 1 ].hhfield .lhfield > 1 )
flushlist ( mem [q + 1 ].hhfield .lhfield ) ;
p = q ;
q = mem [q ].hhfield .v.RH ;
freenode ( p , 2 ) ;
}
freenode ( h , 6 ) ;
}
void
#ifdef HAVE_PROTOTYPES
ztosspen ( halfword p )
#else
ztosspen ( p )
halfword p ;
#endif
{
char k ;
halfword w, ww ;
if ( p != 3 )
{
{register integer for_end; k = 1 ;for_end = 8 ; if ( k <= for_end) do
{
w = mem [p + k ].hhfield .v.RH ;
do {
ww = mem [w ].hhfield .v.RH ;
freenode ( w , 3 ) ;
w = ww ;
} while ( ! ( w == mem [p + k ].hhfield .v.RH ) ) ;
}
while ( k++ < for_end ) ;}
freenode ( p , 10 ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zringdelete ( halfword p )
#else
zringdelete ( p )
halfword p ;
#endif
{
halfword q ;
q = mem [p + 1 ].cint ;
if ( q != 0 )
if ( q != p )
{
while ( mem [q + 1 ].cint != p ) q = mem [q + 1 ].cint ;
mem [q + 1 ].cint = mem [p + 1 ].cint ;
}
}
void
#ifdef HAVE_PROTOTYPES
zrecyclevalue ( halfword p )
#else
zrecyclevalue ( p )
halfword p ;
#endif
{
/* 30 */ smallnumber t ;
integer v ;
integer vv ;
halfword q, r, s, pp ;
t = mem [p ].hhfield .b0 ;
if ( t < 17 )
v = mem [p + 1 ].cint ;
switch ( t )
{case 0 :
case 1 :
case 2 :
case 16 :
case 15 :
;
break ;
case 3 :
case 5 :
case 7 :
case 12 :
case 10 :
ringdelete ( p ) ;
break ;
case 4 :
{
if ( strref [v ]< 127 )
if ( strref [v ]> 1 )
decr ( strref [v ]) ;
else flushstring ( v ) ;
}
break ;
case 6 :
if ( mem [v ].hhfield .lhfield == 0 )
tosspen ( v ) ;
else decr ( mem [v ].hhfield .lhfield ) ;
break ;
case 9 :
case 8 :
tossknotlist ( v ) ;
break ;
case 11 :
tossedges ( v ) ;
break ;
case 14 :
case 13 :
if ( v != 0 )
{
q = v + bignodesize [t ];
do {
q = q - 2 ;
recyclevalue ( q ) ;
} while ( ! ( q == v ) ) ;
freenode ( v , bignodesize [t ]) ;
}
break ;
case 17 :
case 18 :
{
q = mem [p + 1 ].hhfield .v.RH ;
while ( mem [q ].hhfield .lhfield != 0 ) q = mem [q ].hhfield .v.RH
;
mem [mem [p + 1 ].hhfield .lhfield ].hhfield .v.RH = mem [q ]
.hhfield .v.RH ;
mem [mem [q ].hhfield .v.RH + 1 ].hhfield .lhfield = mem [p + 1 ]
.hhfield .lhfield ;
mem [q ].hhfield .v.RH = 0 ;
flushnodelist ( mem [p + 1 ].hhfield .v.RH ) ;
}
break ;
case 19 :
{
maxc [17 ]= 0 ;
maxc [18 ]= 0 ;
maxlink [17 ]= 0 ;
maxlink [18 ]= 0 ;
q = mem [13 ].hhfield .v.RH ;
while ( q != 13 ) {
s = q + 1 ;
while ( true ) {
r = mem [s ].hhfield .v.RH ;
if ( mem [r ].hhfield .lhfield == 0 )
goto lab30 ;
if ( mem [r ].hhfield .lhfield != p )
s = r ;
else {
t = mem [q ].hhfield .b0 ;
mem [s ].hhfield .v.RH = mem [r ].hhfield .v.RH ;
mem [r ].hhfield .lhfield = q ;
if ( abs ( mem [r + 1 ].cint ) > maxc [t ])
{
if ( maxc [t ]> 0 )
{
mem [maxptr [t ]].hhfield .v.RH = maxlink [t ];
maxlink [t ]= maxptr [t ];
}
maxc [t ]= abs ( mem [r + 1 ].cint ) ;
maxptr [t ]= r ;
}
else {
mem [r ].hhfield .v.RH = maxlink [t ];
maxlink [t ]= r ;
}
}
}
lab30: q = mem [r ].hhfield .v.RH ;
}
if ( ( maxc [17 ]> 0 ) || ( maxc [18 ]> 0 ) )
{
if ( ( maxc [17 ]/ 4096 >= maxc [18 ]) )
t = 17 ;
else t = 18 ;
s = maxptr [t ];
pp = mem [s ].hhfield .lhfield ;
v = mem [s + 1 ].cint ;
if ( t == 17 )
mem [s + 1 ].cint = -268435456L ;
else mem [s + 1 ].cint = -65536L ;
r = mem [pp + 1 ].hhfield .v.RH ;
mem [s ].hhfield .v.RH = r ;
while ( mem [r ].hhfield .lhfield != 0 ) r = mem [r ].hhfield
.v.RH ;
q = mem [r ].hhfield .v.RH ;
mem [r ].hhfield .v.RH = 0 ;
mem [q + 1 ].hhfield .lhfield = mem [pp + 1 ].hhfield .lhfield ;
mem [mem [pp + 1 ].hhfield .lhfield ].hhfield .v.RH = q ;
{
mem [pp ].hhfield .b0 = 19 ;
serialno = serialno + 64 ;
mem [pp + 1 ].cint = serialno ;
}
if ( curexp == pp )
if ( curtype == t )
curtype = 19 ;
if ( internal [2 ]> 0 )
if ( interesting ( p ) )
{
begindiagnostic () ;
printnl ( 763 ) ;
if ( v > 0 )
printchar ( 45 ) ;
if ( t == 17 )
vv = roundfraction ( maxc [17 ]) ;
else vv = maxc [18 ];
if ( vv != 65536L )
printscaled ( vv ) ;
printvariablename ( p ) ;
while ( mem [p + 1 ].cint % 64 > 0 ) {
print ( 587 ) ;
mem [p + 1 ].cint = mem [p + 1 ].cint - 2 ;
}
if ( t == 17 )
printchar ( 61 ) ;
else print ( 764 ) ;
printdependency ( s , t ) ;
enddiagnostic ( false ) ;
}
t = 35 - t ;
if ( maxc [t ]> 0 )
{
mem [maxptr [t ]].hhfield .v.RH = maxlink [t ];
maxlink [t ]= maxptr [t ];
}
if ( t != 17 )
{register integer for_end; t = 17 ;for_end = 18 ; if ( t <= for_end)
do
{
r = maxlink [t ];
while ( r != 0 ) {
q = mem [r ].hhfield .lhfield ;
mem [q + 1 ].hhfield .v.RH = pplusfq ( mem [q + 1 ].hhfield
.v.RH , makefraction ( mem [r + 1 ].cint , - (integer) v ) , s
, t , 17 ) ;
if ( mem [q + 1 ].hhfield .v.RH == depfinal )
makeknown ( q , depfinal ) ;
q = r ;
r = mem [r ].hhfield .v.RH ;
freenode ( q , 2 ) ;
}
}
while ( t++ < for_end ) ;}
else {
register integer for_end; t = 17 ;for_end = 18 ; if ( t <=
for_end) do
{
r = maxlink [t ];
while ( r != 0 ) {
q = mem [r ].hhfield .lhfield ;
if ( t == 17 )
{
if ( curexp == q )
if ( curtype == 17 )
curtype = 18 ;
mem [q + 1 ].hhfield .v.RH = poverv ( mem [q + 1 ].hhfield
.v.RH , 65536L , 17 , 18 ) ;
mem [q ].hhfield .b0 = 18 ;
mem [r + 1 ].cint = roundfraction ( mem [r + 1 ].cint ) ;
}
mem [q + 1 ].hhfield .v.RH = pplusfq ( mem [q + 1 ].hhfield
.v.RH , makescaled ( mem [r + 1 ].cint , - (integer) v ) , s ,
18 , 18 ) ;
if ( mem [q + 1 ].hhfield .v.RH == depfinal )
makeknown ( q , depfinal ) ;
q = r ;
r = mem [r ].hhfield .v.RH ;
freenode ( q , 2 ) ;
}
}
while ( t++ < for_end ) ;}
flushnodelist ( s ) ;
if ( fixneeded )
fixdependencies () ;
{
if ( aritherror )
cleararith () ;
}
}
}
break ;
case 20 :
case 21 :
confusion ( 762 ) ;
break ;
case 22 :
case 23 :
deletemacref ( mem [p + 1 ].cint ) ;
break ;
}
mem [p ].hhfield .b0 = 0 ;
}
void
#ifdef HAVE_PROTOTYPES
zflushcurexp ( scaled v )
#else
zflushcurexp ( v )
scaled v ;
#endif
{
switch ( curtype )
{case 3 :
case 5 :
case 7 :
case 12 :
case 10 :
case 13 :
case 14 :
case 17 :
case 18 :
case 19 :
{
recyclevalue ( curexp ) ;
freenode ( curexp , 2 ) ;
}
break ;
case 6 :
if ( mem [curexp ].hhfield .lhfield == 0 )
tosspen ( curexp ) ;
else decr ( mem [curexp ].hhfield .lhfield ) ;
break ;
case 4 :
{
if ( strref [curexp ]< 127 )
if ( strref [curexp ]> 1 )
decr ( strref [curexp ]) ;
else flushstring ( curexp ) ;
}
break ;
case 8 :
case 9 :
tossknotlist ( curexp ) ;
break ;
case 11 :
tossedges ( curexp ) ;
break ;
default:
;
break ;
}
curtype = 16 ;
curexp = v ;
}
void
#ifdef HAVE_PROTOTYPES
zflusherror ( scaled v )
#else
zflusherror ( v )
scaled v ;
#endif
{
error () ;
flushcurexp ( v ) ;
}
void
#ifdef HAVE_PROTOTYPES
putgeterror ( void )
#else
putgeterror ( )
#endif
{
backerror () ;
getxnext () ;
}
void
#ifdef HAVE_PROTOTYPES
zputgetflusherror ( scaled v )
#else
zputgetflusherror ( v )
scaled v ;
#endif
{
putgeterror () ;
flushcurexp ( v ) ;
}
void
#ifdef HAVE_PROTOTYPES
zflushbelowvariable ( halfword p )
#else
zflushbelowvariable ( p )
halfword p ;
#endif
{
halfword q, r ;
if ( mem [p ].hhfield .b0 != 21 )
recyclevalue ( p ) ;
else {
q = mem [p + 1 ].hhfield .v.RH ;
while ( mem [q ].hhfield .b1 == 3 ) {
flushbelowvariable ( q ) ;
r = q ;
q = mem [q ].hhfield .v.RH ;
freenode ( r , 3 ) ;
}
r = mem [p + 1 ].hhfield .lhfield ;
q = mem [r ].hhfield .v.RH ;
recyclevalue ( r ) ;
if ( mem [p ].hhfield .b1 <= 1 )
freenode ( r , 2 ) ;
else freenode ( r , 3 ) ;
do {
flushbelowvariable ( q ) ;
r = q ;
q = mem [q ].hhfield .v.RH ;
freenode ( r , 3 ) ;
} while ( ! ( q == 17 ) ) ;
mem [p ].hhfield .b0 = 0 ;
}
}
void
#ifdef HAVE_PROTOTYPES
zflushvariable ( halfword p , halfword t , boolean discardsuffixes )
#else
zflushvariable ( p , t , discardsuffixes )
halfword p ;
halfword t ;
boolean discardsuffixes ;
#endif
{
/* 10 */ halfword q, r ;
halfword n ;
while ( t != 0 ) {
if ( mem [p ].hhfield .b0 != 21 )
goto lab10 ;
n = mem [t ].hhfield .lhfield ;
t = mem [t ].hhfield .v.RH ;
if ( n == 0 )
{
r = p + 1 ;
q = mem [r ].hhfield .v.RH ;
while ( mem [q ].hhfield .b1 == 3 ) {
flushvariable ( q , t , discardsuffixes ) ;
if ( t == 0 )
if ( mem [q ].hhfield .b0 == 21 )
r = q ;
else {
mem [r ].hhfield .v.RH = mem [q ].hhfield .v.RH ;
freenode ( q , 3 ) ;
}
else r = q ;
q = mem [r ].hhfield .v.RH ;
}
}
p = mem [p + 1 ].hhfield .lhfield ;
do {
r = p ;
p = mem [p ].hhfield .v.RH ;
} while ( ! ( mem [p + 2 ].hhfield .lhfield >= n ) ) ;
if ( mem [p + 2 ].hhfield .lhfield != n )
goto lab10 ;
}
if ( discardsuffixes )
flushbelowvariable ( p ) ;
else {
if ( mem [p ].hhfield .b0 == 21 )
p = mem [p + 1 ].hhfield .lhfield ;
recyclevalue ( p ) ;
}
lab10: ;
}
smallnumber
#ifdef HAVE_PROTOTYPES
zundtype ( halfword p )
#else
zundtype ( p )
halfword p ;
#endif
{
register smallnumber Result; switch ( mem [p ].hhfield .b0 )
{case 0 :
case 1 :
Result = 0 ;
break ;
case 2 :
case 3 :
Result = 3 ;
break ;
case 4 :
case 5 :
Result = 5 ;
break ;
case 6 :
case 7 :
case 8 :
Result = 7 ;
break ;
case 9 :
case 10 :
Result = 10 ;
break ;
case 11 :
case 12 :
Result = 12 ;
break ;
case 13 :
case 14 :
case 15 :
Result = mem [p ].hhfield .b0 ;
break ;
case 16 :
case 17 :
case 18 :
case 19 :
Result = 15 ;
break ;
}
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zclearsymbol ( halfword p , boolean saving )
#else
zclearsymbol ( p , saving )
halfword p ;
boolean saving ;
#endif
{
halfword q ;
q = eqtb [p ].v.RH ;
switch ( eqtb [p ].lhfield % 86 )
{case 10 :
case 53 :
case 44 :
case 49 :
if ( ! saving )
deletemacref ( q ) ;
break ;
case 41 :
if ( q != 0 )
if ( saving )
mem [q ].hhfield .b1 = 1 ;
else {
flushbelowvariable ( q ) ;
freenode ( q , 2 ) ;
}
break ;
default:
;
break ;
}
eqtb [p ]= eqtb [9769 ];
}
void
#ifdef HAVE_PROTOTYPES
zsavevariable ( halfword q )
#else
zsavevariable ( q )
halfword q ;
#endif
{
halfword p ;
if ( saveptr != 0 )
{
p = getnode ( 2 ) ;
mem [p ].hhfield .lhfield = q ;
mem [p ].hhfield .v.RH = saveptr ;
mem [p + 1 ].hhfield = eqtb [q ];
saveptr = p ;
}
clearsymbol ( q , ( saveptr != 0 ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
zsaveinternal ( halfword q )
#else
zsaveinternal ( q )
halfword q ;
#endif
{
halfword p ;
if ( saveptr != 0 )
{
p = getnode ( 2 ) ;
mem [p ].hhfield .lhfield = 9769 + q ;
mem [p ].hhfield .v.RH = saveptr ;
mem [p + 1 ].cint = internal [q ];
saveptr = p ;
}
}
void
#ifdef HAVE_PROTOTYPES
unsave ( void )
#else
unsave ( )
#endif
{
halfword q ;
halfword p ;
while ( mem [saveptr ].hhfield .lhfield != 0 ) {
q = mem [saveptr ].hhfield .lhfield ;
if ( q > 9769 )
{
if ( internal [8 ]> 0 )
{
begindiagnostic () ;
printnl ( 515 ) ;
print ( intname [q - ( 9769 ) ]) ;
printchar ( 61 ) ;
printscaled ( mem [saveptr + 1 ].cint ) ;
printchar ( 125 ) ;
enddiagnostic ( false ) ;
}
internal [q - ( 9769 ) ]= mem [saveptr + 1 ].cint ;
}
else {
if ( internal [8 ]> 0 )
{
begindiagnostic () ;
printnl ( 515 ) ;
print ( hash [q ].v.RH ) ;
printchar ( 125 ) ;
enddiagnostic ( false ) ;
}
clearsymbol ( q , false ) ;
eqtb [q ]= mem [saveptr + 1 ].hhfield ;
if ( eqtb [q ].lhfield % 86 == 41 )
{
p = eqtb [q ].v.RH ;
if ( p != 0 )
mem [p ].hhfield .b1 = 0 ;
}
}
p = mem [saveptr ].hhfield .v.RH ;
freenode ( saveptr , 2 ) ;
saveptr = p ;
}
p = mem [saveptr ].hhfield .v.RH ;
{
mem [saveptr ].hhfield .v.RH = avail ;
avail = saveptr ;
;
#ifdef STAT
decr ( dynused ) ;
#endif /* STAT */
}
saveptr = p ;
}
halfword
#ifdef HAVE_PROTOTYPES
zcopyknot ( halfword p )
#else
zcopyknot ( p )
halfword p ;
#endif
{
register halfword Result; halfword q ;
char k ;
q = getnode ( 7 ) ;
{register integer for_end; k = 0 ;for_end = 6 ; if ( k <= for_end) do
mem [q + k ]= mem [p + k ];
while ( k++ < for_end ) ;}
Result = q ;
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
zcopypath ( halfword p )
#else
zcopypath ( p )
halfword p ;
#endif
{
/* 10 */ register halfword Result; halfword q, pp, qq ;
q = getnode ( 7 ) ;
qq = q ;
pp = p ;
while ( true ) {
mem [qq ].hhfield .b0 = mem [pp ].hhfield .b0 ;
mem [qq ].hhfield .b1 = mem [pp ].hhfield .b1 ;
mem [qq + 1 ].cint = mem [pp + 1 ].cint ;
mem [qq + 2 ].cint = mem [pp + 2 ].cint ;
mem [qq + 3 ].cint = mem [pp + 3 ].cint ;
mem [qq + 4 ].cint = mem [pp + 4 ].cint ;
mem [qq + 5 ].cint = mem [pp + 5 ].cint ;
mem [qq + 6 ].cint = mem [pp + 6 ].cint ;
if ( mem [pp ].hhfield .v.RH == p )
{
mem [qq ].hhfield .v.RH = q ;
Result = q ;
goto lab10 ;
}
mem [qq ].hhfield .v.RH = getnode ( 7 ) ;
qq = mem [qq ].hhfield .v.RH ;
pp = mem [pp ].hhfield .v.RH ;
}
lab10: ;
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
zhtapypoc ( halfword p )
#else
zhtapypoc ( p )
halfword p ;
#endif
{
/* 10 */ register halfword Result; halfword q, pp, qq, rr ;
q = getnode ( 7 ) ;
qq = q ;
pp = p ;
while ( true ) {
mem [qq ].hhfield .b1 = mem [pp ].hhfield .b0 ;
mem [qq ].hhfield .b0 = mem [pp ].hhfield .b1 ;
mem [qq + 1 ].cint = mem [pp + 1 ].cint ;
mem [qq + 2 ].cint = mem [pp + 2 ].cint ;
mem [qq + 5 ].cint = mem [pp + 3 ].cint ;
mem [qq + 6 ].cint = mem [pp + 4 ].cint ;
mem [qq + 3 ].cint = mem [pp + 5 ].cint ;
mem [qq + 4 ].cint = mem [pp + 6 ].cint ;
if ( mem [pp ].hhfield .v.RH == p )
{
mem [q ].hhfield .v.RH = qq ;
pathtail = pp ;
Result = q ;
goto lab10 ;
}
rr = getnode ( 7 ) ;
mem [rr ].hhfield .v.RH = qq ;
qq = rr ;
pp = mem [pp ].hhfield .v.RH ;
}
lab10: ;
return Result ;
}
fraction
#ifdef HAVE_PROTOTYPES
zcurlratio ( scaled gamma , scaled atension , scaled btension )
#else
zcurlratio ( gamma , atension , btension )
scaled gamma ;
scaled atension ;
scaled btension ;
#endif
{
register fraction Result; fraction alpha, beta, num, denom, ff ;
alpha = makefraction ( 65536L , atension ) ;
beta = makefraction ( 65536L , btension ) ;
if ( alpha <= beta )
{
ff = makefraction ( alpha , beta ) ;
ff = takefraction ( ff , ff ) ;
gamma = takefraction ( gamma , ff ) ;
beta = beta / 4096 ;
denom = takefraction ( gamma , alpha ) + 196608L - beta ;
num = takefraction ( gamma , 805306368L - alpha ) + beta ;
}
else {
ff = makefraction ( beta , alpha ) ;
ff = takefraction ( ff , ff ) ;
beta = takefraction ( beta , ff ) / 4096 ;
denom = takefraction ( gamma , alpha ) + ( ff / 1365 ) - beta ;
num = takefraction ( gamma , 805306368L - alpha ) + beta ;
}
if ( num >= denom + denom + denom + denom )
Result = 1073741824L ;
else Result = makefraction ( num , denom ) ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zsetcontrols ( halfword p , halfword q , integer k )
#else
zsetcontrols ( p , q , k )
halfword p ;
halfword q ;
integer k ;
#endif
{
fraction rr, ss ;
scaled lt, rt ;
fraction sine ;
lt = abs ( mem [q + 4 ].cint ) ;
rt = abs ( mem [p + 6 ].cint ) ;
rr = velocity ( st , ct , sf , cf , rt ) ;
ss = velocity ( sf , cf , st , ct , lt ) ;
if ( ( mem [p + 6 ].cint < 0 ) || ( mem [q + 4 ].cint < 0 ) )
if ( ( ( st >= 0 ) && ( sf >= 0 ) ) || ( ( st <= 0 ) && ( sf <= 0 ) ) )
{
sine = takefraction ( abs ( st ) , cf ) + takefraction ( abs ( sf ) , ct )
;
if ( sine > 0 )
{
sine = takefraction ( sine , 268500992L ) ;
if ( mem [p + 6 ].cint < 0 )
if ( abvscd ( abs ( sf ) , 268435456L , rr , sine ) < 0 )
rr = makefraction ( abs ( sf ) , sine ) ;
if ( mem [q + 4 ].cint < 0 )
if ( abvscd ( abs ( st ) , 268435456L , ss , sine ) < 0 )
ss = makefraction ( abs ( st ) , sine ) ;
}
}
mem [p + 5 ].cint = mem [p + 1 ].cint + takefraction ( takefraction (
deltax [k ], ct ) - takefraction ( deltay [k ], st ) , rr ) ;
mem [p + 6 ].cint = mem [p + 2 ].cint + takefraction ( takefraction (
deltay [k ], ct ) + takefraction ( deltax [k ], st ) , rr ) ;
mem [q + 3 ].cint = mem [q + 1 ].cint - takefraction ( takefraction (
deltax [k ], cf ) + takefraction ( deltay [k ], sf ) , ss ) ;
mem [q + 4 ].cint = mem [q + 2 ].cint - takefraction ( takefraction (
deltay [k ], cf ) - takefraction ( deltax [k ], sf ) , ss ) ;
mem [p ].hhfield .b1 = 1 ;
mem [q ].hhfield .b0 = 1 ;
}
void
#ifdef HAVE_PROTOTYPES
zsolvechoices ( halfword p , halfword q , halfword n )
#else
zsolvechoices ( p , q , n )
halfword p ;
halfword q ;
halfword n ;
#endif
{
/* 40 10 */ integer k ;
halfword r, s, t ;
fraction aa, bb, cc, ff, acc ;
scaled dd, ee ;
scaled lt, rt ;
k = 0 ;
s = p ;
while ( true ) {
t = mem [s ].hhfield .v.RH ;
if ( k == 0 )
switch ( mem [s ].hhfield .b1 )
{case 2 :
if ( mem [t ].hhfield .b0 == 2 )
{
aa = narg ( deltax [0 ], deltay [0 ]) ;
nsincos ( mem [p + 5 ].cint - aa ) ;
ct = ncos ;
st = nsin ;
nsincos ( mem [q + 3 ].cint - aa ) ;
cf = ncos ;
sf = - (integer) nsin ;
setcontrols ( p , q , 0 ) ;
goto lab10 ;
}
else {
vv [0 ]= mem [s + 5 ].cint - narg ( deltax [0 ], deltay [0 ])
;
if ( abs ( vv [0 ]) > 188743680L )
if ( vv [0 ]> 0 )
vv [0 ]= vv [0 ]- 377487360L ;
else vv [0 ]= vv [0 ]+ 377487360L ;
uu [0 ]= 0 ;
ww [0 ]= 0 ;
}
break ;
case 3 :
if ( mem [t ].hhfield .b0 == 3 )
{
mem [p ].hhfield .b1 = 1 ;
mem [q ].hhfield .b0 = 1 ;
lt = abs ( mem [q + 4 ].cint ) ;
rt = abs ( mem [p + 6 ].cint ) ;
if ( rt == 65536L )
{
if ( deltax [0 ]>= 0 )
mem [p + 5 ].cint = mem [p + 1 ].cint + ( ( deltax [0 ]+ 1 ) /
3 ) ;
else mem [p + 5 ].cint = mem [p + 1 ].cint + ( ( deltax [0 ]-
1 ) / 3 ) ;
if ( deltay [0 ]>= 0 )
mem [p + 6 ].cint = mem [p + 2 ].cint + ( ( deltay [0 ]+ 1 ) /
3 ) ;
else mem [p + 6 ].cint = mem [p + 2 ].cint + ( ( deltay [0 ]-
1 ) / 3 ) ;
}
else {
ff = makefraction ( 65536L , 3 * rt ) ;
mem [p + 5 ].cint = mem [p + 1 ].cint + takefraction ( deltax [
0 ], ff ) ;
mem [p + 6 ].cint = mem [p + 2 ].cint + takefraction ( deltay [
0 ], ff ) ;
}
if ( lt == 65536L )
{
if ( deltax [0 ]>= 0 )
mem [q + 3 ].cint = mem [q + 1 ].cint - ( ( deltax [0 ]+ 1 ) /
3 ) ;
else mem [q + 3 ].cint = mem [q + 1 ].cint - ( ( deltax [0 ]-
1 ) / 3 ) ;
if ( deltay [0 ]>= 0 )
mem [q + 4 ].cint = mem [q + 2 ].cint - ( ( deltay [0 ]+ 1 ) /
3 ) ;
else mem [q + 4 ].cint = mem [q + 2 ].cint - ( ( deltay [0 ]-
1 ) / 3 ) ;
}
else {
ff = makefraction ( 65536L , 3 * lt ) ;
mem [q + 3 ].cint = mem [q + 1 ].cint - takefraction ( deltax [
0 ], ff ) ;
mem [q + 4 ].cint = mem [q + 2 ].cint - takefraction ( deltay [
0 ], ff ) ;
}
goto lab10 ;
}
else {
cc = mem [s + 5 ].cint ;
lt = abs ( mem [t + 4 ].cint ) ;
rt = abs ( mem [s + 6 ].cint ) ;
if ( ( rt == 65536L ) && ( lt == 65536L ) )
uu [0 ]= makefraction ( cc + cc + 65536L , cc + 131072L ) ;
else uu [0 ]= curlratio ( cc , rt , lt ) ;
vv [0 ]= - (integer) takefraction ( psi [1 ], uu [0 ]) ;
ww [0 ]= 0 ;
}
break ;
case 4 :
{
uu [0 ]= 0 ;
vv [0 ]= 0 ;
ww [0 ]= 268435456L ;
}
break ;
}
else switch ( mem [s ].hhfield .b0 )
{case 5 :
case 4 :
{
if ( abs ( mem [r + 6 ].cint ) == 65536L )
{
aa = 134217728L ;
dd = 2 * delta [k ];
}
else {
aa = makefraction ( 65536L , 3 * abs ( mem [r + 6 ].cint ) -
65536L ) ;
dd = takefraction ( delta [k ], 805306368L - makefraction ( 65536L
, abs ( mem [r + 6 ].cint ) ) ) ;
}
if ( abs ( mem [t + 4 ].cint ) == 65536L )
{
bb = 134217728L ;
ee = 2 * delta [k - 1 ];
}
else {
bb = makefraction ( 65536L , 3 * abs ( mem [t + 4 ].cint ) -
65536L ) ;
ee = takefraction ( delta [k - 1 ], 805306368L - makefraction (
65536L , abs ( mem [t + 4 ].cint ) ) ) ;
}
cc = 268435456L - takefraction ( uu [k - 1 ], aa ) ;
dd = takefraction ( dd , cc ) ;
lt = abs ( mem [s + 4 ].cint ) ;
rt = abs ( mem [s + 6 ].cint ) ;
if ( lt != rt )
if ( lt < rt )
{
ff = makefraction ( lt , rt ) ;
ff = takefraction ( ff , ff ) ;
dd = takefraction ( dd , ff ) ;
}
else {
ff = makefraction ( rt , lt ) ;
ff = takefraction ( ff , ff ) ;
ee = takefraction ( ee , ff ) ;
}
ff = makefraction ( ee , ee + dd ) ;
uu [k ]= takefraction ( ff , bb ) ;
acc = - (integer) takefraction ( psi [k + 1 ], uu [k ]) ;
if ( mem [r ].hhfield .b1 == 3 )
{
ww [k ]= 0 ;
vv [k ]= acc - takefraction ( psi [1 ], 268435456L - ff ) ;
}
else {
ff = makefraction ( 268435456L - ff , cc ) ;
acc = acc - takefraction ( psi [k ], ff ) ;
ff = takefraction ( ff , aa ) ;
vv [k ]= acc - takefraction ( vv [k - 1 ], ff ) ;
if ( ww [k - 1 ]== 0 )
ww [k ]= 0 ;
else ww [k ]= - (integer) takefraction ( ww [k - 1 ], ff ) ;
}
if ( mem [s ].hhfield .b0 == 5 )
{
aa = 0 ;
bb = 268435456L ;
do {
decr ( k ) ;
if ( k == 0 )
k = n ;
aa = vv [k ]- takefraction ( aa , uu [k ]) ;
bb = ww [k ]- takefraction ( bb , uu [k ]) ;
} while ( ! ( k == n ) ) ;
aa = makefraction ( aa , 268435456L - bb ) ;
theta [n ]= aa ;
vv [0 ]= aa ;
{register integer for_end; k = 1 ;for_end = n - 1 ; if ( k <=
for_end) do
vv [k ]= vv [k ]+ takefraction ( aa , ww [k ]) ;
while ( k++ < for_end ) ;}
goto lab40 ;
}
}
break ;
case 3 :
{
cc = mem [s + 3 ].cint ;
lt = abs ( mem [s + 4 ].cint ) ;
rt = abs ( mem [r + 6 ].cint ) ;
if ( ( rt == 65536L ) && ( lt == 65536L ) )
ff = makefraction ( cc + cc + 65536L , cc + 131072L ) ;
else ff = curlratio ( cc , lt , rt ) ;
theta [n ]= - (integer) makefraction ( takefraction ( vv [n - 1 ],
ff ) , 268435456L - takefraction ( ff , uu [n - 1 ]) ) ;
goto lab40 ;
}
break ;
case 2 :
{
theta [n ]= mem [s + 3 ].cint - narg ( deltax [n - 1 ], deltay [
n - 1 ]) ;
if ( abs ( theta [n ]) > 188743680L )
if ( theta [n ]> 0 )
theta [n ]= theta [n ]- 377487360L ;
else theta [n ]= theta [n ]+ 377487360L ;
goto lab40 ;
}
break ;
}
r = s ;
s = t ;
incr ( k ) ;
}
lab40: {
register integer for_end; k = n - 1 ;for_end = 0 ; if ( k >=
for_end) do
theta [k ]= vv [k ]- takefraction ( theta [k + 1 ], uu [k ]) ;
while ( k-- > for_end ) ;}
s = p ;
k = 0 ;
do {
t = mem [s ].hhfield .v.RH ;
nsincos ( theta [k ]) ;
st = nsin ;
ct = ncos ;
nsincos ( - (integer) psi [k + 1 ]- theta [k + 1 ]) ;
sf = nsin ;
cf = ncos ;
setcontrols ( s , t , k ) ;
incr ( k ) ;
s = t ;
} while ( ! ( k == n ) ) ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zmakechoices ( halfword knots )
#else
zmakechoices ( knots )
halfword knots ;
#endif
{
/* 30 */ halfword h ;
halfword p, q ;
integer k, n ;
halfword s, t ;
scaled delx, dely ;
fraction sine, cosine ;
{
if ( aritherror )
cleararith () ;
}
if ( internal [4 ]> 0 )
printpath ( knots , 525 , true ) ;
p = knots ;
do {
q = mem [p ].hhfield .v.RH ;
if ( mem [p + 1 ].cint == mem [q + 1 ].cint )
if ( mem [p + 2 ].cint == mem [q + 2 ].cint )
if ( mem [p ].hhfield .b1 > 1 )
{
mem [p ].hhfield .b1 = 1 ;
if ( mem [p ].hhfield .b0 == 4 )
{
mem [p ].hhfield .b0 = 3 ;
mem [p + 3 ].cint = 65536L ;
}
mem [q ].hhfield .b0 = 1 ;
if ( mem [q ].hhfield .b1 == 4 )
{
mem [q ].hhfield .b1 = 3 ;
mem [q + 5 ].cint = 65536L ;
}
mem [p + 5 ].cint = mem [p + 1 ].cint ;
mem [q + 3 ].cint = mem [p + 1 ].cint ;
mem [p + 6 ].cint = mem [p + 2 ].cint ;
mem [q + 4 ].cint = mem [p + 2 ].cint ;
}
p = q ;
} while ( ! ( p == knots ) ) ;
h = knots ;
while ( true ) {
if ( mem [h ].hhfield .b0 != 4 )
goto lab30 ;
if ( mem [h ].hhfield .b1 != 4 )
goto lab30 ;
h = mem [h ].hhfield .v.RH ;
if ( h == knots )
{
mem [h ].hhfield .b0 = 5 ;
goto lab30 ;
}
}
lab30: ;
p = h ;
do {
q = mem [p ].hhfield .v.RH ;
if ( mem [p ].hhfield .b1 >= 2 )
{
while ( ( mem [q ].hhfield .b0 == 4 ) && ( mem [q ].hhfield .b1 == 4
) ) q = mem [q ].hhfield .v.RH ;
k = 0 ;
s = p ;
n = pathsize ;
do {
t = mem [s ].hhfield .v.RH ;
deltax [k ]= mem [t + 1 ].cint - mem [s + 1 ].cint ;
deltay [k ]= mem [t + 2 ].cint - mem [s + 2 ].cint ;
delta [k ]= pythadd ( deltax [k ], deltay [k ]) ;
if ( k > 0 )
{
sine = makefraction ( deltay [k - 1 ], delta [k - 1 ]) ;
cosine = makefraction ( deltax [k - 1 ], delta [k - 1 ]) ;
psi [k ]= narg ( takefraction ( deltax [k ], cosine ) +
takefraction ( deltay [k ], sine ) , takefraction ( deltay [k ],
cosine ) - takefraction ( deltax [k ], sine ) ) ;
}
incr ( k ) ;
s = t ;
if ( k == pathsize )
overflow ( 530 , pathsize ) ;
if ( s == q )
n = k ;
} while ( ! ( ( k >= n ) && ( mem [s ].hhfield .b0 != 5 ) ) ) ;
if ( k == n )
psi [n ]= 0 ;
else psi [k ]= psi [1 ];
if ( mem [q ].hhfield .b0 == 4 )
{
delx = mem [q + 5 ].cint - mem [q + 1 ].cint ;
dely = mem [q + 6 ].cint - mem [q + 2 ].cint ;
if ( ( delx == 0 ) && ( dely == 0 ) )
{
mem [q ].hhfield .b0 = 3 ;
mem [q + 3 ].cint = 65536L ;
}
else {
mem [q ].hhfield .b0 = 2 ;
mem [q + 3 ].cint = narg ( delx , dely ) ;
}
}
if ( ( mem [p ].hhfield .b1 == 4 ) && ( mem [p ].hhfield .b0 == 1 )
)
{
delx = mem [p + 1 ].cint - mem [p + 3 ].cint ;
dely = mem [p + 2 ].cint - mem [p + 4 ].cint ;
if ( ( delx == 0 ) && ( dely == 0 ) )
{
mem [p ].hhfield .b1 = 3 ;
mem [p + 5 ].cint = 65536L ;
}
else {
mem [p ].hhfield .b1 = 2 ;
mem [p + 5 ].cint = narg ( delx , dely ) ;
}
}
solvechoices ( p , q , n ) ;
}
p = q ;
} while ( ! ( p == h ) ) ;
if ( internal [4 ]> 0 )
printpath ( knots , 526 , true ) ;
if ( aritherror )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 527 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 528 ;
helpline [0 ]= 529 ;
}
putgeterror () ;
aritherror = false ;
}
}
void
#ifdef HAVE_PROTOTYPES
zmakemoves ( scaled xx0 , scaled xx1 , scaled xx2 , scaled xx3 , scaled yy0 ,
scaled yy1 , scaled yy2 , scaled yy3 , smallnumber xicorr , smallnumber
etacorr )
#else
zmakemoves ( xx0 , xx1 , xx2 , xx3 , yy0 , yy1 , yy2 , yy3 , xicorr , etacorr
)
scaled xx0 ;
scaled xx1 ;
scaled xx2 ;
scaled xx3 ;
scaled yy0 ;
scaled yy1 ;
scaled yy2 ;
scaled yy3 ;
smallnumber xicorr ;
smallnumber etacorr ;
#endif
{
/* 22 30 10 */ integer x1, x2, x3, m, r, y1, y2, y3, n, s, l ;
integer q, t, u, x2a, x3a, y2a, y3a ;
if ( ( xx3 < xx0 ) || ( yy3 < yy0 ) )
confusion ( 109 ) ;
l = 16 ;
bisectptr = 0 ;
x1 = xx1 - xx0 ;
x2 = xx2 - xx1 ;
x3 = xx3 - xx2 ;
if ( xx0 >= xicorr )
r = ( xx0 - xicorr ) % 65536L ;
else r = 65535L - ( ( - (integer) xx0 + xicorr - 1 ) % 65536L ) ;
m = ( xx3 - xx0 + r ) / 65536L ;
y1 = yy1 - yy0 ;
y2 = yy2 - yy1 ;
y3 = yy3 - yy2 ;
if ( yy0 >= etacorr )
s = ( yy0 - etacorr ) % 65536L ;
else s = 65535L - ( ( - (integer) yy0 + etacorr - 1 ) % 65536L ) ;
n = ( yy3 - yy0 + s ) / 65536L ;
if ( ( xx3 - xx0 >= 268435456L ) || ( yy3 - yy0 >= 268435456L ) )
{
x1 = half ( x1 + xicorr ) ;
x2 = half ( x2 + xicorr ) ;
x3 = half ( x3 + xicorr ) ;
r = half ( r + xicorr ) ;
y1 = half ( y1 + etacorr ) ;
y2 = half ( y2 + etacorr ) ;
y3 = half ( y3 + etacorr ) ;
s = half ( s + etacorr ) ;
l = 15 ;
}
while ( true ) {
lab22: if ( m == 0 )
while ( n > 0 ) {
incr ( moveptr ) ;
move [moveptr ]= 1 ;
decr ( n ) ;
}
else if ( n == 0 )
move [moveptr ]= move [moveptr ]+ m ;
else if ( m + n == 2 )
{
r = twotothe [l ]- r ;
s = twotothe [l ]- s ;
while ( l < 30 ) {
x3a = x3 ;
x2a = half ( x2 + x3 + xicorr ) ;
x2 = half ( x1 + x2 + xicorr ) ;
x3 = half ( x2 + x2a + xicorr ) ;
t = x1 + x2 + x3 ;
r = r + r - xicorr ;
y3a = y3 ;
y2a = half ( y2 + y3 + etacorr ) ;
y2 = half ( y1 + y2 + etacorr ) ;
y3 = half ( y2 + y2a + etacorr ) ;
u = y1 + y2 + y3 ;
s = s + s - etacorr ;
if ( t < r )
if ( u < s )
{
x1 = x3 ;
x2 = x2a ;
x3 = x3a ;
r = r - t ;
y1 = y3 ;
y2 = y2a ;
y3 = y3a ;
s = s - u ;
}
else {
{
incr ( moveptr ) ;
move [moveptr ]= 2 ;
}
goto lab30 ;
}
else if ( u < s )
{
{
incr ( move [moveptr ]) ;
incr ( moveptr ) ;
move [moveptr ]= 1 ;
}
goto lab30 ;
}
incr ( l ) ;
}
r = r - xicorr ;
s = s - etacorr ;
if ( abvscd ( x1 + x2 + x3 , s , y1 + y2 + y3 , r ) - xicorr >= 0 )
{
incr ( move [moveptr ]) ;
incr ( moveptr ) ;
move [moveptr ]= 1 ;
}
else {
incr ( moveptr ) ;
move [moveptr ]= 2 ;
}
lab30: ;
}
else {
incr ( l ) ;
bisectstack [bisectptr + 10 ]= l ;
bisectstack [bisectptr + 2 ]= x3 ;
bisectstack [bisectptr + 1 ]= half ( x2 + x3 + xicorr ) ;
x2 = half ( x1 + x2 + xicorr ) ;
x3 = half ( x2 + bisectstack [bisectptr + 1 ]+ xicorr ) ;
bisectstack [bisectptr ]= x3 ;
r = r + r + xicorr ;
t = x1 + x2 + x3 + r ;
q = t / twotothe [l ];
bisectstack [bisectptr + 3 ]= t % twotothe [l ];
bisectstack [bisectptr + 4 ]= m - q ;
m = q ;
bisectstack [bisectptr + 7 ]= y3 ;
bisectstack [bisectptr + 6 ]= half ( y2 + y3 + etacorr ) ;
y2 = half ( y1 + y2 + etacorr ) ;
y3 = half ( y2 + bisectstack [bisectptr + 6 ]+ etacorr ) ;
bisectstack [bisectptr + 5 ]= y3 ;
s = s + s + etacorr ;
u = y1 + y2 + y3 + s ;
q = u / twotothe [l ];
bisectstack [bisectptr + 8 ]= u % twotothe [l ];
bisectstack [bisectptr + 9 ]= n - q ;
n = q ;
bisectptr = bisectptr + 11 ;
goto lab22 ;
}
if ( bisectptr == 0 )
goto lab10 ;
bisectptr = bisectptr - 11 ;
x1 = bisectstack [bisectptr ];
x2 = bisectstack [bisectptr + 1 ];
x3 = bisectstack [bisectptr + 2 ];
r = bisectstack [bisectptr + 3 ];
m = bisectstack [bisectptr + 4 ];
y1 = bisectstack [bisectptr + 5 ];
y2 = bisectstack [bisectptr + 6 ];
y3 = bisectstack [bisectptr + 7 ];
s = bisectstack [bisectptr + 8 ];
n = bisectstack [bisectptr + 9 ];
l = bisectstack [bisectptr + 10 ];
}
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zsmoothmoves ( integer b , integer t )
#else
zsmoothmoves ( b , t )
integer b ;
integer t ;
#endif
{
integer k ;
integer a, aa, aaa ;
if ( t - b >= 3 )
{
k = b + 2 ;
aa = move [k - 1 ];
aaa = move [k - 2 ];
do {
a = move [k ];
if ( abs ( a - aa ) > 1 )
if ( a > aa )
{
if ( aaa >= aa )
if ( a >= move [k + 1 ])
{
incr ( move [k - 1 ]) ;
move [k ]= a - 1 ;
}
}
else {
if ( aaa <= aa )
if ( a <= move [k + 1 ])
{
decr ( move [k - 1 ]) ;
move [k ]= a + 1 ;
}
}
incr ( k ) ;
aaa = aa ;
aa = a ;
} while ( ! ( k == t ) ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zinitedges ( halfword h )
#else
zinitedges ( h )
halfword h ;
#endif
{
mem [h ].hhfield .lhfield = h ;
mem [h ].hhfield .v.RH = h ;
mem [h + 1 ].hhfield .lhfield = 8191 ;
mem [h + 1 ].hhfield .v.RH = 1 ;
mem [h + 2 ].hhfield .lhfield = 8191 ;
mem [h + 2 ].hhfield .v.RH = 1 ;
mem [h + 3 ].hhfield .lhfield = 4096 ;
mem [h + 3 ].hhfield .v.RH = 0 ;
mem [h + 4 ].cint = 0 ;
mem [h + 5 ].hhfield .v.RH = h ;
mem [h + 5 ].hhfield .lhfield = 0 ;
}
void
#ifdef HAVE_PROTOTYPES
fixoffset ( void )
#else
fixoffset ( )
#endif
{
halfword p, q ;
integer delta ;
delta = 8 * ( mem [curedges + 3 ].hhfield .lhfield - 4096 ) ;
mem [curedges + 3 ].hhfield .lhfield = 4096 ;
q = mem [curedges ].hhfield .v.RH ;
while ( q != curedges ) {
p = mem [q + 1 ].hhfield .v.RH ;
while ( p != memtop ) {
mem [p ].hhfield .lhfield = mem [p ].hhfield .lhfield - delta ;
p = mem [p ].hhfield .v.RH ;
}
p = mem [q + 1 ].hhfield .lhfield ;
while ( p > 1 ) {
mem [p ].hhfield .lhfield = mem [p ].hhfield .lhfield - delta ;
p = mem [p ].hhfield .v.RH ;
}
q = mem [q ].hhfield .v.RH ;
}
}
void
#ifdef HAVE_PROTOTYPES
zedgeprep ( integer ml , integer mr , integer nl , integer nr )
#else
zedgeprep ( ml , mr , nl , nr )
integer ml ;
integer mr ;
integer nl ;
integer nr ;
#endif
{
halfword delta ;
integer temp ;
halfword p, q ;
ml = ml + 4096 ;
mr = mr + 4096 ;
nl = nl + 4096 ;
nr = nr + 4095 ;
if ( ml < mem [curedges + 2 ].hhfield .lhfield )
mem [curedges + 2 ].hhfield .lhfield = ml ;
if ( mr > mem [curedges + 2 ].hhfield .v.RH )
mem [curedges + 2 ].hhfield .v.RH = mr ;
temp = mem [curedges + 3 ].hhfield .lhfield - 4096 ;
if ( ! ( abs ( mem [curedges + 2 ].hhfield .lhfield + temp - 4096 ) < 4096
) || ! ( abs ( mem [curedges + 2 ].hhfield .v.RH + temp - 4096 ) < 4096 )
)
fixoffset () ;
if ( mem [curedges ].hhfield .v.RH == curedges )
{
mem [curedges + 1 ].hhfield .lhfield = nr + 1 ;
mem [curedges + 1 ].hhfield .v.RH = nr ;
}
if ( nl < mem [curedges + 1 ].hhfield .lhfield )
{
delta = mem [curedges + 1 ].hhfield .lhfield - nl ;
mem [curedges + 1 ].hhfield .lhfield = nl ;
p = mem [curedges ].hhfield .v.RH ;
do {
q = getnode ( 2 ) ;
mem [q + 1 ].hhfield .v.RH = memtop ;
mem [q + 1 ].hhfield .lhfield = 1 ;
mem [p ].hhfield .lhfield = q ;
mem [q ].hhfield .v.RH = p ;
p = q ;
decr ( delta ) ;
} while ( ! ( delta == 0 ) ) ;
mem [p ].hhfield .lhfield = curedges ;
mem [curedges ].hhfield .v.RH = p ;
if ( mem [curedges + 5 ].hhfield .v.RH == curedges )
mem [curedges + 5 ].hhfield .lhfield = nl - 1 ;
}
if ( nr > mem [curedges + 1 ].hhfield .v.RH )
{
delta = nr - mem [curedges + 1 ].hhfield .v.RH ;
mem [curedges + 1 ].hhfield .v.RH = nr ;
p = mem [curedges ].hhfield .lhfield ;
do {
q = getnode ( 2 ) ;
mem [q + 1 ].hhfield .v.RH = memtop ;
mem [q + 1 ].hhfield .lhfield = 1 ;
mem [p ].hhfield .v.RH = q ;
mem [q ].hhfield .lhfield = p ;
p = q ;
decr ( delta ) ;
} while ( ! ( delta == 0 ) ) ;
mem [p ].hhfield .v.RH = curedges ;
mem [curedges ].hhfield .lhfield = p ;
if ( mem [curedges + 5 ].hhfield .v.RH == curedges )
mem [curedges + 5 ].hhfield .lhfield = nr + 1 ;
}
}
halfword
#ifdef HAVE_PROTOTYPES
zcopyedges ( halfword h )
#else
zcopyedges ( h )
halfword h ;
#endif
{
register halfword Result; halfword p, r ;
halfword hh, pp, qq, rr, ss ;
hh = getnode ( 6 ) ;
mem [hh + 1 ]= mem [h + 1 ];
mem [hh + 2 ]= mem [h + 2 ];
mem [hh + 3 ]= mem [h + 3 ];
mem [hh + 4 ]= mem [h + 4 ];
mem [hh + 5 ].hhfield .lhfield = mem [hh + 1 ].hhfield .v.RH + 1 ;
mem [hh + 5 ].hhfield .v.RH = hh ;
p = mem [h ].hhfield .v.RH ;
qq = hh ;
while ( p != h ) {
pp = getnode ( 2 ) ;
mem [qq ].hhfield .v.RH = pp ;
mem [pp ].hhfield .lhfield = qq ;
r = mem [p + 1 ].hhfield .v.RH ;
rr = pp + 1 ;
while ( r != memtop ) {
ss = getavail () ;
mem [rr ].hhfield .v.RH = ss ;
rr = ss ;
mem [rr ].hhfield .lhfield = mem [r ].hhfield .lhfield ;
r = mem [r ].hhfield .v.RH ;
}
mem [rr ].hhfield .v.RH = memtop ;
r = mem [p + 1 ].hhfield .lhfield ;
rr = memtop - 1 ;
while ( r > 1 ) {
ss = getavail () ;
mem [rr ].hhfield .v.RH = ss ;
rr = ss ;
mem [rr ].hhfield .lhfield = mem [r ].hhfield .lhfield ;
r = mem [r ].hhfield .v.RH ;
}
mem [rr ].hhfield .v.RH = r ;
mem [pp + 1 ].hhfield .lhfield = mem [memtop - 1 ].hhfield .v.RH ;
p = mem [p ].hhfield .v.RH ;
qq = pp ;
}
mem [qq ].hhfield .v.RH = hh ;
mem [hh ].hhfield .lhfield = qq ;
Result = hh ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
yreflectedges ( void )
#else
yreflectedges ( )
#endif
{
halfword p, q, r ;
p = mem [curedges + 1 ].hhfield .lhfield ;
mem [curedges + 1 ].hhfield .lhfield = 8191 - mem [curedges + 1 ]
.hhfield .v.RH ;
mem [curedges + 1 ].hhfield .v.RH = 8191 - p ;
mem [curedges + 5 ].hhfield .lhfield = 8191 - mem [curedges + 5 ]
.hhfield .lhfield ;
p = mem [curedges ].hhfield .v.RH ;
q = curedges ;
do {
r = mem [p ].hhfield .v.RH ;
mem [p ].hhfield .v.RH = q ;
mem [q ].hhfield .lhfield = p ;
q = p ;
p = r ;
} while ( ! ( q == curedges ) ) ;
mem [curedges + 4 ].cint = 0 ;
}
void
#ifdef HAVE_PROTOTYPES
xreflectedges ( void )
#else
xreflectedges ( )
#endif
{
halfword p, q, r, s ;
integer m ;
p = mem [curedges + 2 ].hhfield .lhfield ;
mem [curedges + 2 ].hhfield .lhfield = 8192 - mem [curedges + 2 ]
.hhfield .v.RH ;
mem [curedges + 2 ].hhfield .v.RH = 8192 - p ;
m = ( 4096 + mem [curedges + 3 ].hhfield .lhfield ) * 8 + 8 ;
mem [curedges + 3 ].hhfield .lhfield = 4096 ;
p = mem [curedges ].hhfield .v.RH ;
do {
q = mem [p + 1 ].hhfield .v.RH ;
r = memtop ;
while ( q != memtop ) {
s = mem [q ].hhfield .v.RH ;
mem [q ].hhfield .v.RH = r ;
r = q ;
mem [r ].hhfield .lhfield = m - mem [q ].hhfield .lhfield ;
q = s ;
}
mem [p + 1 ].hhfield .v.RH = r ;
q = mem [p + 1 ].hhfield .lhfield ;
while ( q > 1 ) {
mem [q ].hhfield .lhfield = m - mem [q ].hhfield .lhfield ;
q = mem [q ].hhfield .v.RH ;
}
p = mem [p ].hhfield .v.RH ;
} while ( ! ( p == curedges ) ) ;
mem [curedges + 4 ].cint = 0 ;
}
void
#ifdef HAVE_PROTOTYPES
zyscaleedges ( integer s )
#else
zyscaleedges ( s )
integer s ;
#endif
{
halfword p, q, pp, r, rr, ss ;
integer t ;
if ( ( s * ( mem [curedges + 1 ].hhfield .v.RH - 4095 ) >= 4096 ) || ( s *
( mem [curedges + 1 ].hhfield .lhfield - 4096 ) <= -4096 ) )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 534 ) ;
}
{
helpptr = 3 ;
helpline [2 ]= 535 ;
helpline [1 ]= 536 ;
helpline [0 ]= 537 ;
}
putgeterror () ;
}
else {
mem [curedges + 1 ].hhfield .v.RH = s * ( mem [curedges + 1 ].hhfield
.v.RH - 4095 ) + 4095 ;
mem [curedges + 1 ].hhfield .lhfield = s * ( mem [curedges + 1 ]
.hhfield .lhfield - 4096 ) + 4096 ;
p = curedges ;
do {
q = p ;
p = mem [p ].hhfield .v.RH ;
{register integer for_end; t = 2 ;for_end = s ; if ( t <= for_end) do
{
pp = getnode ( 2 ) ;
mem [q ].hhfield .v.RH = pp ;
mem [p ].hhfield .lhfield = pp ;
mem [pp ].hhfield .v.RH = p ;
mem [pp ].hhfield .lhfield = q ;
q = pp ;
r = mem [p + 1 ].hhfield .v.RH ;
rr = pp + 1 ;
while ( r != memtop ) {
ss = getavail () ;
mem [rr ].hhfield .v.RH = ss ;
rr = ss ;
mem [rr ].hhfield .lhfield = mem [r ].hhfield .lhfield ;
r = mem [r ].hhfield .v.RH ;
}
mem [rr ].hhfield .v.RH = memtop ;
r = mem [p + 1 ].hhfield .lhfield ;
rr = memtop - 1 ;
while ( r > 1 ) {
ss = getavail () ;
mem [rr ].hhfield .v.RH = ss ;
rr = ss ;
mem [rr ].hhfield .lhfield = mem [r ].hhfield .lhfield ;
r = mem [r ].hhfield .v.RH ;
}
mem [rr ].hhfield .v.RH = r ;
mem [pp + 1 ].hhfield .lhfield = mem [memtop - 1 ].hhfield .v.RH
;
}
while ( t++ < for_end ) ;}
} while ( ! ( mem [p ].hhfield .v.RH == curedges ) ) ;
mem [curedges + 4 ].cint = 0 ;
}
}
void
#ifdef HAVE_PROTOTYPES
zxscaleedges ( integer s )
#else
zxscaleedges ( s )
integer s ;
#endif
{
halfword p, q ;
unsigned short t ;
char w ;
integer delta ;
if ( ( s * ( mem [curedges + 2 ].hhfield .v.RH - 4096 ) >= 4096 ) || ( s *
( mem [curedges + 2 ].hhfield .lhfield - 4096 ) <= -4096 ) )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 534 ) ;
}
{
helpptr = 3 ;
helpline [2 ]= 538 ;
helpline [1 ]= 536 ;
helpline [0 ]= 537 ;
}
putgeterror () ;
}
else if ( ( mem [curedges + 2 ].hhfield .v.RH != 4096 ) || ( mem [
curedges + 2 ].hhfield .lhfield != 4096 ) )
{
mem [curedges + 2 ].hhfield .v.RH = s * ( mem [curedges + 2 ].hhfield
.v.RH - 4096 ) + 4096 ;
mem [curedges + 2 ].hhfield .lhfield = s * ( mem [curedges + 2 ]
.hhfield .lhfield - 4096 ) + 4096 ;
delta = 8 * ( 4096 - s * mem [curedges + 3 ].hhfield .lhfield ) + 0 ;
mem [curedges + 3 ].hhfield .lhfield = 4096 ;
q = mem [curedges ].hhfield .v.RH ;
do {
p = mem [q + 1 ].hhfield .v.RH ;
while ( p != memtop ) {
t = mem [p ].hhfield .lhfield ;
w = t % 8 ;
mem [p ].hhfield .lhfield = ( t - w ) * s + w + delta ;
p = mem [p ].hhfield .v.RH ;
}
p = mem [q + 1 ].hhfield .lhfield ;
while ( p > 1 ) {
t = mem [p ].hhfield .lhfield ;
w = t % 8 ;
mem [p ].hhfield .lhfield = ( t - w ) * s + w + delta ;
p = mem [p ].hhfield .v.RH ;
}
q = mem [q ].hhfield .v.RH ;
} while ( ! ( q == curedges ) ) ;
mem [curedges + 4 ].cint = 0 ;
}
}
void
#ifdef HAVE_PROTOTYPES
znegateedges ( halfword h )
#else
znegateedges ( h )
halfword h ;
#endif
{
/* 30 */ halfword p, q, r, s, t, u ;
p = mem [h ].hhfield .v.RH ;
while ( p != h ) {
q = mem [p + 1 ].hhfield .lhfield ;
while ( q > 1 ) {
mem [q ].hhfield .lhfield = 8 - 2 * ( ( mem [q ].hhfield .lhfield )
% 8 ) + mem [q ].hhfield .lhfield ;
q = mem [q ].hhfield .v.RH ;
}
q = mem [p + 1 ].hhfield .v.RH ;
if ( q != memtop )
{
do {
mem [q ].hhfield .lhfield = 8 - 2 * ( ( mem [q ].hhfield
.lhfield ) % 8 ) + mem [q ].hhfield .lhfield ;
q = mem [q ].hhfield .v.RH ;
} while ( ! ( q == memtop ) ) ;
u = p + 1 ;
q = mem [u ].hhfield .v.RH ;
r = q ;
s = mem [r ].hhfield .v.RH ;
while ( true ) if ( mem [s ].hhfield .lhfield > mem [r ].hhfield
.lhfield )
{
mem [u ].hhfield .v.RH = q ;
if ( s == memtop )
goto lab30 ;
u = r ;
q = s ;
r = q ;
s = mem [r ].hhfield .v.RH ;
}
else {
t = s ;
s = mem [t ].hhfield .v.RH ;
mem [t ].hhfield .v.RH = q ;
q = t ;
}
lab30: mem [r ].hhfield .v.RH = memtop ;
}
p = mem [p ].hhfield .v.RH ;
}
mem [h + 4 ].cint = 0 ;
}
void
#ifdef HAVE_PROTOTYPES
zsortedges ( halfword h )
#else
zsortedges ( h )
halfword h ;
#endif
{
/* 30 */ halfword k ;
halfword p, q, r, s ;
r = mem [h + 1 ].hhfield .lhfield ;
mem [h + 1 ].hhfield .lhfield = 0 ;
p = mem [r ].hhfield .v.RH ;
mem [r ].hhfield .v.RH = memtop ;
mem [memtop - 1 ].hhfield .v.RH = r ;
while ( p > 1 ) {
k = mem [p ].hhfield .lhfield ;
q = memtop - 1 ;
do {
r = q ;
q = mem [r ].hhfield .v.RH ;
} while ( ! ( k <= mem [q ].hhfield .lhfield ) ) ;
mem [r ].hhfield .v.RH = p ;
r = mem [p ].hhfield .v.RH ;
mem [p ].hhfield .v.RH = q ;
p = r ;
}
{
r = h + 1 ;
q = mem [r ].hhfield .v.RH ;
p = mem [memtop - 1 ].hhfield .v.RH ;
while ( true ) {
k = mem [p ].hhfield .lhfield ;
while ( k > mem [q ].hhfield .lhfield ) {
r = q ;
q = mem [r ].hhfield .v.RH ;
}
mem [r ].hhfield .v.RH = p ;
s = mem [p ].hhfield .v.RH ;
mem [p ].hhfield .v.RH = q ;
if ( s == memtop )
goto lab30 ;
r = p ;
p = s ;
}
lab30: ;
}
}
void
#ifdef HAVE_PROTOTYPES
zculledges ( integer wlo , integer whi , integer wout , integer win )
#else
zculledges ( wlo , whi , wout , win )
integer wlo ;
integer whi ;
integer wout ;
integer win ;
#endif
{
/* 30 */ halfword p, q, r, s ;
integer w ;
integer d ;
integer m ;
integer mm ;
integer ww ;
integer prevw ;
halfword n, minn, maxn ;
halfword mind, maxd ;
mind = 268435455L ;
maxd = 0 ;
minn = 268435455L ;
maxn = 0 ;
p = mem [curedges ].hhfield .v.RH ;
n = mem [curedges + 1 ].hhfield .lhfield ;
while ( p != curedges ) {
if ( mem [p + 1 ].hhfield .lhfield > 1 )
sortedges ( p ) ;
if ( mem [p + 1 ].hhfield .v.RH != memtop )
{
r = memtop - 1 ;
q = mem [p + 1 ].hhfield .v.RH ;
ww = 0 ;
m = 1000000L ;
prevw = 0 ;
while ( true ) {
if ( q == memtop )
mm = 1000000L ;
else {
d = mem [q ].hhfield .lhfield ;
mm = d / 8 ;
ww = ww + ( d % 8 ) - 4 ;
}
if ( mm > m )
{
if ( w != prevw )
{
s = getavail () ;
mem [r ].hhfield .v.RH = s ;
mem [s ].hhfield .lhfield = 8 * m + 4 + w - prevw ;
r = s ;
prevw = w ;
}
if ( q == memtop )
goto lab30 ;
}
m = mm ;
if ( ww >= wlo )
if ( ww <= whi )
w = win ;
else w = wout ;
else w = wout ;
s = mem [q ].hhfield .v.RH ;
{
mem [q ].hhfield .v.RH = avail ;
avail = q ;
;
#ifdef STAT
decr ( dynused ) ;
#endif /* STAT */
}
q = s ;
}
lab30: mem [r ].hhfield .v.RH = memtop ;
mem [p + 1 ].hhfield .v.RH = mem [memtop - 1 ].hhfield .v.RH ;
if ( r != memtop - 1 )
{
if ( minn == 268435455L )
minn = n ;
maxn = n ;
if ( mind > mem [mem [memtop - 1 ].hhfield .v.RH ].hhfield
.lhfield )
mind = mem [mem [memtop - 1 ].hhfield .v.RH ].hhfield .lhfield ;
if ( maxd < mem [r ].hhfield .lhfield )
maxd = mem [r ].hhfield .lhfield ;
}
}
p = mem [p ].hhfield .v.RH ;
incr ( n ) ;
}
if ( minn > maxn )
{
p = mem [curedges ].hhfield .v.RH ;
while ( p != curedges ) {
q = mem [p ].hhfield .v.RH ;
freenode ( p , 2 ) ;
p = q ;
}
initedges ( curedges ) ;
}
else {
n = mem [curedges + 1 ].hhfield .lhfield ;
mem [curedges + 1 ].hhfield .lhfield = minn ;
while ( minn > n ) {
p = mem [curedges ].hhfield .v.RH ;
mem [curedges ].hhfield .v.RH = mem [p ].hhfield .v.RH ;
mem [mem [p ].hhfield .v.RH ].hhfield .lhfield = curedges ;
freenode ( p , 2 ) ;
incr ( n ) ;
}
n = mem [curedges + 1 ].hhfield .v.RH ;
mem [curedges + 1 ].hhfield .v.RH = maxn ;
mem [curedges + 5 ].hhfield .lhfield = maxn + 1 ;
mem [curedges + 5 ].hhfield .v.RH = curedges ;
while ( maxn < n ) {
p = mem [curedges ].hhfield .lhfield ;
mem [curedges ].hhfield .lhfield = mem [p ].hhfield .lhfield ;
mem [mem [p ].hhfield .lhfield ].hhfield .v.RH = curedges ;
freenode ( p , 2 ) ;
decr ( n ) ;
}
mem [curedges + 2 ].hhfield .lhfield = ( ( mind ) / 8 ) - mem [curedges
+ 3 ].hhfield .lhfield + 4096 ;
mem [curedges + 2 ].hhfield .v.RH = ( ( maxd ) / 8 ) - mem [curedges +
3 ].hhfield .lhfield + 4096 ;
}
mem [curedges + 4 ].cint = 0 ;
}
void
#ifdef HAVE_PROTOTYPES
xyswapedges ( void )
#else
xyswapedges ( )
#endif
{
/* 30 */ integer mmagic, nmagic ;
halfword p, q, r, s ;
integer mspread ;
integer j, jj ;
integer m, mm ;
integer pd, rd ;
integer pm, rm ;
integer w ;
integer ww ;
integer dw ;
integer extras ;
schar xw ;
integer k ;
mspread = mem [curedges + 2 ].hhfield .v.RH - mem [curedges + 2 ]
.hhfield .lhfield ;
if ( mspread > movesize )
overflow ( 539 , movesize ) ;
{register integer for_end; j = 0 ;for_end = mspread ; if ( j <= for_end)
do
move [j ]= memtop ;
while ( j++ < for_end ) ;}
p = getnode ( 2 ) ;
mem [p + 1 ].hhfield .v.RH = memtop ;
mem [p + 1 ].hhfield .lhfield = 0 ;
mem [p ].hhfield .lhfield = curedges ;
mem [mem [curedges ].hhfield .v.RH ].hhfield .lhfield = p ;
p = getnode ( 2 ) ;
mem [p + 1 ].hhfield .v.RH = memtop ;
mem [p ].hhfield .lhfield = mem [curedges ].hhfield .lhfield ;
mmagic = mem [curedges + 2 ].hhfield .lhfield + mem [curedges + 3 ]
.hhfield .lhfield - 4096 ;
nmagic = 8 * mem [curedges + 1 ].hhfield .v.RH + 12 ;
do {
q = mem [p ].hhfield .lhfield ;
if ( mem [q + 1 ].hhfield .lhfield > 1 )
sortedges ( q ) ;
r = mem [p + 1 ].hhfield .v.RH ;
freenode ( p , 2 ) ;
p = r ;
pd = mem [p ].hhfield .lhfield ;
pm = pd / 8 ;
r = mem [q + 1 ].hhfield .v.RH ;
rd = mem [r ].hhfield .lhfield ;
rm = rd / 8 ;
w = 0 ;
while ( true ) {
if ( pm < rm )
mm = pm ;
else mm = rm ;
if ( w != 0 )
if ( m != mm )
{
if ( mm - mmagic >= movesize )
confusion ( 509 ) ;
extras = ( abs ( w ) - 1 ) / 3 ;
if ( extras > 0 )
{
if ( w > 0 )
xw = 3 ;
else xw = -3 ;
ww = w - extras * xw ;
}
else ww = w ;
do {
j = m - mmagic ;
{register integer for_end; k = 1 ;for_end = extras ; if ( k <=
for_end) do
{
s = getavail () ;
mem [s ].hhfield .lhfield = nmagic + xw ;
mem [s ].hhfield .v.RH = move [j ];
move [j ]= s ;
}
while ( k++ < for_end ) ;}
s = getavail () ;
mem [s ].hhfield .lhfield = nmagic + ww ;
mem [s ].hhfield .v.RH = move [j ];
move [j ]= s ;
incr ( m ) ;
} while ( ! ( m == mm ) ) ;
}
if ( pd < rd )
{
dw = ( pd % 8 ) - 4 ;
s = mem [p ].hhfield .v.RH ;
{
mem [p ].hhfield .v.RH = avail ;
avail = p ;
;
#ifdef STAT
decr ( dynused ) ;
#endif /* STAT */
}
p = s ;
pd = mem [p ].hhfield .lhfield ;
pm = pd / 8 ;
}
else {
if ( r == memtop )
goto lab30 ;
dw = - (integer) ( ( rd % 8 ) - 4 ) ;
r = mem [r ].hhfield .v.RH ;
rd = mem [r ].hhfield .lhfield ;
rm = rd / 8 ;
}
m = mm ;
w = w + dw ;
}
lab30: ;
p = q ;
nmagic = nmagic - 8 ;
} while ( ! ( mem [p ].hhfield .lhfield == curedges ) ) ;
freenode ( p , 2 ) ;
move [mspread ]= 0 ;
j = 0 ;
while ( move [j ]== memtop ) incr ( j ) ;
if ( j == mspread )
initedges ( curedges ) ;
else {
mm = mem [curedges + 2 ].hhfield .lhfield ;
mem [curedges + 2 ].hhfield .lhfield = mem [curedges + 1 ].hhfield
.lhfield ;
mem [curedges + 2 ].hhfield .v.RH = mem [curedges + 1 ].hhfield .v.RH
+ 1 ;
mem [curedges + 3 ].hhfield .lhfield = 4096 ;
jj = mspread - 1 ;
while ( move [jj ]== memtop ) decr ( jj ) ;
mem [curedges + 1 ].hhfield .lhfield = j + mm ;
mem [curedges + 1 ].hhfield .v.RH = jj + mm ;
q = curedges ;
do {
p = getnode ( 2 ) ;
mem [q ].hhfield .v.RH = p ;
mem [p ].hhfield .lhfield = q ;
mem [p + 1 ].hhfield .v.RH = move [j ];
mem [p + 1 ].hhfield .lhfield = 0 ;
incr ( j ) ;
q = p ;
} while ( ! ( j > jj ) ) ;
mem [q ].hhfield .v.RH = curedges ;
mem [curedges ].hhfield .lhfield = q ;
mem [curedges + 5 ].hhfield .lhfield = mem [curedges + 1 ].hhfield
.v.RH + 1 ;
mem [curedges + 5 ].hhfield .v.RH = curedges ;
mem [curedges + 4 ].cint = 0 ;
}
}
void
#ifdef HAVE_PROTOTYPES
zmergeedges ( halfword h )
#else
zmergeedges ( h )
halfword h ;
#endif
{
/* 30 */ halfword p, q, r, pp, qq, rr ;
integer n ;
halfword k ;
integer delta ;
if ( mem [h ].hhfield .v.RH != h )
{
if ( ( mem [h + 2 ].hhfield .lhfield < mem [curedges + 2 ].hhfield
.lhfield ) || ( mem [h + 2 ].hhfield .v.RH > mem [curedges + 2 ]
.hhfield .v.RH ) || ( mem [h + 1 ].hhfield .lhfield < mem [curedges + 1
].hhfield .lhfield ) || ( mem [h + 1 ].hhfield .v.RH > mem [curedges +
1 ].hhfield .v.RH ) )
edgeprep ( mem [h + 2 ].hhfield .lhfield - 4096 , mem [h + 2 ].hhfield
.v.RH - 4096 , mem [h + 1 ].hhfield .lhfield - 4096 , mem [h + 1 ]
.hhfield .v.RH - 4095 ) ;
if ( mem [h + 3 ].hhfield .lhfield != mem [curedges + 3 ].hhfield
.lhfield )
{
pp = mem [h ].hhfield .v.RH ;
delta = 8 * ( mem [curedges + 3 ].hhfield .lhfield - mem [h + 3 ]
.hhfield .lhfield ) ;
do {
qq = mem [pp + 1 ].hhfield .v.RH ;
while ( qq != memtop ) {
mem [qq ].hhfield .lhfield = mem [qq ].hhfield .lhfield + delta
;
qq = mem [qq ].hhfield .v.RH ;
}
qq = mem [pp + 1 ].hhfield .lhfield ;
while ( qq > 1 ) {
mem [qq ].hhfield .lhfield = mem [qq ].hhfield .lhfield + delta
;
qq = mem [qq ].hhfield .v.RH ;
}
pp = mem [pp ].hhfield .v.RH ;
} while ( ! ( pp == h ) ) ;
}
n = mem [curedges + 1 ].hhfield .lhfield ;
p = mem [curedges ].hhfield .v.RH ;
pp = mem [h ].hhfield .v.RH ;
while ( n < mem [h + 1 ].hhfield .lhfield ) {
incr ( n ) ;
p = mem [p ].hhfield .v.RH ;
}
do {
qq = mem [pp + 1 ].hhfield .lhfield ;
if ( qq > 1 )
if ( mem [p + 1 ].hhfield .lhfield <= 1 )
mem [p + 1 ].hhfield .lhfield = qq ;
else {
while ( mem [qq ].hhfield .v.RH > 1 ) qq = mem [qq ].hhfield .v.RH
;
mem [qq ].hhfield .v.RH = mem [p + 1 ].hhfield .lhfield ;
mem [p + 1 ].hhfield .lhfield = mem [pp + 1 ].hhfield .lhfield ;
}
mem [pp + 1 ].hhfield .lhfield = 0 ;
qq = mem [pp + 1 ].hhfield .v.RH ;
if ( qq != memtop )
{
if ( mem [p + 1 ].hhfield .lhfield == 1 )
mem [p + 1 ].hhfield .lhfield = 0 ;
mem [pp + 1 ].hhfield .v.RH = memtop ;
r = p + 1 ;
q = mem [r ].hhfield .v.RH ;
if ( q == memtop )
mem [p + 1 ].hhfield .v.RH = qq ;
else while ( true ) {
k = mem [qq ].hhfield .lhfield ;
while ( k > mem [q ].hhfield .lhfield ) {
r = q ;
q = mem [r ].hhfield .v.RH ;
}
mem [r ].hhfield .v.RH = qq ;
rr = mem [qq ].hhfield .v.RH ;
mem [qq ].hhfield .v.RH = q ;
if ( rr == memtop )
goto lab30 ;
r = qq ;
qq = rr ;
}
}
lab30: ;
pp = mem [pp ].hhfield .v.RH ;
p = mem [p ].hhfield .v.RH ;
} while ( ! ( pp == h ) ) ;
}
}
integer
#ifdef HAVE_PROTOTYPES
ztotalweight ( halfword h )
#else
ztotalweight ( h )
halfword h ;
#endif
{
register integer Result; halfword p, q ;
integer n ;
unsigned short m ;
n = 0 ;
p = mem [h ].hhfield .v.RH ;
while ( p != h ) {
q = mem [p + 1 ].hhfield .v.RH ;
while ( q != memtop ) {
m = mem [q ].hhfield .lhfield ;
n = n - ( ( m % 8 ) - 4 ) * ( m / 8 ) ;
q = mem [q ].hhfield .v.RH ;
}
q = mem [p + 1 ].hhfield .lhfield ;
while ( q > 1 ) {
m = mem [q ].hhfield .lhfield ;
n = n - ( ( m % 8 ) - 4 ) * ( m / 8 ) ;
q = mem [q ].hhfield .v.RH ;
}
p = mem [p ].hhfield .v.RH ;
}
Result = n ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
beginedgetracing ( void )
#else
beginedgetracing ( )
#endif
{
printdiagnostic ( 540 , 283 , true ) ;
print ( 541 ) ;
printint ( curwt ) ;
printchar ( 41 ) ;
tracex = -4096 ;
}
void
#ifdef HAVE_PROTOTYPES
traceacorner ( void )
#else
traceacorner ( )
#endif
{
if ( fileoffset > maxprintline - 13 )
printnl ( 283 ) ;
printchar ( 40 ) ;
printint ( tracex ) ;
printchar ( 44 ) ;
printint ( traceyy ) ;
printchar ( 41 ) ;
tracey = traceyy ;
}
void
#ifdef HAVE_PROTOTYPES
endedgetracing ( void )
#else
endedgetracing ( )
#endif
{
if ( tracex == -4096 )
printnl ( 542 ) ;
else {
traceacorner () ;
printchar ( 46 ) ;
}
enddiagnostic ( true ) ;
}
void
#ifdef HAVE_PROTOTYPES
ztracenewedge ( halfword r , integer n )
#else
ztracenewedge ( r , n )
halfword r ;
integer n ;
#endif
{
integer d ;
schar w ;
integer m, n0, n1 ;
d = mem [r ].hhfield .lhfield ;
w = ( d % 8 ) - 4 ;
m = ( d / 8 ) - mem [curedges + 3 ].hhfield .lhfield ;
if ( w == curwt )
{
n0 = n + 1 ;
n1 = n ;
}
else {
n0 = n ;
n1 = n + 1 ;
}
if ( m != tracex )
{
if ( tracex == -4096 )
{
printnl ( 283 ) ;
traceyy = n0 ;
}
else if ( traceyy != n0 )
printchar ( 63 ) ;
else traceacorner () ;
tracex = m ;
traceacorner () ;
}
else {
if ( n0 != traceyy )
printchar ( 33 ) ;
if ( ( ( n0 < n1 ) && ( tracey > traceyy ) ) || ( ( n0 > n1 ) && ( tracey
< traceyy ) ) )
traceacorner () ;
}
traceyy = n1 ;
}
void
#ifdef HAVE_PROTOTYPES
zlineedges ( scaled x0 , scaled y0 , scaled x1 , scaled y1 )
#else
zlineedges ( x0 , y0 , x1 , y1 )
scaled x0 ;
scaled y0 ;
scaled x1 ;
scaled y1 ;
#endif
{
/* 30 31 */ integer m0, n0, m1, n1 ;
scaled delx, dely ;
scaled yt ;
scaled tx ;
halfword p, r ;
integer base ;
integer n ;
n0 = roundunscaled ( y0 ) ;
n1 = roundunscaled ( y1 ) ;
if ( n0 != n1 )
{
m0 = roundunscaled ( x0 ) ;
m1 = roundunscaled ( x1 ) ;
delx = x1 - x0 ;
dely = y1 - y0 ;
yt = n0 * 65536L - 32768L ;
y0 = y0 - yt ;
y1 = y1 - yt ;
if ( n0 < n1 )
{
base = 8 * mem [curedges + 3 ].hhfield .lhfield + 4 - curwt ;
if ( m0 <= m1 )
edgeprep ( m0 , m1 , n0 , n1 ) ;
else edgeprep ( m1 , m0 , n0 , n1 ) ;
n = mem [curedges + 5 ].hhfield .lhfield - 4096 ;
p = mem [curedges + 5 ].hhfield .v.RH ;
if ( n != n0 )
if ( n < n0 )
do {
incr ( n ) ;
p = mem [p ].hhfield .v.RH ;
} while ( ! ( n == n0 ) ) ;
else do {
decr ( n ) ;
p = mem [p ].hhfield .lhfield ;
} while ( ! ( n == n0 ) ) ;
y0 = 65536L - y0 ;
while ( true ) {
r = getavail () ;
mem [r ].hhfield .v.RH = mem [p + 1 ].hhfield .lhfield ;
mem [p + 1 ].hhfield .lhfield = r ;
tx = takefraction ( delx , makefraction ( y0 , dely ) ) ;
if ( abvscd ( delx , y0 , dely , tx ) < 0 )
decr ( tx ) ;
mem [r ].hhfield .lhfield = 8 * roundunscaled ( x0 + tx ) + base ;
y1 = y1 - 65536L ;
if ( internal [10 ]> 0 )
tracenewedge ( r , n ) ;
if ( y1 < 65536L )
goto lab30 ;
p = mem [p ].hhfield .v.RH ;
y0 = y0 + 65536L ;
incr ( n ) ;
}
lab30: ;
}
else {
base = 8 * mem [curedges + 3 ].hhfield .lhfield + 4 + curwt ;
if ( m0 <= m1 )
edgeprep ( m0 , m1 , n1 , n0 ) ;
else edgeprep ( m1 , m0 , n1 , n0 ) ;
decr ( n0 ) ;
n = mem [curedges + 5 ].hhfield .lhfield - 4096 ;
p = mem [curedges + 5 ].hhfield .v.RH ;
if ( n != n0 )
if ( n < n0 )
do {
incr ( n ) ;
p = mem [p ].hhfield .v.RH ;
} while ( ! ( n == n0 ) ) ;
else do {
decr ( n ) ;
p = mem [p ].hhfield .lhfield ;
} while ( ! ( n == n0 ) ) ;
while ( true ) {
r = getavail () ;
mem [r ].hhfield .v.RH = mem [p + 1 ].hhfield .lhfield ;
mem [p + 1 ].hhfield .lhfield = r ;
tx = takefraction ( delx , makefraction ( y0 , dely ) ) ;
if ( abvscd ( delx , y0 , dely , tx ) < 0 )
incr ( tx ) ;
mem [r ].hhfield .lhfield = 8 * roundunscaled ( x0 - tx ) + base ;
y1 = y1 + 65536L ;
if ( internal [10 ]> 0 )
tracenewedge ( r , n ) ;
if ( y1 >= 0 )
goto lab31 ;
p = mem [p ].hhfield .lhfield ;
y0 = y0 + 65536L ;
decr ( n ) ;
}
lab31: ;
}
mem [curedges + 5 ].hhfield .v.RH = p ;
mem [curedges + 5 ].hhfield .lhfield = n + 4096 ;
}
}
void
#ifdef HAVE_PROTOTYPES
zmovetoedges ( integer m0 , integer n0 , integer m1 , integer n1 )
#else
zmovetoedges ( m0 , n0 , m1 , n1 )
integer m0 ;
integer n0 ;
integer m1 ;
integer n1 ;
#endif
{
/* 60 61 62 63 30 */ integer delta ;
integer k ;
halfword p, r ;
integer dx ;
integer edgeandweight ;
integer j ;
integer n ;
#ifdef TEXMF_DEBUG
integer sum ;
#endif /* TEXMF_DEBUG */
delta = n1 - n0 ;
;
#ifdef TEXMF_DEBUG
sum = move [0 ];
{register integer for_end; k = 1 ;for_end = delta ; if ( k <= for_end) do
sum = sum + abs ( move [k ]) ;
while ( k++ < for_end ) ;}
if ( sum != m1 - m0 )
confusion ( 48 ) ;
#endif /* TEXMF_DEBUG */
switch ( octant )
{case 1 :
{
dx = 8 ;
edgeprep ( m0 , m1 , n0 , n1 ) ;
goto lab60 ;
}
break ;
case 5 :
{
dx = 8 ;
edgeprep ( n0 , n1 , m0 , m1 ) ;
goto lab62 ;
}
break ;
case 6 :
{
dx = -8 ;
edgeprep ( - (integer) n1 , - (integer) n0 , m0 , m1 ) ;
n0 = - (integer) n0 ;
goto lab62 ;
}
break ;
case 2 :
{
dx = -8 ;
edgeprep ( - (integer) m1 , - (integer) m0 , n0 , n1 ) ;
m0 = - (integer) m0 ;
goto lab60 ;
}
break ;
case 4 :
{
dx = -8 ;
edgeprep ( - (integer) m1 , - (integer) m0 , - (integer) n1 ,
- (integer) n0 ) ;
m0 = - (integer) m0 ;
goto lab61 ;
}
break ;
case 8 :
{
dx = -8 ;
edgeprep ( - (integer) n1 , - (integer) n0 , - (integer) m1 ,
- (integer) m0 ) ;
n0 = - (integer) n0 ;
goto lab63 ;
}
break ;
case 7 :
{
dx = 8 ;
edgeprep ( n0 , n1 , - (integer) m1 , - (integer) m0 ) ;
goto lab63 ;
}
break ;
case 3 :
{
dx = 8 ;
edgeprep ( m0 , m1 , - (integer) n1 , - (integer) n0 ) ;
goto lab61 ;
}
break ;
}
lab60: n = mem [curedges + 5 ].hhfield .lhfield - 4096 ;
p = mem [curedges + 5 ].hhfield .v.RH ;
if ( n != n0 )
if ( n < n0 )
do {
incr ( n ) ;
p = mem [p ].hhfield .v.RH ;
} while ( ! ( n == n0 ) ) ;
else do {
decr ( n ) ;
p = mem [p ].hhfield .lhfield ;
} while ( ! ( n == n0 ) ) ;
if ( delta > 0 )
{
k = 0 ;
edgeandweight = 8 * ( m0 + mem [curedges + 3 ].hhfield .lhfield ) + 4 -
curwt ;
do {
edgeandweight = edgeandweight + dx * move [k ];
{
r = avail ;
if ( r == 0 )
r = getavail () ;
else {
avail = mem [r ].hhfield .v.RH ;
mem [r ].hhfield .v.RH = 0 ;
;
#ifdef STAT
incr ( dynused ) ;
#endif /* STAT */
}
}
mem [r ].hhfield .v.RH = mem [p + 1 ].hhfield .lhfield ;
mem [r ].hhfield .lhfield = edgeandweight ;
if ( internal [10 ]> 0 )
tracenewedge ( r , n ) ;
mem [p + 1 ].hhfield .lhfield = r ;
p = mem [p ].hhfield .v.RH ;
incr ( k ) ;
incr ( n ) ;
} while ( ! ( k == delta ) ) ;
}
goto lab30 ;
lab61: n0 = - (integer) n0 - 1 ;
n = mem [curedges + 5 ].hhfield .lhfield - 4096 ;
p = mem [curedges + 5 ].hhfield .v.RH ;
if ( n != n0 )
if ( n < n0 )
do {
incr ( n ) ;
p = mem [p ].hhfield .v.RH ;
} while ( ! ( n == n0 ) ) ;
else do {
decr ( n ) ;
p = mem [p ].hhfield .lhfield ;
} while ( ! ( n == n0 ) ) ;
if ( delta > 0 )
{
k = 0 ;
edgeandweight = 8 * ( m0 + mem [curedges + 3 ].hhfield .lhfield ) + 4 +
curwt ;
do {
edgeandweight = edgeandweight + dx * move [k ];
{
r = avail ;
if ( r == 0 )
r = getavail () ;
else {
avail = mem [r ].hhfield .v.RH ;
mem [r ].hhfield .v.RH = 0 ;
;
#ifdef STAT
incr ( dynused ) ;
#endif /* STAT */
}
}
mem [r ].hhfield .v.RH = mem [p + 1 ].hhfield .lhfield ;
mem [r ].hhfield .lhfield = edgeandweight ;
if ( internal [10 ]> 0 )
tracenewedge ( r , n ) ;
mem [p + 1 ].hhfield .lhfield = r ;
p = mem [p ].hhfield .lhfield ;
incr ( k ) ;
decr ( n ) ;
} while ( ! ( k == delta ) ) ;
}
goto lab30 ;
lab62: edgeandweight = 8 * ( n0 + mem [curedges + 3 ].hhfield .lhfield ) +
4 - curwt ;
n0 = m0 ;
k = 0 ;
n = mem [curedges + 5 ].hhfield .lhfield - 4096 ;
p = mem [curedges + 5 ].hhfield .v.RH ;
if ( n != n0 )
if ( n < n0 )
do {
incr ( n ) ;
p = mem [p ].hhfield .v.RH ;
} while ( ! ( n == n0 ) ) ;
else do {
decr ( n ) ;
p = mem [p ].hhfield .lhfield ;
} while ( ! ( n == n0 ) ) ;
do {
j = move [k ];
while ( j > 0 ) {
{
r = avail ;
if ( r == 0 )
r = getavail () ;
else {
avail = mem [r ].hhfield .v.RH ;
mem [r ].hhfield .v.RH = 0 ;
;
#ifdef STAT
incr ( dynused ) ;
#endif /* STAT */
}
}
mem [r ].hhfield .v.RH = mem [p + 1 ].hhfield .lhfield ;
mem [r ].hhfield .lhfield = edgeandweight ;
if ( internal [10 ]> 0 )
tracenewedge ( r , n ) ;
mem [p + 1 ].hhfield .lhfield = r ;
p = mem [p ].hhfield .v.RH ;
decr ( j ) ;
incr ( n ) ;
}
edgeandweight = edgeandweight + dx ;
incr ( k ) ;
} while ( ! ( k > delta ) ) ;
goto lab30 ;
lab63: edgeandweight = 8 * ( n0 + mem [curedges + 3 ].hhfield .lhfield ) +
4 + curwt ;
n0 = - (integer) m0 - 1 ;
k = 0 ;
n = mem [curedges + 5 ].hhfield .lhfield - 4096 ;
p = mem [curedges + 5 ].hhfield .v.RH ;
if ( n != n0 )
if ( n < n0 )
do {
incr ( n ) ;
p = mem [p ].hhfield .v.RH ;
} while ( ! ( n == n0 ) ) ;
else do {
decr ( n ) ;
p = mem [p ].hhfield .lhfield ;
} while ( ! ( n == n0 ) ) ;
do {
j = move [k ];
while ( j > 0 ) {
{
r = avail ;
if ( r == 0 )
r = getavail () ;
else {
avail = mem [r ].hhfield .v.RH ;
mem [r ].hhfield .v.RH = 0 ;
;
#ifdef STAT
incr ( dynused ) ;
#endif /* STAT */
}
}
mem [r ].hhfield .v.RH = mem [p + 1 ].hhfield .lhfield ;
mem [r ].hhfield .lhfield = edgeandweight ;
if ( internal [10 ]> 0 )
tracenewedge ( r , n ) ;
mem [p + 1 ].hhfield .lhfield = r ;
p = mem [p ].hhfield .lhfield ;
decr ( j ) ;
decr ( n ) ;
}
edgeandweight = edgeandweight + dx ;
incr ( k ) ;
} while ( ! ( k > delta ) ) ;
goto lab30 ;
lab30: mem [curedges + 5 ].hhfield .lhfield = n + 4096 ;
mem [curedges + 5 ].hhfield .v.RH = p ;
}
void
#ifdef HAVE_PROTOTYPES
zskew ( scaled x , scaled y , smallnumber octant )
#else
zskew ( x , y , octant )
scaled x ;
scaled y ;
smallnumber octant ;
#endif
{
switch ( octant )
{case 1 :
{
curx = x - y ;
cury = y ;
}
break ;
case 5 :
{
curx = y - x ;
cury = x ;
}
break ;
case 6 :
{
curx = y + x ;
cury = - (integer) x ;
}
break ;
case 2 :
{
curx = - (integer) x - y ;
cury = y ;
}
break ;
case 4 :
{
curx = - (integer) x + y ;
cury = - (integer) y ;
}
break ;
case 8 :
{
curx = - (integer) y + x ;
cury = - (integer) x ;
}
break ;
case 7 :
{
curx = - (integer) y - x ;
cury = x ;
}
break ;
case 3 :
{
curx = x + y ;
cury = - (integer) y ;
}
break ;
}
}
void
#ifdef HAVE_PROTOTYPES
zabnegate ( scaled x , scaled y , smallnumber octantbefore , smallnumber
octantafter )
#else
zabnegate ( x , y , octantbefore , octantafter )
scaled x ;
scaled y ;
smallnumber octantbefore ;
smallnumber octantafter ;
#endif
{
if ( odd ( octantbefore ) == odd ( octantafter ) )
curx = x ;
else curx = - (integer) x ;
if ( ( octantbefore > 2 ) == ( octantafter > 2 ) )
cury = y ;
else cury = - (integer) y ;
}
fraction
#ifdef HAVE_PROTOTYPES
zcrossingpoint ( integer a , integer b , integer c )
#else
zcrossingpoint ( a , b , c )
integer a ;
integer b ;
integer c ;
#endif
{
/* 10 */ register fraction Result; integer d ;
integer x, xx, x0, x1, x2 ;
if ( a < 0 )
{
Result = 0 ;
goto lab10 ;
}
if ( c >= 0 )
{
if ( b >= 0 )
if ( c > 0 )
{
Result = 268435457L ;
goto lab10 ;
}
else if ( ( a == 0 ) && ( b == 0 ) )
{
Result = 268435457L ;
goto lab10 ;
}
else {
Result = 268435456L ;
goto lab10 ;
}
if ( a == 0 )
{
Result = 0 ;
goto lab10 ;
}
}
else if ( a == 0 )
if ( b <= 0 )
{
Result = 0 ;
goto lab10 ;
}
d = 1 ;
x0 = a ;
x1 = a - b ;
x2 = b - c ;
do {
x = half ( x1 + x2 ) ;
if ( x1 - x0 > x0 )
{
x2 = x ;
x0 = x0 + x0 ;
d = d + d ;
}
else {
xx = x1 + x - x0 ;
if ( xx > x0 )
{
x2 = x ;
x0 = x0 + x0 ;
d = d + d ;
}
else {
x0 = x0 - xx ;
if ( x <= x0 )
if ( x + x2 <= x0 )
{
Result = 268435457L ;
goto lab10 ;
}
x1 = x ;
d = d + d + 1 ;
}
}
} while ( ! ( d >= 268435456L ) ) ;
Result = d - 268435456L ;
lab10: ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zprintspec ( strnumber s )
#else
zprintspec ( s )
strnumber s ;
#endif
{
/* 45 30 */ halfword p, q ;
smallnumber octant ;
printdiagnostic ( 543 , s , true ) ;
p = curspec ;
octant = mem [p + 3 ].cint ;
println () ;
unskew ( mem [curspec + 1 ].cint , mem [curspec + 2 ].cint , octant ) ;
printtwo ( curx , cury ) ;
print ( 544 ) ;
while ( true ) {
print ( octantdir [octant ]) ;
printchar ( 39 ) ;
while ( true ) {
q = mem [p ].hhfield .v.RH ;
if ( mem [p ].hhfield .b1 == 0 )
goto lab45 ;
{
printnl ( 555 ) ;
unskew ( mem [p + 5 ].cint , mem [p + 6 ].cint , octant ) ;
printtwo ( curx , cury ) ;
print ( 522 ) ;
unskew ( mem [q + 3 ].cint , mem [q + 4 ].cint , octant ) ;
printtwo ( curx , cury ) ;
printnl ( 519 ) ;
unskew ( mem [q + 1 ].cint , mem [q + 2 ].cint , octant ) ;
printtwo ( curx , cury ) ;
print ( 556 ) ;
printint ( mem [q ].hhfield .b0 - 1 ) ;
}
p = q ;
}
lab45: if ( q == curspec )
goto lab30 ;
p = q ;
octant = mem [p + 3 ].cint ;
printnl ( 545 ) ;
}
lab30: printnl ( 546 ) ;
enddiagnostic ( true ) ;
}
void
#ifdef HAVE_PROTOTYPES
zprintstrange ( strnumber s )
#else
zprintstrange ( s )
strnumber s ;
#endif
{
halfword p ;
halfword f ;
halfword q ;
integer t ;
if ( interaction == 3 )
;
printnl ( 62 ) ;
p = curspec ;
t = 256 ;
do {
p = mem [p ].hhfield .v.RH ;
if ( mem [p ].hhfield .b0 != 0 )
{
if ( mem [p ].hhfield .b0 < t )
f = p ;
t = mem [p ].hhfield .b0 ;
}
} while ( ! ( p == curspec ) ) ;
p = curspec ;
q = p ;
do {
p = mem [p ].hhfield .v.RH ;
if ( mem [p ].hhfield .b0 == 0 )
q = p ;
} while ( ! ( p == f ) ) ;
t = 0 ;
do {
if ( mem [p ].hhfield .b0 != 0 )
{
if ( mem [p ].hhfield .b0 != t )
{
t = mem [p ].hhfield .b0 ;
printchar ( 32 ) ;
printint ( t - 1 ) ;
}
if ( q != 0 )
{
if ( mem [mem [q ].hhfield .v.RH ].hhfield .b0 == 0 )
{
print ( 557 ) ;
print ( octantdir [mem [q + 3 ].cint ]) ;
q = mem [q ].hhfield .v.RH ;
while ( mem [mem [q ].hhfield .v.RH ].hhfield .b0 == 0 ) {
printchar ( 32 ) ;
print ( octantdir [mem [q + 3 ].cint ]) ;
q = mem [q ].hhfield .v.RH ;
}
printchar ( 41 ) ;
}
printchar ( 32 ) ;
print ( octantdir [mem [q + 3 ].cint ]) ;
q = 0 ;
}
}
else if ( q == 0 )
q = p ;
p = mem [p ].hhfield .v.RH ;
} while ( ! ( p == f ) ) ;
printchar ( 32 ) ;
printint ( mem [p ].hhfield .b0 - 1 ) ;
if ( q != 0 )
if ( mem [mem [q ].hhfield .v.RH ].hhfield .b0 == 0 )
{
print ( 557 ) ;
print ( octantdir [mem [q + 3 ].cint ]) ;
q = mem [q ].hhfield .v.RH ;
while ( mem [mem [q ].hhfield .v.RH ].hhfield .b0 == 0 ) {
printchar ( 32 ) ;
print ( octantdir [mem [q + 3 ].cint ]) ;
q = mem [q ].hhfield .v.RH ;
}
printchar ( 41 ) ;
}
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( s ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zremovecubic ( halfword p )
#else
zremovecubic ( p )
halfword p ;
#endif
{
halfword q ;
q = mem [p ].hhfield .v.RH ;
mem [p ].hhfield .b1 = mem [q ].hhfield .b1 ;
mem [p ].hhfield .v.RH = mem [q ].hhfield .v.RH ;
mem [p + 1 ].cint = mem [q + 1 ].cint ;
mem [p + 2 ].cint = mem [q + 2 ].cint ;
mem [p + 5 ].cint = mem [q + 5 ].cint ;
mem [p + 6 ].cint = mem [q + 6 ].cint ;
freenode ( q , 7 ) ;
}
void
#ifdef HAVE_PROTOTYPES
zsplitcubic ( halfword p , fraction t , scaled xq , scaled yq )
#else
zsplitcubic ( p , t , xq , yq )
halfword p ;
fraction t ;
scaled xq ;
scaled yq ;
#endif
{
scaled v ;
halfword q, r ;
q = mem [p ].hhfield .v.RH ;
r = getnode ( 7 ) ;
mem [p ].hhfield .v.RH = r ;
mem [r ].hhfield .v.RH = q ;
mem [r ].hhfield .b0 = mem [q ].hhfield .b0 ;
mem [r ].hhfield .b1 = mem [p ].hhfield .b1 ;
v = mem [p + 5 ].cint - takefraction ( mem [p + 5 ].cint - mem [q + 3 ]
.cint , t ) ;
mem [p + 5 ].cint = mem [p + 1 ].cint - takefraction ( mem [p + 1 ]
.cint - mem [p + 5 ].cint , t ) ;
mem [q + 3 ].cint = mem [q + 3 ].cint - takefraction ( mem [q + 3 ]
.cint - xq , t ) ;
mem [r + 3 ].cint = mem [p + 5 ].cint - takefraction ( mem [p + 5 ]
.cint - v , t ) ;
mem [r + 5 ].cint = v - takefraction ( v - mem [q + 3 ].cint , t ) ;
mem [r + 1 ].cint = mem [r + 3 ].cint - takefraction ( mem [r + 3 ]
.cint - mem [r + 5 ].cint , t ) ;
v = mem [p + 6 ].cint - takefraction ( mem [p + 6 ].cint - mem [q + 4 ]
.cint , t ) ;
mem [p + 6 ].cint = mem [p + 2 ].cint - takefraction ( mem [p + 2 ]
.cint - mem [p + 6 ].cint , t ) ;
mem [q + 4 ].cint = mem [q + 4 ].cint - takefraction ( mem [q + 4 ]
.cint - yq , t ) ;
mem [r + 4 ].cint = mem [p + 6 ].cint - takefraction ( mem [p + 6 ]
.cint - v , t ) ;
mem [r + 6 ].cint = v - takefraction ( v - mem [q + 4 ].cint , t ) ;
mem [r + 2 ].cint = mem [r + 4 ].cint - takefraction ( mem [r + 4 ]
.cint - mem [r + 6 ].cint , t ) ;
}
void
#ifdef HAVE_PROTOTYPES
quadrantsubdivide ( void )
#else
quadrantsubdivide ( )
#endif
{
/* 22 10 */ halfword p, q, r, s, pp, qq ;
scaled firstx, firsty ;
scaled del1, del2, del3, del, dmax ;
fraction t ;
scaled destx, desty ;
boolean constantx ;
p = curspec ;
firstx = mem [curspec + 1 ].cint ;
firsty = mem [curspec + 2 ].cint ;
do {
lab22: q = mem [p ].hhfield .v.RH ;
if ( q == curspec )
{
destx = firstx ;
desty = firsty ;
}
else {
destx = mem [q + 1 ].cint ;
desty = mem [q + 2 ].cint ;
}
del1 = mem [p + 5 ].cint - mem [p + 1 ].cint ;
del2 = mem [q + 3 ].cint - mem [p + 5 ].cint ;
del3 = destx - mem [q + 3 ].cint ;
if ( del1 != 0 )
del = del1 ;
else if ( del2 != 0 )
del = del2 ;
else del = del3 ;
if ( del != 0 )
{
dmax = abs ( del1 ) ;
if ( abs ( del2 ) > dmax )
dmax = abs ( del2 ) ;
if ( abs ( del3 ) > dmax )
dmax = abs ( del3 ) ;
while ( dmax < 134217728L ) {
dmax = dmax + dmax ;
del1 = del1 + del1 ;
del2 = del2 + del2 ;
del3 = del3 + del3 ;
}
}
if ( del == 0 )
constantx = true ;
else {
constantx = false ;
if ( del < 0 )
{
mem [p + 1 ].cint = - (integer) mem [p + 1 ].cint ;
mem [p + 5 ].cint = - (integer) mem [p + 5 ].cint ;
mem [q + 3 ].cint = - (integer) mem [q + 3 ].cint ;
del1 = - (integer) del1 ;
del2 = - (integer) del2 ;
del3 = - (integer) del3 ;
destx = - (integer) destx ;
mem [p ].hhfield .b1 = 2 ;
}
t = crossingpoint ( del1 , del2 , del3 ) ;
if ( t < 268435456L )
{
splitcubic ( p , t , destx , desty ) ;
r = mem [p ].hhfield .v.RH ;
if ( mem [r ].hhfield .b1 > 1 )
mem [r ].hhfield .b1 = 1 ;
else mem [r ].hhfield .b1 = 2 ;
if ( mem [r + 1 ].cint < mem [p + 1 ].cint )
mem [r + 1 ].cint = mem [p + 1 ].cint ;
mem [r + 3 ].cint = mem [r + 1 ].cint ;
if ( mem [p + 5 ].cint > mem [r + 1 ].cint )
mem [p + 5 ].cint = mem [r + 1 ].cint ;
mem [r + 1 ].cint = - (integer) mem [r + 1 ].cint ;
mem [r + 5 ].cint = mem [r + 1 ].cint ;
mem [q + 3 ].cint = - (integer) mem [q + 3 ].cint ;
destx = - (integer) destx ;
del2 = del2 - takefraction ( del2 - del3 , t ) ;
if ( del2 > 0 )
del2 = 0 ;
t = crossingpoint ( 0 , - (integer) del2 , - (integer) del3 ) ;
if ( t < 268435456L )
{
splitcubic ( r , t , destx , desty ) ;
s = mem [r ].hhfield .v.RH ;
if ( mem [s + 1 ].cint < destx )
mem [s + 1 ].cint = destx ;
if ( mem [s + 1 ].cint < mem [r + 1 ].cint )
mem [s + 1 ].cint = mem [r + 1 ].cint ;
mem [s ].hhfield .b1 = mem [p ].hhfield .b1 ;
mem [s + 3 ].cint = mem [s + 1 ].cint ;
if ( mem [q + 3 ].cint < destx )
mem [q + 3 ].cint = - (integer) destx ;
else if ( mem [q + 3 ].cint > mem [s + 1 ].cint )
mem [q + 3 ].cint = - (integer) mem [s + 1 ].cint ;
else mem [q + 3 ].cint = - (integer) mem [q + 3 ].cint ;
mem [s + 1 ].cint = - (integer) mem [s + 1 ].cint ;
mem [s + 5 ].cint = mem [s + 1 ].cint ;
}
else {
if ( mem [r + 1 ].cint > destx )
{
mem [r + 1 ].cint = destx ;
mem [r + 3 ].cint = - (integer) mem [r + 1 ].cint ;
mem [r + 5 ].cint = mem [r + 1 ].cint ;
}
if ( mem [q + 3 ].cint > destx )
mem [q + 3 ].cint = destx ;
else if ( mem [q + 3 ].cint < mem [r + 1 ].cint )
mem [q + 3 ].cint = mem [r + 1 ].cint ;
}
}
}
pp = p ;
do {
qq = mem [pp ].hhfield .v.RH ;
abnegate ( mem [qq + 1 ].cint , mem [qq + 2 ].cint , mem [qq ]
.hhfield .b1 , mem [pp ].hhfield .b1 ) ;
destx = curx ;
desty = cury ;
del1 = mem [pp + 6 ].cint - mem [pp + 2 ].cint ;
del2 = mem [qq + 4 ].cint - mem [pp + 6 ].cint ;
del3 = desty - mem [qq + 4 ].cint ;
if ( del1 != 0 )
del = del1 ;
else if ( del2 != 0 )
del = del2 ;
else del = del3 ;
if ( del != 0 )
{
dmax = abs ( del1 ) ;
if ( abs ( del2 ) > dmax )
dmax = abs ( del2 ) ;
if ( abs ( del3 ) > dmax )
dmax = abs ( del3 ) ;
while ( dmax < 134217728L ) {
dmax = dmax + dmax ;
del1 = del1 + del1 ;
del2 = del2 + del2 ;
del3 = del3 + del3 ;
}
}
if ( del != 0 )
{
if ( del < 0 )
{
mem [pp + 2 ].cint = - (integer) mem [pp + 2 ].cint ;
mem [pp + 6 ].cint = - (integer) mem [pp + 6 ].cint ;
mem [qq + 4 ].cint = - (integer) mem [qq + 4 ].cint ;
del1 = - (integer) del1 ;
del2 = - (integer) del2 ;
del3 = - (integer) del3 ;
desty = - (integer) desty ;
mem [pp ].hhfield .b1 = mem [pp ].hhfield .b1 + 2 ;
}
t = crossingpoint ( del1 , del2 , del3 ) ;
if ( t < 268435456L )
{
splitcubic ( pp , t , destx , desty ) ;
r = mem [pp ].hhfield .v.RH ;
if ( mem [r ].hhfield .b1 > 2 )
mem [r ].hhfield .b1 = mem [r ].hhfield .b1 - 2 ;
else mem [r ].hhfield .b1 = mem [r ].hhfield .b1 + 2 ;
if ( mem [r + 2 ].cint < mem [pp + 2 ].cint )
mem [r + 2 ].cint = mem [pp + 2 ].cint ;
mem [r + 4 ].cint = mem [r + 2 ].cint ;
if ( mem [pp + 6 ].cint > mem [r + 2 ].cint )
mem [pp + 6 ].cint = mem [r + 2 ].cint ;
mem [r + 2 ].cint = - (integer) mem [r + 2 ].cint ;
mem [r + 6 ].cint = mem [r + 2 ].cint ;
mem [qq + 4 ].cint = - (integer) mem [qq + 4 ].cint ;
desty = - (integer) desty ;
if ( mem [r + 1 ].cint < mem [pp + 1 ].cint )
mem [r + 1 ].cint = mem [pp + 1 ].cint ;
else if ( mem [r + 1 ].cint > destx )
mem [r + 1 ].cint = destx ;
if ( mem [r + 3 ].cint > mem [r + 1 ].cint )
{
mem [r + 3 ].cint = mem [r + 1 ].cint ;
if ( mem [pp + 5 ].cint > mem [r + 1 ].cint )
mem [pp + 5 ].cint = mem [r + 1 ].cint ;
}
if ( mem [r + 5 ].cint < mem [r + 1 ].cint )
{
mem [r + 5 ].cint = mem [r + 1 ].cint ;
if ( mem [qq + 3 ].cint < mem [r + 1 ].cint )
mem [qq + 3 ].cint = mem [r + 1 ].cint ;
}
del2 = del2 - takefraction ( del2 - del3 , t ) ;
if ( del2 > 0 )
del2 = 0 ;
t = crossingpoint ( 0 , - (integer) del2 , - (integer) del3 ) ;
if ( t < 268435456L )
{
splitcubic ( r , t , destx , desty ) ;
s = mem [r ].hhfield .v.RH ;
if ( mem [s + 2 ].cint < desty )
mem [s + 2 ].cint = desty ;
if ( mem [s + 2 ].cint < mem [r + 2 ].cint )
mem [s + 2 ].cint = mem [r + 2 ].cint ;
mem [s ].hhfield .b1 = mem [pp ].hhfield .b1 ;
mem [s + 4 ].cint = mem [s + 2 ].cint ;
if ( mem [qq + 4 ].cint < desty )
mem [qq + 4 ].cint = - (integer) desty ;
else if ( mem [qq + 4 ].cint > mem [s + 2 ].cint )
mem [qq + 4 ].cint = - (integer) mem [s + 2 ].cint ;
else mem [qq + 4 ].cint = - (integer) mem [qq + 4 ].cint ;
mem [s + 2 ].cint = - (integer) mem [s + 2 ].cint ;
mem [s + 6 ].cint = mem [s + 2 ].cint ;
if ( mem [s + 1 ].cint < mem [r + 1 ].cint )
mem [s + 1 ].cint = mem [r + 1 ].cint ;
else if ( mem [s + 1 ].cint > destx )
mem [s + 1 ].cint = destx ;
if ( mem [s + 3 ].cint > mem [s + 1 ].cint )
{
mem [s + 3 ].cint = mem [s + 1 ].cint ;
if ( mem [r + 5 ].cint > mem [s + 1 ].cint )
mem [r + 5 ].cint = mem [s + 1 ].cint ;
}
if ( mem [s + 5 ].cint < mem [s + 1 ].cint )
{
mem [s + 5 ].cint = mem [s + 1 ].cint ;
if ( mem [qq + 3 ].cint < mem [s + 1 ].cint )
mem [qq + 3 ].cint = mem [s + 1 ].cint ;
}
}
else {
if ( mem [r + 2 ].cint > desty )
{
mem [r + 2 ].cint = desty ;
mem [r + 4 ].cint = - (integer) mem [r + 2 ].cint ;
mem [r + 6 ].cint = mem [r + 2 ].cint ;
}
if ( mem [qq + 4 ].cint > desty )
mem [qq + 4 ].cint = desty ;
else if ( mem [qq + 4 ].cint < mem [r + 2 ].cint )
mem [qq + 4 ].cint = mem [r + 2 ].cint ;
}
}
}
else if ( constantx )
{
if ( q != p )
{
removecubic ( p ) ;
if ( curspec != q )
goto lab22 ;
else {
curspec = p ;
goto lab10 ;
}
}
}
else if ( ! odd ( mem [pp ].hhfield .b1 ) )
{
mem [pp + 2 ].cint = - (integer) mem [pp + 2 ].cint ;
mem [pp + 6 ].cint = - (integer) mem [pp + 6 ].cint ;
mem [qq + 4 ].cint = - (integer) mem [qq + 4 ].cint ;
del1 = - (integer) del1 ;
del2 = - (integer) del2 ;
del3 = - (integer) del3 ;
desty = - (integer) desty ;
mem [pp ].hhfield .b1 = mem [pp ].hhfield .b1 + 2 ;
}
pp = qq ;
} while ( ! ( pp == q ) ) ;
if ( constantx )
{
pp = p ;
do {
qq = mem [pp ].hhfield .v.RH ;
if ( mem [pp ].hhfield .b1 > 2 )
{
mem [pp ].hhfield .b1 = mem [pp ].hhfield .b1 + 1 ;
mem [pp + 1 ].cint = - (integer) mem [pp + 1 ].cint ;
mem [pp + 5 ].cint = - (integer) mem [pp + 5 ].cint ;
mem [qq + 3 ].cint = - (integer) mem [qq + 3 ].cint ;
}
pp = qq ;
} while ( ! ( pp == q ) ) ;
}
p = q ;
} while ( ! ( p == curspec ) ) ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
octantsubdivide ( void )
#else
octantsubdivide ( )
#endif
{
halfword p, q, r, s ;
scaled del1, del2, del3, del, dmax ;
fraction t ;
scaled destx, desty ;
p = curspec ;
do {
q = mem [p ].hhfield .v.RH ;
mem [p + 1 ].cint = mem [p + 1 ].cint - mem [p + 2 ].cint ;
mem [p + 5 ].cint = mem [p + 5 ].cint - mem [p + 6 ].cint ;
mem [q + 3 ].cint = mem [q + 3 ].cint - mem [q + 4 ].cint ;
if ( q == curspec )
{
unskew ( mem [q + 1 ].cint , mem [q + 2 ].cint , mem [q ].hhfield
.b1 ) ;
skew ( curx , cury , mem [p ].hhfield .b1 ) ;
destx = curx ;
desty = cury ;
}
else {
abnegate ( mem [q + 1 ].cint , mem [q + 2 ].cint , mem [q ]
.hhfield .b1 , mem [p ].hhfield .b1 ) ;
destx = curx - cury ;
desty = cury ;
}
del1 = mem [p + 5 ].cint - mem [p + 1 ].cint ;
del2 = mem [q + 3 ].cint - mem [p + 5 ].cint ;
del3 = destx - mem [q + 3 ].cint ;
if ( del1 != 0 )
del = del1 ;
else if ( del2 != 0 )
del = del2 ;
else del = del3 ;
if ( del != 0 )
{
dmax = abs ( del1 ) ;
if ( abs ( del2 ) > dmax )
dmax = abs ( del2 ) ;
if ( abs ( del3 ) > dmax )
dmax = abs ( del3 ) ;
while ( dmax < 134217728L ) {
dmax = dmax + dmax ;
del1 = del1 + del1 ;
del2 = del2 + del2 ;
del3 = del3 + del3 ;
}
}
if ( del != 0 )
{
if ( del < 0 )
{
mem [p + 2 ].cint = mem [p + 1 ].cint + mem [p + 2 ].cint ;
mem [p + 1 ].cint = - (integer) mem [p + 1 ].cint ;
mem [p + 6 ].cint = mem [p + 5 ].cint + mem [p + 6 ].cint ;
mem [p + 5 ].cint = - (integer) mem [p + 5 ].cint ;
mem [q + 4 ].cint = mem [q + 3 ].cint + mem [q + 4 ].cint ;
mem [q + 3 ].cint = - (integer) mem [q + 3 ].cint ;
del1 = - (integer) del1 ;
del2 = - (integer) del2 ;
del3 = - (integer) del3 ;
desty = destx + desty ;
destx = - (integer) destx ;
mem [p ].hhfield .b1 = mem [p ].hhfield .b1 + 4 ;
}
t = crossingpoint ( del1 , del2 , del3 ) ;
if ( t < 268435456L )
{
splitcubic ( p , t , destx , desty ) ;
r = mem [p ].hhfield .v.RH ;
if ( mem [r ].hhfield .b1 > 4 )
mem [r ].hhfield .b1 = mem [r ].hhfield .b1 - 4 ;
else mem [r ].hhfield .b1 = mem [r ].hhfield .b1 + 4 ;
if ( mem [r + 2 ].cint < mem [p + 2 ].cint )
mem [r + 2 ].cint = mem [p + 2 ].cint ;
else if ( mem [r + 2 ].cint > desty )
mem [r + 2 ].cint = desty ;
if ( mem [p + 1 ].cint + mem [r + 2 ].cint > destx + desty )
mem [r + 2 ].cint = destx + desty - mem [p + 1 ].cint ;
if ( mem [r + 4 ].cint > mem [r + 2 ].cint )
{
mem [r + 4 ].cint = mem [r + 2 ].cint ;
if ( mem [p + 6 ].cint > mem [r + 2 ].cint )
mem [p + 6 ].cint = mem [r + 2 ].cint ;
}
if ( mem [r + 6 ].cint < mem [r + 2 ].cint )
{
mem [r + 6 ].cint = mem [r + 2 ].cint ;
if ( mem [q + 4 ].cint < mem [r + 2 ].cint )
mem [q + 4 ].cint = mem [r + 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 [r + 2 ].cint > destx + desty )
mem [r + 1 ].cint = destx + desty - mem [r + 2 ].cint ;
mem [r + 3 ].cint = mem [r + 1 ].cint ;
if ( mem [p + 5 ].cint > mem [r + 1 ].cint )
mem [p + 5 ].cint = mem [r + 1 ].cint ;
mem [r + 2 ].cint = mem [r + 2 ].cint + mem [r + 1 ].cint ;
mem [r + 6 ].cint = mem [r + 6 ].cint + mem [r + 1 ].cint ;
mem [r + 1 ].cint = - (integer) mem [r + 1 ].cint ;
mem [r + 5 ].cint = mem [r + 1 ].cint ;
mem [q + 4 ].cint = mem [q + 4 ].cint + mem [q + 3 ].cint ;
mem [q + 3 ].cint = - (integer) mem [q + 3 ].cint ;
desty = desty + destx ;
destx = - (integer) destx ;
if ( mem [r + 6 ].cint < mem [r + 2 ].cint )
{
mem [r + 6 ].cint = mem [r + 2 ].cint ;
if ( mem [q + 4 ].cint < mem [r + 2 ].cint )
mem [q + 4 ].cint = mem [r + 2 ].cint ;
}
del2 = del2 - takefraction ( del2 - del3 , t ) ;
if ( del2 > 0 )
del2 = 0 ;
t = crossingpoint ( 0 , - (integer) del2 , - (integer) del3 ) ;
if ( t < 268435456L )
{
splitcubic ( r , t , destx , desty ) ;
s = mem [r ].hhfield .v.RH ;
if ( mem [s + 2 ].cint < mem [r + 2 ].cint )
mem [s + 2 ].cint = mem [r + 2 ].cint ;
else if ( mem [s + 2 ].cint > desty )
mem [s + 2 ].cint = desty ;
if ( mem [r + 1 ].cint + mem [s + 2 ].cint > destx + desty )
mem [s + 2 ].cint = destx + desty - mem [r + 1 ].cint ;
if ( mem [s + 4 ].cint > mem [s + 2 ].cint )
{
mem [s + 4 ].cint = mem [s + 2 ].cint ;
if ( mem [r + 6 ].cint > mem [s + 2 ].cint )
mem [r + 6 ].cint = mem [s + 2 ].cint ;
}
if ( mem [s + 6 ].cint < mem [s + 2 ].cint )
{
mem [s + 6 ].cint = mem [s + 2 ].cint ;
if ( mem [q + 4 ].cint < mem [s + 2 ].cint )
mem [q + 4 ].cint = mem [s + 2 ].cint ;
}
if ( mem [s + 1 ].cint + mem [s + 2 ].cint > destx + desty )
mem [s + 1 ].cint = destx + desty - mem [s + 2 ].cint ;
else {
if ( mem [s + 1 ].cint < destx )
mem [s + 1 ].cint = destx ;
if ( mem [s + 1 ].cint < mem [r + 1 ].cint )
mem [s + 1 ].cint = mem [r + 1 ].cint ;
}
mem [s ].hhfield .b1 = mem [p ].hhfield .b1 ;
mem [s + 3 ].cint = mem [s + 1 ].cint ;
if ( mem [q + 3 ].cint < destx )
{
mem [q + 4 ].cint = mem [q + 4 ].cint + destx ;
mem [q + 3 ].cint = - (integer) destx ;
}
else if ( mem [q + 3 ].cint > mem [s + 1 ].cint )
{
mem [q + 4 ].cint = mem [q + 4 ].cint + mem [s + 1 ].cint ;
mem [q + 3 ].cint = - (integer) mem [s + 1 ].cint ;
}
else {
mem [q + 4 ].cint = mem [q + 4 ].cint + mem [q + 3 ].cint ;
mem [q + 3 ].cint = - (integer) mem [q + 3 ].cint ;
}
mem [s + 2 ].cint = mem [s + 2 ].cint + mem [s + 1 ].cint ;
mem [s + 6 ].cint = mem [s + 6 ].cint + mem [s + 1 ].cint ;
mem [s + 1 ].cint = - (integer) mem [s + 1 ].cint ;
mem [s + 5 ].cint = mem [s + 1 ].cint ;
if ( mem [s + 6 ].cint < mem [s + 2 ].cint )
{
mem [s + 6 ].cint = mem [s + 2 ].cint ;
if ( mem [q + 4 ].cint < mem [s + 2 ].cint )
mem [q + 4 ].cint = mem [s + 2 ].cint ;
}
}
else {
if ( mem [r + 1 ].cint > destx )
{
mem [r + 1 ].cint = destx ;
mem [r + 3 ].cint = - (integer) mem [r + 1 ].cint ;
mem [r + 5 ].cint = mem [r + 1 ].cint ;
}
if ( mem [q + 3 ].cint > destx )
mem [q + 3 ].cint = destx ;
else if ( mem [q + 3 ].cint < mem [r + 1 ].cint )
mem [q + 3 ].cint = mem [r + 1 ].cint ;
}
}
}
p = q ;
} while ( ! ( p == curspec ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
makesafe ( void )
#else
makesafe ( )
#endif
{
integer k ;
boolean allsafe ;
scaled nexta ;
scaled deltaa, deltab ;
before [curroundingptr ]= before [0 ];
nodetoround [curroundingptr ]= nodetoround [0 ];
do {
after [curroundingptr ]= after [0 ];
allsafe = true ;
nexta = after [0 ];
{register integer for_end; k = 0 ;for_end = curroundingptr - 1 ; if ( k
<= for_end) do
{
deltab = before [k + 1 ]- before [k ];
if ( deltab >= 0 )
deltaa = after [k + 1 ]- nexta ;
else deltaa = nexta - after [k + 1 ];
nexta = after [k + 1 ];
if ( ( deltaa < 0 ) || ( deltaa > abs ( deltab + deltab ) ) )
{
allsafe = false ;
after [k ]= before [k ];
if ( k == curroundingptr - 1 )
after [0 ]= before [0 ];
else after [k + 1 ]= before [k + 1 ];
}
}
while ( k++ < for_end ) ;}
} while ( ! ( allsafe ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
zbeforeandafter ( scaled b , scaled a , halfword p )
#else
zbeforeandafter ( b , a , p )
scaled b ;
scaled a ;
halfword p ;
#endif
{
if ( curroundingptr == maxroundingptr )
if ( maxroundingptr < maxwiggle )
incr ( maxroundingptr ) ;
else overflow ( 567 , maxwiggle ) ;
after [curroundingptr ]= a ;
before [curroundingptr ]= b ;
nodetoround [curroundingptr ]= p ;
incr ( curroundingptr ) ;
}
scaled
#ifdef HAVE_PROTOTYPES
zgoodval ( scaled b , scaled o )
#else
zgoodval ( b , o )
scaled b ;
scaled o ;
#endif
{
register scaled Result; scaled a ;
a = b + o ;
if ( a >= 0 )
a = a - ( a % curgran ) - o ;
else a = a + ( ( - (integer) ( a + 1 ) ) % curgran ) - curgran + 1 - o ;
if ( b - a < a + curgran - b )
Result = a ;
else Result = a + curgran ;
return Result ;
}
scaled
#ifdef HAVE_PROTOTYPES
zcompromise ( scaled u , scaled v )
#else
zcompromise ( u , v )
scaled u ;
scaled v ;
#endif
{
register scaled Result; Result = half ( goodval ( u + u , - (integer) u -
v ) ) ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
xyround ( void )
#else
xyround ( )
#endif
{
halfword p, q ;
scaled b, a ;
scaled penedge ;
fraction alpha ;
curgran = abs ( internal [37 ]) ;
if ( curgran == 0 )
curgran = 65536L ;
p = curspec ;
curroundingptr = 0 ;
do {
q = mem [p ].hhfield .v.RH ;
if ( odd ( mem [p ].hhfield .b1 ) != odd ( mem [q ].hhfield .b1 ) )
{
if ( odd ( mem [q ].hhfield .b1 ) )
b = mem [q + 1 ].cint ;
else b = - (integer) mem [q + 1 ].cint ;
if ( ( abs ( mem [q + 1 ].cint - mem [q + 5 ].cint ) < 655 ) || (
abs ( mem [q + 1 ].cint + mem [q + 3 ].cint ) < 655 ) )
{
if ( curpen == 3 )
penedge = 0 ;
else if ( curpathtype == 0 )
penedge = compromise ( mem [mem [curpen + 5 ].hhfield .v.RH + 2 ]
.cint , mem [mem [curpen + 7 ].hhfield .v.RH + 2 ].cint ) ;
else if ( odd ( mem [q ].hhfield .b1 ) )
penedge = mem [mem [curpen + 7 ].hhfield .v.RH + 2 ].cint ;
else penedge = mem [mem [curpen + 5 ].hhfield .v.RH + 2 ].cint ;
a = goodval ( b , penedge ) ;
}
else a = b ;
if ( abs ( a ) > maxallowed )
if ( a > 0 )
a = maxallowed ;
else a = - (integer) maxallowed ;
beforeandafter ( b , a , q ) ;
}
p = q ;
} while ( ! ( p == curspec ) ) ;
if ( curroundingptr > 0 )
{
makesafe () ;
do {
decr ( curroundingptr ) ;
if ( ( after [curroundingptr ]!= before [curroundingptr ]) || (
after [curroundingptr + 1 ]!= before [curroundingptr + 1 ]) )
{
p = nodetoround [curroundingptr ];
if ( odd ( mem [p ].hhfield .b1 ) )
{
b = before [curroundingptr ];
a = after [curroundingptr ];
}
else {
b = - (integer) before [curroundingptr ];
a = - (integer) after [curroundingptr ];
}
if ( before [curroundingptr ]== before [curroundingptr + 1 ])
alpha = 268435456L ;
else alpha = makefraction ( after [curroundingptr + 1 ]- after [
curroundingptr ], before [curroundingptr + 1 ]- before [
curroundingptr ]) ;
do {
mem [p + 1 ].cint = takefraction ( alpha , mem [p + 1 ].cint
- b ) + a ;
mem [p + 5 ].cint = takefraction ( alpha , mem [p + 5 ].cint - b
) + a ;
p = mem [p ].hhfield .v.RH ;
mem [p + 3 ].cint = takefraction ( alpha , mem [p + 3 ].cint - b
) + a ;
} while ( ! ( p == nodetoround [curroundingptr + 1 ]) ) ;
}
} while ( ! ( curroundingptr == 0 ) ) ;
}
p = curspec ;
curroundingptr = 0 ;
do {
q = mem [p ].hhfield .v.RH ;
if ( ( mem [p ].hhfield .b1 > 2 ) != ( mem [q ].hhfield .b1 > 2 ) )
{
if ( mem [q ].hhfield .b1 <= 2 )
b = mem [q + 2 ].cint ;
else b = - (integer) mem [q + 2 ].cint ;
if ( ( abs ( mem [q + 2 ].cint - mem [q + 6 ].cint ) < 655 ) || (
abs ( mem [q + 2 ].cint + mem [q + 4 ].cint ) < 655 ) )
{
if ( curpen == 3 )
penedge = 0 ;
else if ( curpathtype == 0 )
penedge = compromise ( mem [mem [curpen + 2 ].hhfield .v.RH + 2 ]
.cint , mem [mem [curpen + 1 ].hhfield .v.RH + 2 ].cint ) ;
else if ( mem [q ].hhfield .b1 <= 2 )
penedge = mem [mem [curpen + 1 ].hhfield .v.RH + 2 ].cint ;
else penedge = mem [mem [curpen + 2 ].hhfield .v.RH + 2 ].cint ;
a = goodval ( b , penedge ) ;
}
else a = b ;
if ( abs ( a ) > maxallowed )
if ( a > 0 )
a = maxallowed ;
else a = - (integer) maxallowed ;
beforeandafter ( b , a , q ) ;
}
p = q ;
} while ( ! ( p == curspec ) ) ;
if ( curroundingptr > 0 )
{
makesafe () ;
do {
decr ( curroundingptr ) ;
if ( ( after [curroundingptr ]!= before [curroundingptr ]) || (
after [curroundingptr + 1 ]!= before [curroundingptr + 1 ]) )
{
p = nodetoround [curroundingptr ];
if ( mem [p ].hhfield .b1 <= 2 )
{
b = before [curroundingptr ];
a = after [curroundingptr ];
}
else {
b = - (integer) before [curroundingptr ];
a = - (integer) after [curroundingptr ];
}
if ( before [curroundingptr ]== before [curroundingptr + 1 ])
alpha = 268435456L ;
else alpha = makefraction ( after [curroundingptr + 1 ]- after [
curroundingptr ], before [curroundingptr + 1 ]- before [
curroundingptr ]) ;
do {
mem [p + 2 ].cint = takefraction ( alpha , mem [p + 2 ].cint
- b ) + a ;
mem [p + 6 ].cint = takefraction ( alpha , mem [p + 6 ].cint - b
) + a ;
p = mem [p ].hhfield .v.RH ;
mem [p + 4 ].cint = takefraction ( alpha , mem [p + 4 ].cint - b
) + a ;
} while ( ! ( p == nodetoround [curroundingptr + 1 ]) ) ;
}
} while ( ! ( curroundingptr == 0 ) ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
diaground ( void )
#else
diaground ( )
#endif
{
halfword p, q, pp ;
scaled b, a, bb, aa, d, c, dd, cc ;
scaled penedge ;
fraction alpha, beta ;
scaled nexta ;
boolean allsafe ;
integer k ;
scaled firstx, firsty ;
p = curspec ;
curroundingptr = 0 ;
do {
q = mem [p ].hhfield .v.RH ;
if ( mem [p ].hhfield .b1 != mem [q ].hhfield .b1 )
{
if ( mem [q ].hhfield .b1 > 4 )
b = - (integer) mem [q + 1 ].cint ;
else b = mem [q + 1 ].cint ;
if ( abs ( mem [q ].hhfield .b1 - mem [p ].hhfield .b1 ) == 4 )
if ( ( abs ( mem [q + 1 ].cint - mem [q + 5 ].cint ) < 655 ) || (
abs ( mem [q + 1 ].cint + mem [q + 3 ].cint ) < 655 ) )
{
if ( curpen == 3 )
penedge = 0 ;
else if ( curpathtype == 0 )
switch ( mem [q ].hhfield .b1 )
{case 1 :
case 5 :
penedge = compromise ( mem [mem [mem [curpen + 1 ].hhfield .v.RH
].hhfield .lhfield + 1 ].cint , - (integer) mem [mem [mem [
curpen + 4 ].hhfield .v.RH ].hhfield .lhfield + 1 ].cint ) ;
break ;
case 4 :
case 8 :
penedge = - (integer) compromise ( mem [mem [mem [curpen + 1 ]
.hhfield .v.RH ].hhfield .lhfield + 1 ].cint , - (integer) mem [
mem [mem [curpen + 4 ].hhfield .v.RH ].hhfield .lhfield + 1 ]
.cint ) ;
break ;
case 6 :
case 2 :
penedge = compromise ( mem [mem [mem [curpen + 2 ].hhfield .v.RH
].hhfield .lhfield + 1 ].cint , - (integer) mem [mem [mem [
curpen + 3 ].hhfield .v.RH ].hhfield .lhfield + 1 ].cint ) ;
break ;
case 7 :
case 3 :
penedge = - (integer) compromise ( mem [mem [mem [curpen + 2 ]
.hhfield .v.RH ].hhfield .lhfield + 1 ].cint , - (integer) mem [
mem [mem [curpen + 3 ].hhfield .v.RH ].hhfield .lhfield + 1 ]
.cint ) ;
break ;
}
else if ( mem [q ].hhfield .b1 <= 4 )
penedge = mem [mem [mem [curpen + mem [q ].hhfield .b1 ].hhfield
.v.RH ].hhfield .lhfield + 1 ].cint ;
else penedge = - (integer) mem [mem [mem [curpen + mem [q ]
.hhfield .b1 ].hhfield .v.RH ].hhfield .lhfield + 1 ].cint ;
if ( odd ( mem [q ].hhfield .b1 ) )
a = goodval ( b , penedge + halfp ( curgran ) ) ;
else a = goodval ( b - 1 , penedge + halfp ( curgran ) ) ;
}
else a = b ;
else a = b ;
beforeandafter ( b , a , q ) ;
}
p = q ;
} while ( ! ( p == curspec ) ) ;
if ( curroundingptr > 0 )
{
p = nodetoround [0 ];
firstx = mem [p + 1 ].cint ;
firsty = mem [p + 2 ].cint ;
before [curroundingptr ]= before [0 ];
nodetoround [curroundingptr ]= nodetoround [0 ];
do {
after [curroundingptr ]= after [0 ];
allsafe = true ;
nexta = after [0 ];
{register integer for_end; k = 0 ;for_end = curroundingptr - 1 ; if (
k <= for_end) do
{
a = nexta ;
b = before [k ];
nexta = after [k + 1 ];
aa = nexta ;
bb = before [k + 1 ];
if ( ( a != b ) || ( aa != bb ) )
{
p = nodetoround [k ];
pp = nodetoround [k + 1 ];
if ( aa == bb )
{
if ( pp == nodetoround [0 ])
unskew ( firstx , firsty , mem [pp ].hhfield .b1 ) ;
else unskew ( mem [pp + 1 ].cint , mem [pp + 2 ].cint , mem
[pp ].hhfield .b1 ) ;
skew ( curx , cury , mem [p ].hhfield .b1 ) ;
bb = curx ;
aa = bb ;
dd = cury ;
cc = dd ;
if ( mem [p ].hhfield .b1 > 4 )
{
b = - (integer) b ;
a = - (integer) a ;
}
}
else {
if ( mem [p ].hhfield .b1 > 4 )
{
bb = - (integer) bb ;
aa = - (integer) aa ;
b = - (integer) b ;
a = - (integer) a ;
}
if ( pp == nodetoround [0 ])
dd = firsty - bb ;
else dd = mem [pp + 2 ].cint - bb ;
if ( odd ( aa - bb ) )
if ( mem [p ].hhfield .b1 > 4 )
cc = dd - half ( aa - bb + 1 ) ;
else cc = dd - half ( aa - bb - 1 ) ;
else cc = dd - half ( aa - bb ) ;
}
d = mem [p + 2 ].cint ;
if ( odd ( a - b ) )
if ( mem [p ].hhfield .b1 > 4 )
c = d - half ( a - b - 1 ) ;
else c = d - half ( a - b + 1 ) ;
else c = d - half ( a - b ) ;
if ( ( aa < a ) || ( cc < c ) || ( aa - a > 2 * ( bb - b ) ) || (
cc - c > 2 * ( dd - d ) ) )
{
allsafe = false ;
after [k ]= before [k ];
if ( k == curroundingptr - 1 )
after [0 ]= before [0 ];
else after [k + 1 ]= before [k + 1 ];
}
}
}
while ( k++ < for_end ) ;}
} while ( ! ( allsafe ) ) ;
{register integer for_end; k = 0 ;for_end = curroundingptr - 1 ; if ( k
<= for_end) do
{
a = after [k ];
b = before [k ];
aa = after [k + 1 ];
bb = before [k + 1 ];
if ( ( a != b ) || ( aa != bb ) )
{
p = nodetoround [k ];
pp = nodetoround [k + 1 ];
if ( aa == bb )
{
if ( pp == nodetoround [0 ])
unskew ( firstx , firsty , mem [pp ].hhfield .b1 ) ;
else unskew ( mem [pp + 1 ].cint , mem [pp + 2 ].cint , mem [
pp ].hhfield .b1 ) ;
skew ( curx , cury , mem [p ].hhfield .b1 ) ;
bb = curx ;
aa = bb ;
dd = cury ;
cc = dd ;
if ( mem [p ].hhfield .b1 > 4 )
{
b = - (integer) b ;
a = - (integer) a ;
}
}
else {
if ( mem [p ].hhfield .b1 > 4 )
{
bb = - (integer) bb ;
aa = - (integer) aa ;
b = - (integer) b ;
a = - (integer) a ;
}
if ( pp == nodetoround [0 ])
dd = firsty - bb ;
else dd = mem [pp + 2 ].cint - bb ;
if ( odd ( aa - bb ) )
if ( mem [p ].hhfield .b1 > 4 )
cc = dd - half ( aa - bb + 1 ) ;
else cc = dd - half ( aa - bb - 1 ) ;
else cc = dd - half ( aa - bb ) ;
}
d = mem [p + 2 ].cint ;
if ( odd ( a - b ) )
if ( mem [p ].hhfield .b1 > 4 )
c = d - half ( a - b - 1 ) ;
else c = d - half ( a - b + 1 ) ;
else c = d - half ( a - b ) ;
if ( b == bb )
alpha = 268435456L ;
else alpha = makefraction ( aa - a , bb - b ) ;
if ( d == dd )
beta = 268435456L ;
else beta = makefraction ( cc - c , dd - d ) ;
do {
mem [p + 1 ].cint = takefraction ( alpha , mem [p + 1 ]
.cint - b ) + a ;
mem [p + 2 ].cint = takefraction ( beta , mem [p + 2 ].cint -
d ) + c ;
mem [p + 5 ].cint = takefraction ( alpha , mem [p + 5 ].cint -
b ) + a ;
mem [p + 6 ].cint = takefraction ( beta , mem [p + 6 ].cint -
d ) + c ;
p = mem [p ].hhfield .v.RH ;
mem [p + 3 ].cint = takefraction ( alpha , mem [p + 3 ].cint -
b ) + a ;
mem [p + 4 ].cint = takefraction ( beta , mem [p + 4 ].cint -
d ) + c ;
} while ( ! ( p == pp ) ) ;
}
}
while ( k++ < for_end ) ;}
}
}
void
#ifdef HAVE_PROTOTYPES
znewboundary ( halfword p , smallnumber octant )
#else
znewboundary ( p , octant )
halfword p ;
smallnumber octant ;
#endif
{
halfword q, r ;
q = mem [p ].hhfield .v.RH ;
r = getnode ( 7 ) ;
mem [r ].hhfield .v.RH = q ;
mem [p ].hhfield .v.RH = r ;
mem [r ].hhfield .b0 = mem [q ].hhfield .b0 ;
mem [r + 3 ].cint = mem [q + 3 ].cint ;
mem [r + 4 ].cint = mem [q + 4 ].cint ;
mem [r ].hhfield .b1 = 0 ;
mem [q ].hhfield .b0 = 0 ;
mem [r + 5 ].cint = octant ;
mem [q + 3 ].cint = mem [q ].hhfield .b1 ;
unskew ( mem [q + 1 ].cint , mem [q + 2 ].cint , mem [q ].hhfield .b1
) ;
skew ( curx , cury , octant ) ;
mem [r + 1 ].cint = curx ;
mem [r + 2 ].cint = cury ;
}
halfword
#ifdef HAVE_PROTOTYPES
zmakespec ( halfword h , scaled safetymargin , integer tracing )
#else
zmakespec ( h , safetymargin , tracing )
halfword h ;
scaled safetymargin ;
integer tracing ;
#endif
{
/* 22 30 */ register halfword Result; halfword p, q, r, s ;
integer k ;
boolean chopped ;
smallnumber o1, o2 ;
boolean clockwise ;
integer dx1, dy1, dx2, dy2 ;
integer dmax, del ;
curspec = h ;
if ( tracing > 0 )
printpath ( curspec , 558 , true ) ;
maxallowed = 268402687L - safetymargin ;
p = curspec ;
k = 1 ;
chopped = false ;
do {
if ( abs ( mem [p + 3 ].cint ) > maxallowed )
{
chopped = true ;
if ( mem [p + 3 ].cint > 0 )
mem [p + 3 ].cint = maxallowed ;
else mem [p + 3 ].cint = - (integer) maxallowed ;
}
if ( abs ( mem [p + 4 ].cint ) > maxallowed )
{
chopped = true ;
if ( mem [p + 4 ].cint > 0 )
mem [p + 4 ].cint = maxallowed ;
else mem [p + 4 ].cint = - (integer) maxallowed ;
}
if ( abs ( mem [p + 1 ].cint ) > maxallowed )
{
chopped = true ;
if ( mem [p + 1 ].cint > 0 )
mem [p + 1 ].cint = maxallowed ;
else mem [p + 1 ].cint = - (integer) maxallowed ;
}
if ( abs ( mem [p + 2 ].cint ) > maxallowed )
{
chopped = true ;
if ( mem [p + 2 ].cint > 0 )
mem [p + 2 ].cint = maxallowed ;
else mem [p + 2 ].cint = - (integer) maxallowed ;
}
if ( abs ( mem [p + 5 ].cint ) > maxallowed )
{
chopped = true ;
if ( mem [p + 5 ].cint > 0 )
mem [p + 5 ].cint = maxallowed ;
else mem [p + 5 ].cint = - (integer) maxallowed ;
}
if ( abs ( mem [p + 6 ].cint ) > maxallowed )
{
chopped = true ;
if ( mem [p + 6 ].cint > 0 )
mem [p + 6 ].cint = maxallowed ;
else mem [p + 6 ].cint = - (integer) maxallowed ;
}
p = mem [p ].hhfield .v.RH ;
mem [p ].hhfield .b0 = k ;
if ( k < 255 )
incr ( k ) ;
else k = 1 ;
} while ( ! ( p == curspec ) ) ;
if ( chopped )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 562 ) ;
}
{
helpptr = 4 ;
helpline [3 ]= 563 ;
helpline [2 ]= 564 ;
helpline [1 ]= 565 ;
helpline [0 ]= 566 ;
}
putgeterror () ;
}
quadrantsubdivide () ;
if ( internal [36 ]> 0 )
xyround () ;
octantsubdivide () ;
if ( internal [36 ]> 65536L )
diaground () ;
p = curspec ;
do {
lab22: q = mem [p ].hhfield .v.RH ;
if ( p != q )
{
if ( mem [p + 1 ].cint == mem [p + 5 ].cint )
if ( mem [p + 2 ].cint == mem [p + 6 ].cint )
if ( mem [p + 1 ].cint == mem [q + 3 ].cint )
if ( mem [p + 2 ].cint == mem [q + 4 ].cint )
{
unskew ( mem [q + 1 ].cint , mem [q + 2 ].cint , mem [q ]
.hhfield .b1 ) ;
skew ( curx , cury , mem [p ].hhfield .b1 ) ;
if ( mem [p + 1 ].cint == curx )
if ( mem [p + 2 ].cint == cury )
{
removecubic ( p ) ;
if ( q != curspec )
goto lab22 ;
curspec = p ;
q = p ;
}
}
}
p = q ;
} while ( ! ( p == curspec ) ) ;
turningnumber = 0 ;
p = curspec ;
q = mem [p ].hhfield .v.RH ;
do {
r = mem [q ].hhfield .v.RH ;
if ( ( mem [p ].hhfield .b1 != mem [q ].hhfield .b1 ) || ( q == r ) )
{
newboundary ( p , mem [p ].hhfield .b1 ) ;
s = mem [p ].hhfield .v.RH ;
o1 = octantnumber [mem [p ].hhfield .b1 ];
o2 = octantnumber [mem [q ].hhfield .b1 ];
switch ( o2 - o1 )
{case 1 :
case -7 :
case 7 :
case -1 :
goto lab30 ;
break ;
case 2 :
case -6 :
clockwise = false ;
break ;
case 3 :
case -5 :
case 4 :
case -4 :
case 5 :
case -3 :
{
dx1 = mem [s + 1 ].cint - mem [s + 3 ].cint ;
dy1 = mem [s + 2 ].cint - mem [s + 4 ].cint ;
if ( dx1 == 0 )
if ( dy1 == 0 )
{
dx1 = mem [s + 1 ].cint - mem [p + 5 ].cint ;
dy1 = mem [s + 2 ].cint - mem [p + 6 ].cint ;
if ( dx1 == 0 )
if ( dy1 == 0 )
{
dx1 = mem [s + 1 ].cint - mem [p + 1 ].cint ;
dy1 = mem [s + 2 ].cint - mem [p + 2 ].cint ;
}
}
dmax = abs ( dx1 ) ;
if ( abs ( dy1 ) > dmax )
dmax = abs ( dy1 ) ;
while ( dmax < 268435456L ) {
dmax = dmax + dmax ;
dx1 = dx1 + dx1 ;
dy1 = dy1 + dy1 ;
}
dx2 = mem [q + 5 ].cint - mem [q + 1 ].cint ;
dy2 = mem [q + 6 ].cint - mem [q + 2 ].cint ;
if ( dx2 == 0 )
if ( dy2 == 0 )
{
dx2 = mem [r + 3 ].cint - mem [q + 1 ].cint ;
dy2 = mem [r + 4 ].cint - mem [q + 2 ].cint ;
if ( dx2 == 0 )
if ( dy2 == 0 )
{
if ( mem [r ].hhfield .b1 == 0 )
{
curx = mem [r + 1 ].cint ;
cury = mem [r + 2 ].cint ;
}
else {
unskew ( mem [r + 1 ].cint , mem [r + 2 ].cint , mem [r ]
.hhfield .b1 ) ;
skew ( curx , cury , mem [q ].hhfield .b1 ) ;
}
dx2 = curx - mem [q + 1 ].cint ;
dy2 = cury - mem [q + 2 ].cint ;
}
}
dmax = abs ( dx2 ) ;
if ( abs ( dy2 ) > dmax )
dmax = abs ( dy2 ) ;
while ( dmax < 268435456L ) {
dmax = dmax + dmax ;
dx2 = dx2 + dx2 ;
dy2 = dy2 + dy2 ;
}
unskew ( dx1 , dy1 , mem [p ].hhfield .b1 ) ;
del = pythadd ( curx , cury ) ;
dx1 = makefraction ( curx , del ) ;
dy1 = makefraction ( cury , del ) ;
unskew ( dx2 , dy2 , mem [q ].hhfield .b1 ) ;
del = pythadd ( curx , cury ) ;
dx2 = makefraction ( curx , del ) ;
dy2 = makefraction ( cury , del ) ;
del = takefraction ( dx1 , dy2 ) - takefraction ( dx2 , dy1 ) ;
if ( del > 4684844L )
clockwise = false ;
else if ( del < -4684844L )
clockwise = true ;
else clockwise = revturns ;
}
break ;
case 6 :
case -2 :
clockwise = true ;
break ;
case 0 :
clockwise = revturns ;
break ;
}
while ( true ) {
if ( clockwise )
if ( o1 == 1 )
o1 = 8 ;
else decr ( o1 ) ;
else if ( o1 == 8 )
o1 = 1 ;
else incr ( o1 ) ;
if ( o1 == o2 )
goto lab30 ;
newboundary ( s , octantcode [o1 ]) ;
s = mem [s ].hhfield .v.RH ;
mem [s + 3 ].cint = mem [s + 5 ].cint ;
}
lab30: if ( q == r )
{
q = mem [q ].hhfield .v.RH ;
r = q ;
p = s ;
mem [s ].hhfield .v.RH = q ;
mem [q + 3 ].cint = mem [q + 5 ].cint ;
mem [q ].hhfield .b0 = 0 ;
freenode ( curspec , 7 ) ;
curspec = q ;
}
p = mem [p ].hhfield .v.RH ;
do {
s = mem [p ].hhfield .v.RH ;
o1 = octantnumber [mem [p + 5 ].cint ];
o2 = octantnumber [mem [s + 3 ].cint ];
if ( abs ( o1 - o2 ) == 1 )
{
if ( o2 < o1 )
o2 = o1 ;
if ( odd ( o2 ) )
mem [p + 6 ].cint = 0 ;
else mem [p + 6 ].cint = 1 ;
}
else {
if ( o1 == 8 )
incr ( turningnumber ) ;
else decr ( turningnumber ) ;
mem [p + 6 ].cint = 0 ;
}
mem [s + 4 ].cint = mem [p + 6 ].cint ;
p = s ;
} while ( ! ( p == q ) ) ;
}
p = q ;
q = r ;
} while ( ! ( p == curspec ) ) ;
while ( mem [curspec ].hhfield .b0 != 0 ) curspec = mem [curspec ]
.hhfield .v.RH ;
if ( tracing > 0 )
if ( internal [36 ]<= 0 )
printspec ( 559 ) ;
else if ( internal [36 ]> 65536L )
printspec ( 560 ) ;
else printspec ( 561 ) ;
Result = curspec ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zendround ( scaled x , scaled y )
#else
zendround ( x , y )
scaled x ;
scaled y ;
#endif
{
y = y + 32768L - ycorr [octant ];
x = x + y - xcorr [octant ];
m1 = floorunscaled ( x ) ;
n1 = floorunscaled ( y ) ;
if ( x - 65536L * m1 >= y - 65536L * n1 + zcorr [octant ])
d1 = 1 ;
else d1 = 0 ;
}
void
#ifdef HAVE_PROTOTYPES
zfillspec ( halfword h )
#else
zfillspec ( h )
halfword h ;
#endif
{
halfword p, q, r, s ;
if ( internal [10 ]> 0 )
beginedgetracing () ;
p = h ;
do {
octant = mem [p + 3 ].cint ;
q = p ;
while ( mem [q ].hhfield .b1 != 0 ) q = mem [q ].hhfield .v.RH ;
if ( q != p )
{
endround ( mem [p + 1 ].cint , mem [p + 2 ].cint ) ;
m0 = m1 ;
n0 = n1 ;
d0 = d1 ;
endround ( mem [q + 1 ].cint , mem [q + 2 ].cint ) ;
if ( n1 - n0 >= movesize )
overflow ( 539 , movesize ) ;
move [0 ]= d0 ;
moveptr = 0 ;
r = p ;
do {
s = mem [r ].hhfield .v.RH ;
makemoves ( mem [r + 1 ].cint , mem [r + 5 ].cint , mem [s + 3 ]
.cint , mem [s + 1 ].cint , mem [r + 2 ].cint + 32768L , mem [r +
6 ].cint + 32768L , mem [s + 4 ].cint + 32768L , mem [s + 2 ]
.cint + 32768L , xycorr [octant ], ycorr [octant ]) ;
r = s ;
} while ( ! ( r == q ) ) ;
move [moveptr ]= move [moveptr ]- d1 ;
if ( internal [35 ]> 0 )
smoothmoves ( 0 , moveptr ) ;
movetoedges ( m0 , n0 , m1 , n1 ) ;
}
p = mem [q ].hhfield .v.RH ;
} while ( ! ( p == h ) ) ;
tossknotlist ( h ) ;
if ( internal [10 ]> 0 )
endedgetracing () ;
}
void
#ifdef HAVE_PROTOTYPES
zdupoffset ( halfword w )
#else
zdupoffset ( w )
halfword w ;
#endif
{
halfword r ;
r = getnode ( 3 ) ;
mem [r + 1 ].cint = mem [w + 1 ].cint ;
mem [r + 2 ].cint = mem [w + 2 ].cint ;
mem [r ].hhfield .v.RH = mem [w ].hhfield .v.RH ;
mem [mem [w ].hhfield .v.RH ].hhfield .lhfield = r ;
mem [r ].hhfield .lhfield = w ;
mem [w ].hhfield .v.RH = r ;
}
halfword
#ifdef HAVE_PROTOTYPES
zmakepen ( halfword h )
#else
zmakepen ( h )
halfword h ;
#endif
{
/* 30 31 45 40 */ register halfword Result; smallnumber o, oo, k ;
halfword p ;
halfword q, r, s, w, hh ;
integer n ;
scaled dx, dy ;
scaled mc ;
q = h ;
r = mem [q ].hhfield .v.RH ;
mc = abs ( mem [h + 1 ].cint ) ;
if ( q == r )
{
hh = h ;
mem [h ].hhfield .b1 = 0 ;
if ( mc < abs ( mem [h + 2 ].cint ) )
mc = abs ( mem [h + 2 ].cint ) ;
}
else {
o = 0 ;
hh = 0 ;
while ( true ) {
s = mem [r ].hhfield .v.RH ;
if ( mc < abs ( mem [r + 1 ].cint ) )
mc = abs ( mem [r + 1 ].cint ) ;
if ( mc < abs ( mem [r + 2 ].cint ) )
mc = abs ( mem [r + 2 ].cint ) ;
dx = mem [r + 1 ].cint - mem [q + 1 ].cint ;
dy = mem [r + 2 ].cint - mem [q + 2 ].cint ;
if ( dx == 0 )
if ( dy == 0 )
goto lab45 ;
if ( abvscd ( dx , mem [s + 2 ].cint - mem [r + 2 ].cint , dy , mem
[s + 1 ].cint - mem [r + 1 ].cint ) < 0 )
goto lab45 ;
if ( dx > 0 )
octant = 1 ;
else if ( dx == 0 )
if ( dy > 0 )
octant = 1 ;
else octant = 2 ;
else {
dx = - (integer) dx ;
octant = 2 ;
}
if ( dy < 0 )
{
dy = - (integer) dy ;
octant = octant + 2 ;
}
else if ( dy == 0 )
if ( octant > 1 )
octant = 4 ;
if ( dx < dy )
octant = octant + 4 ;
mem [q ].hhfield .b1 = octant ;
oo = octantnumber [octant ];
if ( o > oo )
{
if ( hh != 0 )
goto lab45 ;
hh = q ;
}
o = oo ;
if ( ( q == h ) && ( hh != 0 ) )
goto lab30 ;
q = r ;
r = s ;
}
lab30: ;
}
if ( mc >= 268402688L )
goto lab45 ;
p = getnode ( 10 ) ;
q = hh ;
mem [p + 9 ].cint = mc ;
mem [p ].hhfield .lhfield = 0 ;
if ( mem [q ].hhfield .v.RH != q )
mem [p ].hhfield .v.RH = 1 ;
{register integer for_end; k = 1 ;for_end = 8 ; if ( k <= for_end) do
{
octant = octantcode [k ];
n = 0 ;
h = p + octant ;
while ( true ) {
r = getnode ( 3 ) ;
skew ( mem [q + 1 ].cint , mem [q + 2 ].cint , octant ) ;
mem [r + 1 ].cint = curx ;
mem [r + 2 ].cint = cury ;
if ( n == 0 )
mem [h ].hhfield .v.RH = r ;
else if ( odd ( k ) )
{
mem [w ].hhfield .v.RH = r ;
mem [r ].hhfield .lhfield = w ;
}
else {
mem [w ].hhfield .lhfield = r ;
mem [r ].hhfield .v.RH = w ;
}
w = r ;
if ( mem [q ].hhfield .b1 != octant )
goto lab31 ;
q = mem [q ].hhfield .v.RH ;
incr ( n ) ;
}
lab31: r = mem [h ].hhfield .v.RH ;
if ( odd ( k ) )
{
mem [w ].hhfield .v.RH = r ;
mem [r ].hhfield .lhfield = w ;
}
else {
mem [w ].hhfield .lhfield = r ;
mem [r ].hhfield .v.RH = w ;
mem [h ].hhfield .v.RH = w ;
r = w ;
}
if ( ( mem [r + 2 ].cint != mem [mem [r ].hhfield .v.RH + 2 ].cint
) || ( n == 0 ) )
{
dupoffset ( r ) ;
incr ( n ) ;
}
r = mem [r ].hhfield .lhfield ;
if ( mem [r + 1 ].cint != mem [mem [r ].hhfield .lhfield + 1 ]
.cint )
dupoffset ( r ) ;
else decr ( n ) ;
if ( n >= 255 )
overflow ( 578 , 255 ) ;
mem [h ].hhfield .lhfield = n ;
}
while ( k++ < for_end ) ;}
goto lab40 ;
lab45: p = 3 ;
if ( mc >= 268402688L )
{
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 572 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 573 ;
helpline [0 ]= 574 ;
}
}
else {
{
if ( interaction == 3 )
;
printnl ( 261 ) ;
print ( 575 ) ;
}
{
helpptr = 3 ;
helpline [2 ]= 576 ;
helpline [1 ]= 577 ;
helpline [0 ]= 574 ;
}
}
putgeterror () ;
lab40: if ( internal [6 ]> 0 )
printpen ( p , 571 , true ) ;
Result = p ;
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
ztrivialknot ( scaled x , scaled y )
#else
ztrivialknot ( x , y )
scaled x ;
scaled y ;
#endif
{
register halfword Result; halfword p ;
p = getnode ( 7 ) ;
mem [p ].hhfield .b0 = 1 ;
mem [p ].hhfield .b1 = 1 ;
mem [p + 1 ].cint = x ;
mem [p + 3 ].cint = x ;
mem [p + 5 ].cint = x ;
mem [p + 2 ].cint = y ;
mem [p + 4 ].cint = y ;
mem [p + 6 ].cint = y ;
Result = p ;
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
zmakepath ( halfword penhead )
#else
zmakepath ( penhead )
halfword penhead ;
#endif
{
register halfword Result; halfword p ;
char k ;
halfword h ;
integer m, n ;
halfword w, ww ;
p = memtop - 1 ;
{register integer for_end; k = 1 ;for_end = 8 ; if ( k <= for_end) do
{
octant = octantcode [k ];
h = penhead + octant ;
n = mem [h ].hhfield .lhfield ;
w = mem [h ].hhfield .v.RH ;
if ( ! odd ( k ) )
w = mem [w ].hhfield .lhfield ;
{register integer for_end; m = 1 ;for_end = n + 1 ; if ( m <= for_end)
do
{
if ( odd ( k ) )
ww = mem [w ].hhfield .v.RH ;
else ww = mem [w ].hhfield .lhfield ;
if ( ( mem [ww + 1 ].cint != mem [w + 1 ].cint ) || ( mem [ww +
2 ].cint != mem [w + 2 ].cint ) )
{
unskew ( mem [ww + 1 ].cint , mem [ww + 2 ].cint , octant ) ;
mem [p ].hhfield .v.RH = trivialknot ( curx , cury ) ;
p = mem [p ].hhfield .v.RH ;
}
w = ww ;
}
while ( m++ < for_end ) ;}
}
while ( k++ < for_end ) ;}
if ( p == memtop - 1 )
{
w = mem [penhead + 1 ].hhfield .v.RH ;
p = trivialknot ( mem [w + 1 ].cint + mem [w + 2 ].cint , mem [w + 2
].cint ) ;
mem [memtop - 1 ].hhfield .v.RH = p ;
}
mem [p ].hhfield .v.RH = mem [memtop - 1 ].hhfield .v.RH ;
Result = mem [memtop - 1 ].hhfield .v.RH ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zfindoffset ( scaled x , scaled y , halfword p )
#else
zfindoffset ( x , y , p )
scaled x ;
scaled y ;
halfword p ;
#endif
{
/* 30 10 */ char octant ;
schar s ;
integer n ;
halfword h, w, ww ;
if ( x > 0 )
octant = 1 ;
else if ( x == 0 )
if ( y <= 0 )
if ( y == 0 )
{
curx = 0 ;
cury = 0 ;
goto lab10 ;
}
else octant = 2 ;
else octant = 1 ;
else {
x = - (integer) x ;
if ( y == 0 )
octant = 4 ;
else octant = 2 ;
}
if ( y < 0 )
{
octant = octant + 2 ;
y = - (integer) y ;
}
if ( x >= y )
x = x - y ;
else {
octant = octant + 4 ;
x = y - x ;
y = y - x ;
}
if ( odd ( octantnumber [octant ]) )
s = -1 ;
else s = 1 ;
h = p + octant ;
w = mem [mem [h ].hhfield .v.RH ].hhfield .v.RH ;
ww = mem [w ].hhfield .v.RH ;
n = mem [h ].hhfield .lhfield ;
while ( n > 1 ) {
if ( abvscd ( x , mem [ww + 2 ].cint - mem [w + 2 ].cint , y , mem [
ww + 1 ].cint - mem [w + 1 ].cint ) != s )
goto lab30 ;
w = ww ;
ww = mem [w ].hhfield .v.RH ;
decr ( n ) ;
}
lab30: unskew ( mem [w + 1 ].cint , mem [w + 2 ].cint , octant ) ;
lab10: ;
}
|
