#define EXTERN extern
#include "mpd.h"
void
#ifdef HAVE_PROTOTYPES
zpathintersection ( halfword h , halfword hh )
#else
zpathintersection ( h , hh )
halfword h ;
halfword hh ;
#endif
{
/* 10 */ halfword p, pp ;
integer n, nn ;
if ( mem [h ].hhfield .b1 == 0 )
{
mem [h + 5 ].cint = mem [h + 1 ].cint ;
mem [h + 3 ].cint = mem [h + 1 ].cint ;
mem [h + 6 ].cint = mem [h + 2 ].cint ;
mem [h + 4 ].cint = mem [h + 2 ].cint ;
mem [h ].hhfield .b1 = 1 ;
}
if ( mem [hh ].hhfield .b1 == 0 )
{
mem [hh + 5 ].cint = mem [hh + 1 ].cint ;
mem [hh + 3 ].cint = mem [hh + 1 ].cint ;
mem [hh + 6 ].cint = mem [hh + 2 ].cint ;
mem [hh + 4 ].cint = mem [hh + 2 ].cint ;
mem [hh ].hhfield .b1 = 1 ;
}
tolstep = 0 ;
do {
n = -65536L ;
p = h ;
do {
if ( mem [p ].hhfield .b1 != 0 )
{
nn = -65536L ;
pp = hh ;
do {
if ( mem [pp ].hhfield .b1 != 0 )
{
cubicintersection ( p , pp ) ;
if ( curt > 0 )
{
curt = curt + n ;
curtt = curtt + nn ;
goto lab10 ;
}
}
nn = nn + 65536L ;
pp = mem [pp ].hhfield .v.RH ;
} while ( ! ( pp == hh ) ) ;
}
n = n + 65536L ;
p = mem [p ].hhfield .v.RH ;
} while ( ! ( p == h ) ) ;
tolstep = tolstep + 3 ;
} while ( ! ( tolstep > 3 ) ) ;
curt = -65536L ;
curtt = -65536L ;
lab10: ;
}
fraction
#ifdef HAVE_PROTOTYPES
zmaxcoef ( halfword p )
#else
zmaxcoef ( p )
halfword p ;
#endif
{
register fraction Result; fraction x ;
x = 0 ;
while ( mem [p ].hhfield .lhfield != 0 ) {
if ( abs ( mem [p + 1 ].cint ) > x )
x = abs ( mem [p + 1 ].cint ) ;
p = mem [p ].hhfield .v.RH ;
}
Result = x ;
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
zpplusq ( halfword p , halfword q , smallnumber t )
#else
zpplusq ( p , q , t )
halfword p ;
halfword q ;
smallnumber t ;
#endif
{
/* 30 */ register halfword Result; halfword pp, qq ;
halfword r, s ;
integer threshold ;
integer v ;
if ( t == 17 )
threshold = 2685 ;
else threshold = 8 ;
r = memtop - 1 ;
pp = mem [p ].hhfield .lhfield ;
qq = mem [q ].hhfield .lhfield ;
while ( true ) if ( pp == qq )
if ( pp == 0 )
goto lab30 ;
else {
v = mem [p + 1 ].cint + mem [q + 1 ].cint ;
mem [p + 1 ].cint = v ;
s = p ;
p = mem [p ].hhfield .v.RH ;
pp = mem [p ].hhfield .lhfield ;
if ( abs ( v ) < threshold )
freenode ( s , 2 ) ;
else {
if ( abs ( v ) >= 626349397L )
if ( watchcoefs )
{
mem [qq ].hhfield .b0 = 0 ;
fixneeded = true ;
}
mem [r ].hhfield .v.RH = s ;
r = s ;
}
q = mem [q ].hhfield .v.RH ;
qq = mem [q ].hhfield .lhfield ;
}
else if ( mem [pp + 1 ].cint < mem [qq + 1 ].cint )
{
s = getnode ( 2 ) ;
mem [s ].hhfield .lhfield = qq ;
mem [s + 1 ].cint = mem [q + 1 ].cint ;
q = mem [q ].hhfield .v.RH ;
qq = mem [q ].hhfield .lhfield ;
mem [r ].hhfield .v.RH = s ;
r = s ;
}
else {
mem [r ].hhfield .v.RH = p ;
r = p ;
p = mem [p ].hhfield .v.RH ;
pp = mem [p ].hhfield .lhfield ;
}
lab30: mem [p + 1 ].cint = slowadd ( mem [p + 1 ].cint , mem [q + 1 ]
.cint ) ;
mem [r ].hhfield .v.RH = p ;
depfinal = p ;
Result = mem [memtop - 1 ].hhfield .v.RH ;
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
zptimesv ( halfword p , integer v , smallnumber t0 , smallnumber t1 , boolean
visscaled )
#else
zptimesv ( p , v , t0 , t1 , visscaled )
halfword p ;
integer v ;
smallnumber t0 ;
smallnumber t1 ;
boolean visscaled ;
#endif
{
register halfword Result; halfword r, s ;
integer w ;
integer threshold ;
boolean scalingdown ;
if ( t0 != t1 )
scalingdown = true ;
else scalingdown = ! visscaled ;
if ( t1 == 17 )
threshold = 1342 ;
else threshold = 4 ;
r = memtop - 1 ;
while ( mem [p ].hhfield .lhfield != 0 ) {
if ( scalingdown )
w = takefraction ( v , mem [p + 1 ].cint ) ;
else w = takescaled ( v , mem [p + 1 ].cint ) ;
if ( abs ( w ) <= threshold )
{
s = mem [p ].hhfield .v.RH ;
freenode ( p , 2 ) ;
p = s ;
}
else {
if ( abs ( w ) >= 626349397L )
{
fixneeded = true ;
mem [mem [p ].hhfield .lhfield ].hhfield .b0 = 0 ;
}
mem [r ].hhfield .v.RH = p ;
r = p ;
mem [p + 1 ].cint = w ;
p = mem [p ].hhfield .v.RH ;
}
}
mem [r ].hhfield .v.RH = p ;
if ( visscaled )
mem [p + 1 ].cint = takescaled ( mem [p + 1 ].cint , v ) ;
else mem [p + 1 ].cint = takefraction ( mem [p + 1 ].cint , v ) ;
Result = mem [memtop - 1 ].hhfield .v.RH ;
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
zpwithxbecomingq ( halfword p , halfword x , halfword q , smallnumber t )
#else
zpwithxbecomingq ( p , x , q , t )
halfword p ;
halfword x ;
halfword q ;
smallnumber t ;
#endif
{
register halfword Result; halfword r, s ;
integer v ;
integer sx ;
s = p ;
r = memtop - 1 ;
sx = mem [x + 1 ].cint ;
while ( mem [mem [s ].hhfield .lhfield + 1 ].cint > sx ) {
r = s ;
s = mem [s ].hhfield .v.RH ;
}
if ( mem [s ].hhfield .lhfield != x )
Result = p ;
else {
mem [memtop - 1 ].hhfield .v.RH = p ;
mem [r ].hhfield .v.RH = mem [s ].hhfield .v.RH ;
v = mem [s + 1 ].cint ;
freenode ( s , 2 ) ;
Result = pplusfq ( mem [memtop - 1 ].hhfield .v.RH , v , q , t , 17 ) ;
}
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
znewdep ( halfword q , halfword p )
#else
znewdep ( q , p )
halfword q ;
halfword p ;
#endif
{
halfword r ;
mem [q + 1 ].hhfield .v.RH = p ;
mem [q + 1 ].hhfield .lhfield = 5 ;
r = mem [5 ].hhfield .v.RH ;
mem [depfinal ].hhfield .v.RH = r ;
mem [r + 1 ].hhfield .lhfield = depfinal ;
mem [5 ].hhfield .v.RH = q ;
}
halfword
#ifdef HAVE_PROTOTYPES
zconstdependency ( scaled v )
#else
zconstdependency ( v )
scaled v ;
#endif
{
register halfword Result; depfinal = getnode ( 2 ) ;
mem [depfinal + 1 ].cint = v ;
mem [depfinal ].hhfield .lhfield = 0 ;
Result = depfinal ;
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
zsingledependency ( halfword p )
#else
zsingledependency ( p )
halfword p ;
#endif
{
register halfword Result; halfword q ;
integer m ;
m = mem [p + 1 ].cint % 64 ;
if ( m > 28 )
Result = constdependency ( 0 ) ;
else {
q = getnode ( 2 ) ;
mem [q + 1 ].cint = twotothe [28 - m ];
mem [q ].hhfield .lhfield = p ;
mem [q ].hhfield .v.RH = constdependency ( 0 ) ;
Result = q ;
}
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
zcopydeplist ( halfword p )
#else
zcopydeplist ( p )
halfword p ;
#endif
{
/* 30 */ register halfword Result; halfword q ;
q = getnode ( 2 ) ;
depfinal = q ;
while ( true ) {
mem [depfinal ].hhfield .lhfield = mem [p ].hhfield .lhfield ;
mem [depfinal + 1 ].cint = mem [p + 1 ].cint ;
if ( mem [depfinal ].hhfield .lhfield == 0 )
goto lab30 ;
mem [depfinal ].hhfield .v.RH = getnode ( 2 ) ;
depfinal = mem [depfinal ].hhfield .v.RH ;
p = mem [p ].hhfield .v.RH ;
}
lab30: Result = q ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zlineareq ( halfword p , smallnumber t )
#else
zlineareq ( p , t )
halfword p ;
smallnumber t ;
#endif
{
halfword q, r, s ;
halfword x ;
integer n ;
integer v ;
halfword prevr ;
halfword finalnode ;
integer w ;
q = p ;
r = mem [p ].hhfield .v.RH ;
v = mem [q + 1 ].cint ;
while ( mem [r ].hhfield .lhfield != 0 ) {
if ( abs ( mem [r + 1 ].cint ) > abs ( v ) )
{
q = r ;
v = mem [r + 1 ].cint ;
}
r = mem [r ].hhfield .v.RH ;
}
x = mem [q ].hhfield .lhfield ;
n = mem [x + 1 ].cint % 64 ;
s = memtop - 1 ;
mem [s ].hhfield .v.RH = p ;
r = p ;
do {
if ( r == q )
{
mem [s ].hhfield .v.RH = mem [r ].hhfield .v.RH ;
freenode ( r , 2 ) ;
}
else {
w = makefraction ( mem [r + 1 ].cint , v ) ;
if ( abs ( w ) <= 1342 )
{
mem [s ].hhfield .v.RH = mem [r ].hhfield .v.RH ;
freenode ( r , 2 ) ;
}
else {
mem [r + 1 ].cint = - (integer) w ;
s = r ;
}
}
r = mem [s ].hhfield .v.RH ;
} while ( ! ( mem [r ].hhfield .lhfield == 0 ) ) ;
if ( t == 18 )
mem [r + 1 ].cint = - (integer) makescaled ( mem [r + 1 ].cint , v ) ;
else if ( v != -268435456L )
mem [r + 1 ].cint = - (integer) makefraction ( mem [r + 1 ].cint , v ) ;
finalnode = r ;
p = mem [memtop - 1 ].hhfield .v.RH ;
if ( internal [2 ]> 0 )
if ( interesting ( x ) )
{
begindiagnostic () ;
printnl ( 608 ) ;
printvariablename ( x ) ;
w = n ;
while ( w > 0 ) {
print ( 601 ) ;
w = w - 2 ;
}
printchar ( 61 ) ;
printdependency ( p , 17 ) ;
enddiagnostic ( false ) ;
}
prevr = 5 ;
r = mem [5 ].hhfield .v.RH ;
while ( r != 5 ) {
s = mem [r + 1 ].hhfield .v.RH ;
q = pwithxbecomingq ( s , x , p , mem [r ].hhfield .b0 ) ;
if ( mem [q ].hhfield .lhfield == 0 )
makeknown ( r , q ) ;
else {
mem [r + 1 ].hhfield .v.RH = q ;
do {
q = mem [q ].hhfield .v.RH ;
} while ( ! ( mem [q ].hhfield .lhfield == 0 ) ) ;
prevr = q ;
}
r = mem [prevr ].hhfield .v.RH ;
}
if ( n > 0 )
{
s = memtop - 1 ;
mem [memtop - 1 ].hhfield .v.RH = p ;
r = p ;
do {
if ( n > 30 )
w = 0 ;
else w = mem [r + 1 ].cint / twotothe [n ];
if ( ( abs ( w ) <= 1342 ) && ( mem [r ].hhfield .lhfield != 0 ) )
{
mem [s ].hhfield .v.RH = mem [r ].hhfield .v.RH ;
freenode ( r , 2 ) ;
}
else {
mem [r + 1 ].cint = w ;
s = r ;
}
r = mem [s ].hhfield .v.RH ;
} while ( ! ( mem [s ].hhfield .lhfield == 0 ) ) ;
p = mem [memtop - 1 ].hhfield .v.RH ;
}
if ( mem [p ].hhfield .lhfield == 0 )
{
mem [x ].hhfield .b0 = 16 ;
mem [x + 1 ].cint = mem [p + 1 ].cint ;
if ( abs ( mem [x + 1 ].cint ) >= 268435456L )
valtoobig ( mem [x + 1 ].cint ) ;
freenode ( p , 2 ) ;
if ( curexp == x )
if ( curtype == 19 )
{
curexp = mem [x + 1 ].cint ;
curtype = 16 ;
freenode ( x , 2 ) ;
}
}
else {
mem [x ].hhfield .b0 = 17 ;
depfinal = finalnode ;
newdep ( x , p ) ;
if ( curexp == x )
if ( curtype == 19 )
curtype = 17 ;
}
if ( fixneeded )
fixdependencies () ;
}
halfword
#ifdef HAVE_PROTOTYPES
znewringentry ( halfword p )
#else
znewringentry ( p )
halfword p ;
#endif
{
register halfword Result; halfword q ;
q = getnode ( 2 ) ;
mem [q ].hhfield .b1 = 14 ;
mem [q ].hhfield .b0 = mem [p ].hhfield .b0 ;
if ( mem [p + 1 ].cint == 0 )
mem [q + 1 ].cint = p ;
else mem [q + 1 ].cint = mem [p + 1 ].cint ;
mem [p + 1 ].cint = q ;
Result = q ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
znonlineareq ( integer v , halfword p , boolean flushp )
#else
znonlineareq ( v , p , flushp )
integer v ;
halfword p ;
boolean flushp ;
#endif
{
smallnumber t ;
halfword q, r ;
t = mem [p ].hhfield .b0 - 1 ;
q = mem [p + 1 ].cint ;
if ( flushp )
mem [p ].hhfield .b0 = 1 ;
else p = q ;
do {
r = mem [q + 1 ].cint ;
mem [q ].hhfield .b0 = t ;
switch ( t )
{case 2 :
mem [q + 1 ].cint = v ;
break ;
case 4 :
{
mem [q + 1 ].cint = v ;
{
if ( strref [v ]< 127 )
incr ( strref [v ]) ;
}
}
break ;
case 6 :
mem [q + 1 ].cint = makepen ( copypath ( v ) , false ) ;
break ;
case 8 :
mem [q + 1 ].cint = copypath ( v ) ;
break ;
case 10 :
{
mem [q + 1 ].cint = v ;
incr ( mem [v ].hhfield .lhfield ) ;
}
break ;
}
q = r ;
} while ( ! ( q == p ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
zringmerge ( halfword p , halfword q )
#else
zringmerge ( p , q )
halfword p ;
halfword q ;
#endif
{
/* 10 */ halfword r ;
r = mem [p + 1 ].cint ;
while ( r != p ) {
if ( r == q )
{
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 611 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 612 ;
helpline [0 ]= 613 ;
}
putgeterror () ;
}
goto lab10 ;
}
r = mem [r + 1 ].cint ;
}
r = mem [p + 1 ].cint ;
mem [p + 1 ].cint = mem [q + 1 ].cint ;
mem [q + 1 ].cint = r ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zshowcmdmod ( integer c , integer m )
#else
zshowcmdmod ( c , m )
integer c ;
integer m ;
#endif
{
begindiagnostic () ;
printnl ( 123 ) ;
printcmdmod ( c , m ) ;
printchar ( 125 ) ;
enddiagnostic ( false ) ;
}
void
#ifdef HAVE_PROTOTYPES
showcontext ( void )
#else
showcontext ( )
#endif
{
/* 30 */ char oldsetting ;
integer i ;
integer l ;
integer m ;
integer n ;
integer p ;
integer q ;
fileptr = inputptr ;
inputstack [fileptr ]= curinput ;
while ( true ) {
curinput = inputstack [fileptr ];
if ( ( fileptr == inputptr ) || ( curinput .indexfield <= 15 ) || (
curinput .indexfield != 19 ) || ( curinput .locfield != 0 ) )
{
tally = 0 ;
oldsetting = selector ;
if ( ( curinput .indexfield <= 15 ) )
{
if ( curinput .namefield > 2 )
{
printnl ( curinput .namefield ) ;
print ( 58 ) ;
printint ( trueline () ) ;
print ( 58 ) ;
}
else if ( ( curinput .namefield == 0 ) )
if ( fileptr == 0 )
printnl ( 615 ) ;
else printnl ( 616 ) ;
else if ( curinput .namefield == 2 )
printnl ( 617 ) ;
else printnl ( 618 ) ;
printchar ( 32 ) ;
{
l = tally ;
tally = 0 ;
selector = 6 ;
trickcount = 1000000L ;
}
if ( curinput .limitfield > 0 )
{register integer for_end; i = curinput .startfield ;for_end =
curinput .limitfield - 1 ; if ( i <= for_end) do
{
if ( i == curinput .locfield )
{
firstcount = tally ;
trickcount = tally + 1 + errorline - halferrorline ;
if ( trickcount < errorline )
trickcount = errorline ;
}
print ( buffer [i ]) ;
}
while ( i++ < for_end ) ;}
}
else {
switch ( curinput .indexfield )
{case 16 :
printnl ( 619 ) ;
break ;
case 17 :
{
printnl ( 624 ) ;
p = paramstack [curinput .limitfield ];
if ( p != 0 )
if ( mem [p ].hhfield .v.RH == 1 )
printexp ( p , 0 ) ;
else showtokenlist ( p , 0 , 20 , tally ) ;
print ( 625 ) ;
}
break ;
case 18 :
printnl ( 620 ) ;
break ;
case 19 :
if ( curinput .locfield == 0 )
printnl ( 621 ) ;
else printnl ( 622 ) ;
break ;
case 20 :
printnl ( 623 ) ;
break ;
case 21 :
{
println () ;
if ( curinput .namefield != 0 )
print ( hash [curinput .namefield ].v.RH ) ;
else {
p = paramstack [curinput .limitfield ];
if ( p == 0 )
showtokenlist ( paramstack [curinput .limitfield + 1 ], 0 , 20
, tally ) ;
else {
q = p ;
while ( mem [q ].hhfield .v.RH != 0 ) q = mem [q ].hhfield
.v.RH ;
mem [q ].hhfield .v.RH = paramstack [curinput .limitfield +
1 ];
showtokenlist ( p , 0 , 20 , tally ) ;
mem [q ].hhfield .v.RH = 0 ;
}
}
print ( 513 ) ;
}
break ;
default:
printnl ( 63 ) ;
break ;
}
{
l = tally ;
tally = 0 ;
selector = 6 ;
trickcount = 1000000L ;
}
if ( curinput .indexfield != 21 )
showtokenlist ( curinput .startfield , curinput .locfield , 100000L ,
0 ) ;
else showmacro ( curinput .startfield , curinput .locfield , 100000L )
;
}
selector = oldsetting ;
if ( trickcount == 1000000L )
{
firstcount = tally ;
trickcount = tally + 1 + errorline - halferrorline ;
if ( trickcount < errorline )
trickcount = errorline ;
}
if ( tally < trickcount )
m = tally - firstcount ;
else m = trickcount - firstcount ;
if ( l + firstcount <= halferrorline )
{
p = 0 ;
n = l + firstcount ;
}
else {
print ( 275 ) ;
p = l + firstcount - halferrorline + 3 ;
n = halferrorline ;
}
{register integer for_end; q = p ;for_end = firstcount - 1 ; if ( q <=
for_end) do
printchar ( trickbuf [q % errorline ]) ;
while ( q++ < for_end ) ;}
println () ;
{register integer for_end; q = 1 ;for_end = n ; if ( q <= for_end) do
printchar ( 32 ) ;
while ( q++ < for_end ) ;}
if ( m + n <= errorline )
p = firstcount + m ;
else p = firstcount + ( errorline - n - 3 ) ;
{register integer for_end; q = firstcount ;for_end = p - 1 ; if ( q <=
for_end) do
printchar ( trickbuf [q % errorline ]) ;
while ( q++ < for_end ) ;}
if ( m + n > errorline )
print ( 275 ) ;
}
if ( ( curinput .indexfield <= 15 ) )
if ( ( curinput .namefield > 2 ) || ( fileptr == 0 ) )
goto lab30 ;
decr ( fileptr ) ;
}
lab30: curinput = inputstack [inputptr ];
}
void
#ifdef HAVE_PROTOTYPES
zbegintokenlist ( halfword p , quarterword t )
#else
zbegintokenlist ( p , t )
halfword p ;
quarterword t ;
#endif
{
{
if ( inputptr > maxinstack )
{
maxinstack = inputptr ;
if ( inputptr == stacksize )
overflow ( 626 , stacksize ) ;
}
inputstack [inputptr ]= curinput ;
incr ( inputptr ) ;
}
curinput .startfield = p ;
curinput .indexfield = t ;
curinput .limitfield = paramptr ;
curinput .locfield = p ;
}
void
#ifdef HAVE_PROTOTYPES
endtokenlist ( void )
#else
endtokenlist ( )
#endif
{
/* 30 */ halfword p ;
if ( curinput .indexfield >= 19 )
if ( curinput .indexfield <= 20 )
{
flushtokenlist ( curinput .startfield ) ;
goto lab30 ;
}
else deletemacref ( curinput .startfield ) ;
while ( paramptr > curinput .limitfield ) {
decr ( paramptr ) ;
p = paramstack [paramptr ];
if ( p != 0 )
if ( mem [p ].hhfield .v.RH == 1 )
{
recyclevalue ( p ) ;
freenode ( p , 2 ) ;
}
else flushtokenlist ( p ) ;
}
lab30: {
decr ( inputptr ) ;
curinput = inputstack [inputptr ];
}
{
if ( interrupt != 0 )
pauseforinstructions () ;
}
}
void
#ifdef HAVE_PROTOTYPES
zencapsulate ( halfword p )
#else
zencapsulate ( p )
halfword p ;
#endif
{
curexp = getnode ( 2 ) ;
mem [curexp ].hhfield .b0 = curtype ;
mem [curexp ].hhfield .b1 = 14 ;
newdep ( curexp , p ) ;
}
void
#ifdef HAVE_PROTOTYPES
zinstall ( halfword r , halfword q )
#else
zinstall ( r , q )
halfword r ;
halfword q ;
#endif
{
halfword p ;
if ( mem [q ].hhfield .b0 == 16 )
{
mem [r + 1 ].cint = mem [q + 1 ].cint ;
mem [r ].hhfield .b0 = 16 ;
}
else if ( mem [q ].hhfield .b0 == 19 )
{
p = singledependency ( q ) ;
if ( p == depfinal )
{
mem [r ].hhfield .b0 = 16 ;
mem [r + 1 ].cint = 0 ;
freenode ( p , 2 ) ;
}
else {
mem [r ].hhfield .b0 = 17 ;
newdep ( r , p ) ;
}
}
else {
mem [r ].hhfield .b0 = mem [q ].hhfield .b0 ;
newdep ( r , copydeplist ( mem [q + 1 ].hhfield .v.RH ) ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zmakeexpcopy ( halfword p )
#else
zmakeexpcopy ( p )
halfword p ;
#endif
{
/* 20 */ halfword q, r, t ;
lab20: curtype = mem [p ].hhfield .b0 ;
switch ( curtype )
{case 1 :
case 2 :
case 16 :
curexp = mem [p + 1 ].cint ;
break ;
case 3 :
case 5 :
case 7 :
case 11 :
case 9 :
curexp = newringentry ( p ) ;
break ;
case 4 :
{
curexp = mem [p + 1 ].cint ;
{
if ( strref [curexp ]< 127 )
incr ( strref [curexp ]) ;
}
}
break ;
case 10 :
{
curexp = mem [p + 1 ].cint ;
incr ( mem [curexp ].hhfield .lhfield ) ;
}
break ;
case 6 :
curexp = makepen ( copypath ( mem [p + 1 ].cint ) , false ) ;
break ;
case 8 :
curexp = copypath ( mem [p + 1 ].cint ) ;
break ;
case 12 :
case 13 :
case 14 :
{
if ( mem [p + 1 ].cint == 0 )
initbignode ( p ) ;
t = getnode ( 2 ) ;
mem [t ].hhfield .b1 = 14 ;
mem [t ].hhfield .b0 = curtype ;
initbignode ( t ) ;
q = mem [p + 1 ].cint + bignodesize [curtype ];
r = mem [t + 1 ].cint + bignodesize [curtype ];
do {
q = q - 2 ;
r = r - 2 ;
install ( r , q ) ;
} while ( ! ( q == mem [p + 1 ].cint ) ) ;
curexp = t ;
}
break ;
case 17 :
case 18 :
encapsulate ( copydeplist ( mem [p + 1 ].hhfield .v.RH ) ) ;
break ;
case 15 :
{
{
mem [p ].hhfield .b0 = 19 ;
serialno = serialno + 64 ;
mem [p + 1 ].cint = serialno ;
}
goto lab20 ;
}
break ;
case 19 :
{
q = singledependency ( p ) ;
if ( q == depfinal )
{
curtype = 16 ;
curexp = 0 ;
freenode ( q , 2 ) ;
}
else {
curtype = 17 ;
encapsulate ( q ) ;
}
}
break ;
default:
confusion ( 851 ) ;
break ;
}
}
halfword
#ifdef HAVE_PROTOTYPES
curtok ( void )
#else
curtok ( )
#endif
{
register halfword Result; halfword p ;
smallnumber savetype ;
integer saveexp ;
if ( cursym == 0 )
if ( curcmd == 40 )
{
savetype = curtype ;
saveexp = curexp ;
makeexpcopy ( curmod ) ;
p = stashcurexp () ;
mem [p ].hhfield .v.RH = 0 ;
curtype = savetype ;
curexp = saveexp ;
}
else {
p = getnode ( 2 ) ;
mem [p + 1 ].cint = curmod ;
mem [p ].hhfield .b1 = 15 ;
if ( curcmd == 44 )
mem [p ].hhfield .b0 = 16 ;
else mem [p ].hhfield .b0 = 4 ;
}
else {
{
p = avail ;
if ( p == 0 )
p = getavail () ;
else {
avail = mem [p ].hhfield .v.RH ;
mem [p ].hhfield .v.RH = 0 ;
;
#ifdef STAT
incr ( dynused ) ;
#endif /* STAT */
}
}
mem [p ].hhfield .lhfield = cursym ;
}
Result = p ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
backinput ( void )
#else
backinput ( )
#endif
{
halfword p ;
p = curtok () ;
while ( ( curinput .indexfield > 15 ) && ( curinput .locfield == 0 ) )
endtokenlist () ;
begintokenlist ( p , 19 ) ;
}
void
#ifdef HAVE_PROTOTYPES
backerror ( void )
#else
backerror ( )
#endif
{
OKtointerrupt = false ;
backinput () ;
OKtointerrupt = true ;
error () ;
}
void
#ifdef HAVE_PROTOTYPES
inserror ( void )
#else
inserror ( )
#endif
{
OKtointerrupt = false ;
backinput () ;
curinput .indexfield = 20 ;
OKtointerrupt = true ;
error () ;
}
void
#ifdef HAVE_PROTOTYPES
beginfilereading ( void )
#else
beginfilereading ( )
#endif
{
if ( inopen == 15 )
overflow ( 627 , 15 ) ;
if ( first == bufsize )
overflow ( 256 , bufsize ) ;
incr ( inopen ) ;
{
if ( inputptr > maxinstack )
{
maxinstack = inputptr ;
if ( inputptr == stacksize )
overflow ( 626 , stacksize ) ;
}
inputstack [inputptr ]= curinput ;
incr ( inputptr ) ;
}
curinput .indexfield = inopen ;
mpxname [curinput .indexfield ]= 1 ;
curinput .startfield = first ;
curinput .namefield = 0 ;
}
void
#ifdef HAVE_PROTOTYPES
endfilereading ( void )
#else
endfilereading ( )
#endif
{
if ( inopen > curinput .indexfield )
if ( ( mpxname [inopen ]== 1 ) || ( curinput .namefield <= 2 ) )
confusion ( 628 ) ;
else {
aclose ( inputfile [inopen ]) ;
{
if ( strref [mpxname [inopen ]]< 127 )
if ( strref [mpxname [inopen ]]> 1 )
decr ( strref [mpxname [inopen ]]) ;
else flushstring ( mpxname [inopen ]) ;
}
decr ( inopen ) ;
}
first = curinput .startfield ;
if ( curinput .indexfield != inopen )
confusion ( 628 ) ;
if ( curinput .namefield > 2 )
{
aclose ( inputfile [curinput .indexfield ]) ;
{
if ( strref [curinput .namefield ]< 127 )
if ( strref [curinput .namefield ]> 1 )
decr ( strref [curinput .namefield ]) ;
else flushstring ( curinput .namefield ) ;
}
{
if ( strref [inamestack [curinput .indexfield ]]< 127 )
if ( strref [inamestack [curinput .indexfield ]]> 1 )
decr ( strref [inamestack [curinput .indexfield ]]) ;
else flushstring ( inamestack [curinput .indexfield ]) ;
}
{
if ( strref [iareastack [curinput .indexfield ]]< 127 )
if ( strref [iareastack [curinput .indexfield ]]> 1 )
decr ( strref [iareastack [curinput .indexfield ]]) ;
else flushstring ( iareastack [curinput .indexfield ]) ;
}
}
{
decr ( inputptr ) ;
curinput = inputstack [inputptr ];
}
decr ( inopen ) ;
}
boolean
#ifdef HAVE_PROTOTYPES
beginmpxreading ( void )
#else
beginmpxreading ( )
#endif
{
register boolean Result; if ( inopen != curinput .indexfield + 1 )
Result = false ;
else {
if ( mpxname [inopen ]<= 1 )
confusion ( 629 ) ;
if ( first == bufsize )
overflow ( 256 , bufsize ) ;
{
if ( inputptr > maxinstack )
{
maxinstack = inputptr ;
if ( inputptr == stacksize )
overflow ( 626 , stacksize ) ;
}
inputstack [inputptr ]= curinput ;
incr ( inputptr ) ;
}
curinput .indexfield = inopen ;
curinput .startfield = first ;
curinput .namefield = mpxname [inopen ];
{
if ( strref [curinput .namefield ]< 127 )
incr ( strref [curinput .namefield ]) ;
}
last = first ;
curinput .limitfield = last ;
buffer [curinput .limitfield ]= 37 ;
first = curinput .limitfield + 1 ;
curinput .locfield = curinput .startfield ;
Result = true ;
}
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
endmpxreading ( void )
#else
endmpxreading ( )
#endif
{
if ( inopen != curinput .indexfield )
confusion ( 629 ) ;
if ( curinput .locfield < curinput .limitfield )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 630 ) ;
}
{
helpptr = 4 ;
helpline [3 ]= 631 ;
helpline [2 ]= 632 ;
helpline [1 ]= 633 ;
helpline [0 ]= 634 ;
}
error () ;
}
first = curinput .startfield ;
{
decr ( inputptr ) ;
curinput = inputstack [inputptr ];
}
}
void
#ifdef HAVE_PROTOTYPES
clearforerrorprompt ( void )
#else
clearforerrorprompt ( )
#endif
{
while ( ( curinput .indexfield <= 15 ) && ( curinput .namefield == 0 ) &&
( inputptr > 0 ) && ( curinput .locfield == curinput .limitfield ) )
endfilereading () ;
println () ;
}
boolean
#ifdef HAVE_PROTOTYPES
checkoutervalidity ( void )
#else
checkoutervalidity ( )
#endif
{
register boolean Result; halfword p ;
if ( scannerstatus == 0 )
Result = true ;
else if ( scannerstatus == 7 )
if ( cursym != 0 )
Result = true ;
else {
deletionsallowed = false ;
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 640 ) ;
}
printint ( warninginfo ) ;
{
helpptr = 2 ;
helpline [1 ]= 641 ;
helpline [0 ]= 642 ;
}
cursym = 9768 ;
inserror () ;
deletionsallowed = true ;
Result = false ;
}
else {
deletionsallowed = false ;
if ( cursym != 0 )
{
p = getavail () ;
mem [p ].hhfield .lhfield = cursym ;
begintokenlist ( p , 19 ) ;
}
if ( scannerstatus > 1 )
{
runaway () ;
if ( cursym == 0 )
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 643 ) ;
}
else {
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 644 ) ;
}
}
print ( 645 ) ;
{
helpptr = 4 ;
helpline [3 ]= 646 ;
helpline [2 ]= 647 ;
helpline [1 ]= 648 ;
helpline [0 ]= 649 ;
}
switch ( scannerstatus )
{case 2 :
{
print ( 650 ) ;
helpline [3 ]= 651 ;
cursym = 9763 ;
}
break ;
case 3 :
{
print ( 652 ) ;
helpline [3 ]= 653 ;
if ( warninginfo == 0 )
cursym = 9767 ;
else {
cursym = 9759 ;
eqtb [9759 ].v.RH = warninginfo ;
}
}
break ;
case 4 :
case 5 :
{
print ( 654 ) ;
if ( scannerstatus == 5 )
print ( hash [warninginfo ].v.RH ) ;
else printvariablename ( warninginfo ) ;
cursym = 9765 ;
}
break ;
case 6 :
{
print ( 655 ) ;
print ( hash [warninginfo ].v.RH ) ;
print ( 656 ) ;
helpline [3 ]= 657 ;
cursym = 9764 ;
}
break ;
}
inserror () ;
}
else {
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 635 ) ;
}
printint ( warninginfo ) ;
{
helpptr = 3 ;
helpline [2 ]= 636 ;
helpline [1 ]= 637 ;
helpline [0 ]= 638 ;
}
if ( cursym == 0 )
helpline [2 ]= 639 ;
cursym = 9766 ;
inserror () ;
}
deletionsallowed = true ;
Result = false ;
}
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
getnext ( void )
#else
getnext ( )
#endif
{
/* 20 10 50 40 25 85 86 87 30 */ integer k ;
ASCIIcode c ;
ASCIIcode class ;
integer n, f ;
lab20: cursym = 0 ;
if ( ( curinput .indexfield <= 15 ) )
{
lab25: c = buffer [curinput .locfield ];
incr ( curinput .locfield ) ;
class = charclass [c ];
switch ( class )
{case 0 :
goto lab85 ;
break ;
case 1 :
{
class = charclass [buffer [curinput .locfield ]];
if ( class > 1 )
goto lab25 ;
else if ( class < 1 )
{
n = 0 ;
goto lab86 ;
}
}
break ;
case 2 :
goto lab25 ;
break ;
case 3 :
{
if ( scannerstatus == 7 )
if ( curinput .locfield < curinput .limitfield )
goto lab25 ;
if ( curinput .namefield > 2 )
{
incr ( linestack [curinput .indexfield ]) ;
first = curinput .startfield ;
if ( ! forceeof )
{
if ( inputln ( inputfile [curinput .indexfield ], true ) )
firmuptheline () ;
else forceeof = true ;
}
if ( forceeof )
{
forceeof = false ;
decr ( curinput .locfield ) ;
if ( ( mpxname [curinput .indexfield ]> 1 ) )
{
mpxname [curinput .indexfield ]= 0 ;
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 676 ) ;
}
{
helpptr = 4 ;
helpline [3 ]= 677 ;
helpline [2 ]= 632 ;
helpline [1 ]= 678 ;
helpline [0 ]= 679 ;
}
deletionsallowed = false ;
error () ;
deletionsallowed = true ;
cursym = 9769 ;
goto lab50 ;
}
else {
printchar ( 41 ) ;
decr ( openparens ) ;
fflush ( stdout ) ;
endfilereading () ;
if ( checkoutervalidity () )
goto lab20 ;
else goto lab20 ;
}
}
buffer [curinput .limitfield ]= 37 ;
first = curinput .limitfield + 1 ;
curinput .locfield = curinput .startfield ;
}
else {
if ( inputptr > 0 )
{
endfilereading () ;
goto lab20 ;
}
if ( selector < 9 )
openlogfile () ;
if ( interaction > 1 )
{
if ( curinput .limitfield == curinput .startfield )
printnl ( 674 ) ;
println () ;
first = curinput .startfield ;
{
;
print ( 42 ) ;
terminput () ;
}
curinput .limitfield = last ;
buffer [curinput .limitfield ]= 37 ;
first = curinput .limitfield + 1 ;
curinput .locfield = curinput .startfield ;
}
else fatalerror ( 675 ) ;
}
{
if ( interrupt != 0 )
pauseforinstructions () ;
}
goto lab25 ;
}
break ;
case 4 :
if ( scannerstatus == 7 )
goto lab25 ;
else {
if ( buffer [curinput .locfield ]== 34 )
curmod = 284 ;
else {
k = curinput .locfield ;
buffer [curinput .limitfield + 1 ]= 34 ;
do {
incr ( curinput .locfield ) ;
} while ( ! ( buffer [curinput .locfield ]== 34 ) ) ;
if ( curinput .locfield > curinput .limitfield )
{
curinput .locfield = curinput .limitfield ;
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 665 ) ;
}
{
helpptr = 3 ;
helpline [2 ]= 666 ;
helpline [1 ]= 667 ;
helpline [0 ]= 668 ;
}
deletionsallowed = false ;
error () ;
deletionsallowed = true ;
goto lab20 ;
}
if ( curinput .locfield == k + 1 )
curmod = buffer [k ];
else {
{
if ( poolptr + curinput .locfield - k > maxpoolptr )
if ( poolptr + curinput .locfield - k > poolsize )
docompaction ( curinput .locfield - k ) ;
else maxpoolptr = poolptr + curinput .locfield - k ;
}
do {
{
strpool [poolptr ]= buffer [k ];
incr ( poolptr ) ;
}
incr ( k ) ;
} while ( ! ( k == curinput .locfield ) ) ;
curmod = makestring () ;
}
}
incr ( curinput .locfield ) ;
curcmd = 41 ;
goto lab10 ;
}
break ;
case 5 :
case 6 :
case 7 :
case 8 :
{
k = curinput .locfield - 1 ;
goto lab40 ;
}
break ;
case 20 :
if ( scannerstatus == 7 )
goto lab25 ;
else {
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 662 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 663 ;
helpline [0 ]= 664 ;
}
deletionsallowed = false ;
error () ;
deletionsallowed = true ;
goto lab20 ;
}
break ;
default:
;
break ;
}
k = curinput .locfield - 1 ;
while ( charclass [buffer [curinput .locfield ]]== class ) incr (
curinput .locfield ) ;
goto lab40 ;
lab85: n = c - 48 ;
while ( charclass [buffer [curinput .locfield ]]== 0 ) {
if ( n < 32768L )
n = 10 * n + buffer [curinput .locfield ]- 48 ;
incr ( curinput .locfield ) ;
}
if ( buffer [curinput .locfield ]== 46 )
if ( charclass [buffer [curinput .locfield + 1 ]]== 0 )
goto lab30 ;
f = 0 ;
goto lab87 ;
lab30: incr ( curinput .locfield ) ;
lab86: k = 0 ;
do {
if ( k < 17 )
{
dig [k ]= buffer [curinput .locfield ]- 48 ;
incr ( k ) ;
}
incr ( curinput .locfield ) ;
} while ( ! ( charclass [buffer [curinput .locfield ]]!= 0 ) ) ;
f = rounddecimals ( k ) ;
if ( f == 65536L )
{
incr ( n ) ;
f = 0 ;
}
lab87: if ( n < 32768L )
{
curmod = n * 65536L + f ;
if ( curmod >= 268435456L )
if ( ( internal [30 ]> 0 ) && ( scannerstatus != 7 ) )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 672 ) ;
}
printscaled ( curmod ) ;
printchar ( 41 ) ;
{
helpptr = 3 ;
helpline [2 ]= 673 ;
helpline [1 ]= 605 ;
helpline [0 ]= 606 ;
}
error () ;
}
}
else if ( scannerstatus != 7 )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 669 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 670 ;
helpline [0 ]= 671 ;
}
deletionsallowed = false ;
error () ;
deletionsallowed = true ;
curmod = 2147483647L ;
}
curcmd = 44 ;
goto lab10 ;
lab40: cursym = idlookup ( k , curinput .locfield - k ) ;
}
else if ( curinput .locfield >= himemmin )
{
cursym = mem [curinput .locfield ].hhfield .lhfield ;
curinput .locfield = mem [curinput .locfield ].hhfield .v.RH ;
if ( cursym >= 9772 )
if ( cursym >= 9922 )
{
if ( cursym >= 10072 )
cursym = cursym - 150 ;
begintokenlist ( paramstack [curinput .limitfield + cursym - ( 9922 ) ]
, 18 ) ;
goto lab20 ;
}
else {
curcmd = 40 ;
curmod = paramstack [curinput .limitfield + cursym - ( 9772 ) ];
cursym = 0 ;
goto lab10 ;
}
}
else if ( curinput .locfield > 0 )
{
if ( mem [curinput .locfield ].hhfield .b1 == 15 )
{
curmod = mem [curinput .locfield + 1 ].cint ;
if ( mem [curinput .locfield ].hhfield .b0 == 16 )
curcmd = 44 ;
else {
curcmd = 41 ;
{
if ( strref [curmod ]< 127 )
incr ( strref [curmod ]) ;
}
}
}
else {
curmod = curinput .locfield ;
curcmd = 40 ;
}
curinput .locfield = mem [curinput .locfield ].hhfield .v.RH ;
goto lab10 ;
}
else {
endtokenlist () ;
goto lab20 ;
}
lab50: curcmd = eqtb [cursym ].lhfield ;
curmod = eqtb [cursym ].v.RH ;
if ( curcmd >= 85 )
if ( checkoutervalidity () )
curcmd = curcmd - 85 ;
else goto lab20 ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
firmuptheline ( void )
#else
firmuptheline ( )
#endif
{
integer k ;
curinput .limitfield = last ;
if ( internal [24 ]> 0 )
if ( interaction > 1 )
{
;
println () ;
if ( curinput .startfield < curinput .limitfield )
{register integer for_end; k = curinput .startfield ;for_end = curinput
.limitfield - 1 ; if ( k <= for_end) do
print ( buffer [k ]) ;
while ( k++ < for_end ) ;}
first = curinput .limitfield ;
{
;
print ( 680 ) ;
terminput () ;
}
if ( last > first )
{
{register integer for_end; k = first ;for_end = last - 1 ; if ( k <=
for_end) do
buffer [k + curinput .startfield - first ]= buffer [k ];
while ( k++ < for_end ) ;}
curinput .limitfield = curinput .startfield + last - first ;
}
}
}
void
#ifdef HAVE_PROTOTYPES
tnext ( void )
#else
tnext ( )
#endif
{
/* 65 50 */ char oldstatus ;
integer oldinfo ;
while ( curcmd <= 3 ) {
if ( curcmd == 3 )
if ( ! ( curinput .indexfield <= 15 ) || ( mpxname [curinput .indexfield
]== 1 ) )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 690 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 691 ;
helpline [0 ]= 692 ;
}
error () ;
}
else {
endmpxreading () ;
goto lab65 ;
}
else if ( curcmd == 1 )
if ( ( curinput .indexfield > 15 ) || ( curinput .namefield <= 2 ) )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 686 ) ;
}
{
helpptr = 3 ;
helpline [2 ]= 687 ;
helpline [1 ]= 688 ;
helpline [0 ]= 689 ;
}
error () ;
}
else if ( ( mpxname [curinput .indexfield ]> 1 ) )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 683 ) ;
}
{
helpptr = 4 ;
helpline [3 ]= 631 ;
helpline [2 ]= 632 ;
helpline [1 ]= 684 ;
helpline [0 ]= 685 ;
}
error () ;
}
else if ( ( curmod != 1 ) && ( mpxname [curinput .indexfield ]!= 0 ) )
{
if ( ! beginmpxreading () )
startmpxinput () ;
}
else goto lab65 ;
else {
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 693 ) ;
}
{
helpptr = 1 ;
helpline [0 ]= 694 ;
}
error () ;
}
goto lab50 ;
lab65: oldstatus = scannerstatus ;
oldinfo = warninginfo ;
scannerstatus = 7 ;
warninginfo = linestack [curinput .indexfield ];
do {
getnext () ;
} while ( ! ( curcmd == 2 ) ) ;
scannerstatus = oldstatus ;
warninginfo = oldinfo ;
lab50: getnext () ;
}
}
halfword
#ifdef HAVE_PROTOTYPES
zscantoks ( commandcode terminator , halfword substlist , halfword tailend ,
smallnumber suffixcount )
#else
zscantoks ( terminator , substlist , tailend , suffixcount )
commandcode terminator ;
halfword substlist ;
halfword tailend ;
smallnumber suffixcount ;
#endif
{
/* 30 40 */ register halfword Result; halfword p ;
halfword q ;
integer balance ;
p = memtop - 2 ;
balance = 1 ;
mem [memtop - 2 ].hhfield .v.RH = 0 ;
while ( true ) {
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
if ( cursym > 0 )
{
{
q = substlist ;
while ( q != 0 ) {
if ( mem [q ].hhfield .lhfield == cursym )
{
cursym = mem [q + 1 ].cint ;
curcmd = 10 ;
goto lab40 ;
}
q = mem [q ].hhfield .v.RH ;
}
lab40: ;
}
if ( curcmd == terminator )
if ( curmod > 0 )
incr ( balance ) ;
else {
decr ( balance ) ;
if ( balance == 0 )
goto lab30 ;
}
else if ( curcmd == 63 )
{
if ( curmod == 0 )
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
else if ( curmod <= suffixcount )
cursym = 9921 + curmod ;
}
}
mem [p ].hhfield .v.RH = curtok () ;
p = mem [p ].hhfield .v.RH ;
}
lab30: mem [p ].hhfield .v.RH = tailend ;
flushnodelist ( substlist ) ;
Result = mem [memtop - 2 ].hhfield .v.RH ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
getsymbol ( void )
#else
getsymbol ( )
#endif
{
/* 20 */ lab20: {
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
if ( ( cursym == 0 ) || ( cursym > 9757 ) )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 706 ) ;
}
{
helpptr = 3 ;
helpline [2 ]= 707 ;
helpline [1 ]= 708 ;
helpline [0 ]= 709 ;
}
if ( cursym > 0 )
helpline [2 ]= 710 ;
else if ( curcmd == 41 )
{
if ( strref [curmod ]< 127 )
if ( strref [curmod ]> 1 )
decr ( strref [curmod ]) ;
else flushstring ( curmod ) ;
}
cursym = 9757 ;
inserror () ;
goto lab20 ;
}
}
void
#ifdef HAVE_PROTOTYPES
getclearsymbol ( void )
#else
getclearsymbol ( )
#endif
{
getsymbol () ;
clearsymbol ( cursym , false ) ;
}
void
#ifdef HAVE_PROTOTYPES
checkequals ( void )
#else
checkequals ( )
#endif
{
if ( curcmd != 53 )
if ( curcmd != 76 )
{
missingerr ( 61 ) ;
{
helpptr = 5 ;
helpline [4 ]= 711 ;
helpline [3 ]= 712 ;
helpline [2 ]= 713 ;
helpline [1 ]= 714 ;
helpline [0 ]= 715 ;
}
backerror () ;
}
}
void
#ifdef HAVE_PROTOTYPES
makeopdef ( void )
#else
makeopdef ( )
#endif
{
commandcode m ;
halfword p, q, r ;
m = curmod ;
getsymbol () ;
q = getnode ( 2 ) ;
mem [q ].hhfield .lhfield = cursym ;
mem [q + 1 ].cint = 9772 ;
getclearsymbol () ;
warninginfo = cursym ;
getsymbol () ;
p = getnode ( 2 ) ;
mem [p ].hhfield .lhfield = cursym ;
mem [p + 1 ].cint = 9773 ;
mem [p ].hhfield .v.RH = q ;
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
checkequals () ;
scannerstatus = 5 ;
q = getavail () ;
mem [q ].hhfield .lhfield = 0 ;
r = getavail () ;
mem [q ].hhfield .v.RH = r ;
mem [r ].hhfield .lhfield = 0 ;
mem [r ].hhfield .v.RH = scantoks ( 18 , p , 0 , 0 ) ;
scannerstatus = 0 ;
eqtb [warninginfo ].lhfield = m ;
eqtb [warninginfo ].v.RH = q ;
getxnext () ;
}
void
#ifdef HAVE_PROTOTYPES
zcheckdelimiter ( halfword ldelim , halfword rdelim )
#else
zcheckdelimiter ( ldelim , rdelim )
halfword ldelim ;
halfword rdelim ;
#endif
{
/* 10 */ if ( curcmd == 64 )
if ( curmod == ldelim )
goto lab10 ;
if ( cursym != rdelim )
{
missingerr ( hash [rdelim ].v.RH ) ;
{
helpptr = 2 ;
helpline [1 ]= 970 ;
helpline [0 ]= 971 ;
}
backerror () ;
}
else {
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 972 ) ;
}
print ( hash [rdelim ].v.RH ) ;
print ( 973 ) ;
{
helpptr = 3 ;
helpline [2 ]= 974 ;
helpline [1 ]= 975 ;
helpline [0 ]= 976 ;
}
error () ;
}
lab10: ;
}
halfword
#ifdef HAVE_PROTOTYPES
scandeclaredvariable ( void )
#else
scandeclaredvariable ( )
#endif
{
/* 30 */ register halfword Result; halfword x ;
halfword h, t ;
halfword l ;
getsymbol () ;
x = cursym ;
if ( curcmd != 43 )
clearsymbol ( x , false ) ;
h = getavail () ;
mem [h ].hhfield .lhfield = x ;
t = h ;
while ( true ) {
getxnext () ;
if ( cursym == 0 )
goto lab30 ;
if ( curcmd != 43 )
if ( curcmd != 42 )
if ( curcmd == 65 )
{
l = cursym ;
getxnext () ;
if ( curcmd != 66 )
{
backinput () ;
cursym = l ;
curcmd = 65 ;
goto lab30 ;
}
else cursym = 0 ;
}
else goto lab30 ;
mem [t ].hhfield .v.RH = getavail () ;
t = mem [t ].hhfield .v.RH ;
mem [t ].hhfield .lhfield = cursym ;
}
lab30: if ( eqtb [x ].lhfield != 43 )
clearsymbol ( x , false ) ;
if ( eqtb [x ].v.RH == 0 )
newroot ( x ) ;
Result = h ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
scandef ( void )
#else
scandef ( )
#endif
{
char m ;
char n ;
unsigned char k ;
char c ;
halfword r ;
halfword q ;
halfword p ;
halfword base ;
halfword ldelim, rdelim ;
m = curmod ;
c = 0 ;
mem [memtop - 2 ].hhfield .v.RH = 0 ;
q = getavail () ;
mem [q ].hhfield .lhfield = 0 ;
r = 0 ;
if ( m == 1 )
{
getclearsymbol () ;
warninginfo = cursym ;
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
scannerstatus = 5 ;
n = 0 ;
eqtb [warninginfo ].lhfield = 13 ;
eqtb [warninginfo ].v.RH = q ;
}
else {
p = scandeclaredvariable () ;
flushvariable ( eqtb [mem [p ].hhfield .lhfield ].v.RH , mem [p ]
.hhfield .v.RH , true ) ;
warninginfo = findvariable ( p ) ;
flushlist ( p ) ;
if ( warninginfo == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 722 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 723 ;
helpline [0 ]= 724 ;
}
error () ;
warninginfo = 22 ;
}
scannerstatus = 4 ;
n = 2 ;
if ( curcmd == 63 )
if ( curmod == 3 )
{
n = 3 ;
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
}
mem [warninginfo ].hhfield .b0 = 20 + n ;
mem [warninginfo + 1 ].cint = q ;
}
k = n ;
if ( curcmd == 33 )
do {
ldelim = cursym ;
rdelim = curmod ;
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
if ( ( curcmd == 58 ) && ( curmod >= 9772 ) )
base = curmod ;
else {
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 725 ) ;
}
{
helpptr = 1 ;
helpline [0 ]= 726 ;
}
backerror () ;
base = 9772 ;
}
do {
mem [q ].hhfield .v.RH = getavail () ;
q = mem [q ].hhfield .v.RH ;
mem [q ].hhfield .lhfield = base + k ;
getsymbol () ;
p = getnode ( 2 ) ;
mem [p + 1 ].cint = base + k ;
mem [p ].hhfield .lhfield = cursym ;
if ( k == 150 )
overflow ( 727 , 150 ) ;
incr ( k ) ;
mem [p ].hhfield .v.RH = r ;
r = p ;
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
} while ( ! ( curcmd != 81 ) ) ;
checkdelimiter ( ldelim , rdelim ) ;
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
} while ( ! ( curcmd != 33 ) ) ;
if ( curcmd == 58 )
{
p = getnode ( 2 ) ;
if ( curmod < 9772 )
{
c = curmod ;
mem [p + 1 ].cint = 9772 + k ;
}
else {
mem [p + 1 ].cint = curmod + k ;
if ( curmod == 9772 )
c = 4 ;
else if ( curmod == 9922 )
c = 6 ;
else c = 7 ;
}
if ( k == 150 )
overflow ( 727 , 150 ) ;
incr ( k ) ;
getsymbol () ;
mem [p ].hhfield .lhfield = cursym ;
mem [p ].hhfield .v.RH = r ;
r = p ;
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
if ( c == 4 )
if ( curcmd == 70 )
{
c = 5 ;
p = getnode ( 2 ) ;
if ( k == 150 )
overflow ( 727 , 150 ) ;
mem [p + 1 ].cint = 9772 + k ;
getsymbol () ;
mem [p ].hhfield .lhfield = cursym ;
mem [p ].hhfield .v.RH = r ;
r = p ;
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
}
}
checkequals () ;
p = getavail () ;
mem [p ].hhfield .lhfield = c ;
mem [q ].hhfield .v.RH = p ;
if ( m == 1 )
mem [p ].hhfield .v.RH = scantoks ( 18 , r , 0 , n ) ;
else {
q = getavail () ;
mem [q ].hhfield .lhfield = bgloc ;
mem [p ].hhfield .v.RH = q ;
p = getavail () ;
mem [p ].hhfield .lhfield = egloc ;
mem [q ].hhfield .v.RH = scantoks ( 18 , r , p , n ) ;
}
if ( warninginfo == 22 )
flushtokenlist ( mem [23 ].cint ) ;
scannerstatus = 0 ;
getxnext () ;
}
void
#ifdef HAVE_PROTOTYPES
zprintmacroname ( halfword a , halfword n )
#else
zprintmacroname ( a , n )
halfword a ;
halfword n ;
#endif
{
halfword p, q ;
if ( n != 0 )
print ( hash [n ].v.RH ) ;
else {
p = mem [a ].hhfield .lhfield ;
if ( p == 0 )
print ( hash [mem [mem [mem [a ].hhfield .v.RH ].hhfield .lhfield ]
.hhfield .lhfield ].v.RH ) ;
else {
q = p ;
while ( mem [q ].hhfield .v.RH != 0 ) q = mem [q ].hhfield .v.RH ;
mem [q ].hhfield .v.RH = mem [mem [a ].hhfield .v.RH ].hhfield
.lhfield ;
showtokenlist ( p , 0 , 1000 , 0 ) ;
mem [q ].hhfield .v.RH = 0 ;
}
}
}
void
#ifdef HAVE_PROTOTYPES
zprintarg ( halfword q , integer n , halfword b )
#else
zprintarg ( q , n , b )
halfword q ;
integer n ;
halfword b ;
#endif
{
if ( mem [q ].hhfield .v.RH == 1 )
printnl ( 510 ) ;
else if ( ( b < 10072 ) && ( b != 7 ) )
printnl ( 511 ) ;
else printnl ( 512 ) ;
printint ( n ) ;
print ( 743 ) ;
if ( mem [q ].hhfield .v.RH == 1 )
printexp ( q , 1 ) ;
else showtokenlist ( q , 0 , 1000 , 0 ) ;
}
void
#ifdef HAVE_PROTOTYPES
zscantextarg ( halfword ldelim , halfword rdelim )
#else
zscantextarg ( ldelim , rdelim )
halfword ldelim ;
halfword rdelim ;
#endif
{
/* 30 */ integer balance ;
halfword p ;
warninginfo = ldelim ;
scannerstatus = 3 ;
p = memtop - 2 ;
balance = 1 ;
mem [memtop - 2 ].hhfield .v.RH = 0 ;
while ( true ) {
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
if ( ldelim == 0 )
{
if ( curcmd > 81 )
{
if ( balance == 1 )
goto lab30 ;
else if ( curcmd == 83 )
decr ( balance ) ;
}
else if ( curcmd == 34 )
incr ( balance ) ;
}
else {
if ( curcmd == 64 )
{
if ( curmod == ldelim )
{
decr ( balance ) ;
if ( balance == 0 )
goto lab30 ;
}
}
else if ( curcmd == 33 )
if ( curmod == rdelim )
incr ( balance ) ;
}
mem [p ].hhfield .v.RH = curtok () ;
p = mem [p ].hhfield .v.RH ;
}
lab30: curexp = mem [memtop - 2 ].hhfield .v.RH ;
curtype = 20 ;
scannerstatus = 0 ;
}
void
#ifdef HAVE_PROTOTYPES
zmacrocall ( halfword defref , halfword arglist , halfword macroname )
#else
zmacrocall ( defref , arglist , macroname )
halfword defref ;
halfword arglist ;
halfword macroname ;
#endif
{
/* 40 */ halfword r ;
halfword p, q ;
integer n ;
halfword ldelim, rdelim ;
halfword tail ;
r = mem [defref ].hhfield .v.RH ;
incr ( mem [defref ].hhfield .lhfield ) ;
if ( arglist == 0 )
n = 0 ;
else {
n = 1 ;
tail = arglist ;
while ( mem [tail ].hhfield .v.RH != 0 ) {
incr ( n ) ;
tail = mem [tail ].hhfield .v.RH ;
}
}
if ( internal [8 ]> 0 )
{
begindiagnostic () ;
println () ;
printmacroname ( arglist , macroname ) ;
if ( n == 3 )
print ( 705 ) ;
showmacro ( defref , 0 , 100000L ) ;
if ( arglist != 0 )
{
n = 0 ;
p = arglist ;
do {
q = mem [p ].hhfield .lhfield ;
printarg ( q , n , 0 ) ;
incr ( n ) ;
p = mem [p ].hhfield .v.RH ;
} while ( ! ( p == 0 ) ) ;
}
enddiagnostic ( false ) ;
}
curcmd = 82 ;
while ( mem [r ].hhfield .lhfield >= 9772 ) {
if ( curcmd != 81 )
{
getxnext () ;
if ( curcmd != 33 )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 749 ) ;
}
printmacroname ( arglist , macroname ) ;
{
helpptr = 3 ;
helpline [2 ]= 750 ;
helpline [1 ]= 751 ;
helpline [0 ]= 752 ;
}
if ( mem [r ].hhfield .lhfield >= 9922 )
{
curexp = 0 ;
curtype = 20 ;
}
else {
curexp = 0 ;
curtype = 16 ;
}
backerror () ;
curcmd = 64 ;
goto lab40 ;
}
ldelim = cursym ;
rdelim = curmod ;
}
if ( mem [r ].hhfield .lhfield >= 10072 )
scantextarg ( ldelim , rdelim ) ;
else {
getxnext () ;
if ( mem [r ].hhfield .lhfield >= 9922 )
scansuffix () ;
else scanexpression () ;
}
if ( curcmd != 81 )
if ( ( curcmd != 64 ) || ( curmod != ldelim ) )
if ( mem [mem [r ].hhfield .v.RH ].hhfield .lhfield >= 9772 )
{
missingerr ( 44 ) ;
{
helpptr = 3 ;
helpline [2 ]= 753 ;
helpline [1 ]= 754 ;
helpline [0 ]= 748 ;
}
backerror () ;
curcmd = 81 ;
}
else {
missingerr ( hash [rdelim ].v.RH ) ;
{
helpptr = 2 ;
helpline [1 ]= 755 ;
helpline [0 ]= 748 ;
}
backerror () ;
}
lab40: {
p = getavail () ;
if ( curtype == 20 )
mem [p ].hhfield .lhfield = curexp ;
else mem [p ].hhfield .lhfield = stashcurexp () ;
if ( internal [8 ]> 0 )
{
begindiagnostic () ;
printarg ( mem [p ].hhfield .lhfield , n , mem [r ].hhfield
.lhfield ) ;
enddiagnostic ( false ) ;
}
if ( arglist == 0 )
arglist = p ;
else mem [tail ].hhfield .v.RH = p ;
tail = p ;
incr ( n ) ;
}
r = mem [r ].hhfield .v.RH ;
}
if ( curcmd == 81 )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 744 ) ;
}
printmacroname ( arglist , macroname ) ;
printchar ( 59 ) ;
printnl ( 745 ) ;
print ( hash [rdelim ].v.RH ) ;
print ( 299 ) ;
{
helpptr = 3 ;
helpline [2 ]= 746 ;
helpline [1 ]= 747 ;
helpline [0 ]= 748 ;
}
error () ;
}
if ( mem [r ].hhfield .lhfield != 0 )
{
if ( mem [r ].hhfield .lhfield < 7 )
{
getxnext () ;
if ( mem [r ].hhfield .lhfield != 6 )
if ( ( curcmd == 53 ) || ( curcmd == 76 ) )
getxnext () ;
}
switch ( mem [r ].hhfield .lhfield )
{case 1 :
scanprimary () ;
break ;
case 2 :
scansecondary () ;
break ;
case 3 :
scantertiary () ;
break ;
case 4 :
scanexpression () ;
break ;
case 5 :
{
scanexpression () ;
p = getavail () ;
mem [p ].hhfield .lhfield = stashcurexp () ;
if ( internal [8 ]> 0 )
{
begindiagnostic () ;
printarg ( mem [p ].hhfield .lhfield , n , 0 ) ;
enddiagnostic ( false ) ;
}
if ( arglist == 0 )
arglist = p ;
else mem [tail ].hhfield .v.RH = p ;
tail = p ;
incr ( n ) ;
if ( curcmd != 70 )
{
missingerr ( 489 ) ;
print ( 756 ) ;
printmacroname ( arglist , macroname ) ;
{
helpptr = 1 ;
helpline [0 ]= 757 ;
}
backerror () ;
}
getxnext () ;
scanprimary () ;
}
break ;
case 6 :
{
if ( curcmd != 33 )
ldelim = 0 ;
else {
ldelim = cursym ;
rdelim = curmod ;
getxnext () ;
}
scansuffix () ;
if ( ldelim != 0 )
{
if ( ( curcmd != 64 ) || ( curmod != ldelim ) )
{
missingerr ( hash [rdelim ].v.RH ) ;
{
helpptr = 2 ;
helpline [1 ]= 755 ;
helpline [0 ]= 748 ;
}
backerror () ;
}
getxnext () ;
}
}
break ;
case 7 :
scantextarg ( 0 , 0 ) ;
break ;
}
backinput () ;
{
p = getavail () ;
if ( curtype == 20 )
mem [p ].hhfield .lhfield = curexp ;
else mem [p ].hhfield .lhfield = stashcurexp () ;
if ( internal [8 ]> 0 )
{
begindiagnostic () ;
printarg ( mem [p ].hhfield .lhfield , n , mem [r ].hhfield
.lhfield ) ;
enddiagnostic ( false ) ;
}
if ( arglist == 0 )
arglist = p ;
else mem [tail ].hhfield .v.RH = p ;
tail = p ;
incr ( n ) ;
}
}
r = mem [r ].hhfield .v.RH ;
while ( ( curinput .indexfield > 15 ) && ( curinput .locfield == 0 ) )
endtokenlist () ;
if ( paramptr + n > maxparamstack )
{
maxparamstack = paramptr + n ;
if ( maxparamstack > 150 )
overflow ( 727 , 150 ) ;
}
begintokenlist ( defref , 21 ) ;
curinput .namefield = macroname ;
curinput .locfield = r ;
if ( n > 0 )
{
p = arglist ;
do {
paramstack [paramptr ]= mem [p ].hhfield .lhfield ;
incr ( paramptr ) ;
p = mem [p ].hhfield .v.RH ;
} while ( ! ( p == 0 ) ) ;
flushlist ( arglist ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
expand ( void )
#else
expand ( )
#endif
{
halfword p ;
integer k ;
poolpointer j ;
if ( internal [6 ]> 65536L )
if ( curcmd != 13 )
showcmdmod ( curcmd , curmod ) ;
switch ( curcmd )
{case 4 :
conditional () ;
break ;
case 5 :
if ( curmod > iflimit )
if ( iflimit == 1 )
{
missingerr ( 58 ) ;
backinput () ;
cursym = 9762 ;
inserror () ;
}
else {
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 764 ) ;
}
printcmdmod ( 5 , curmod ) ;
{
helpptr = 1 ;
helpline [0 ]= 765 ;
}
error () ;
}
else {
while ( curmod != 2 ) passtext () ;
{
p = condptr ;
ifline = mem [p + 1 ].cint ;
curif = mem [p ].hhfield .b1 ;
iflimit = mem [p ].hhfield .b0 ;
condptr = mem [p ].hhfield .v.RH ;
freenode ( p , 2 ) ;
}
}
break ;
case 6 :
if ( curmod > 0 )
forceeof = true ;
else startinput () ;
break ;
case 7 :
if ( curmod == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 728 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 729 ;
helpline [0 ]= 730 ;
}
error () ;
}
else beginiteration () ;
break ;
case 8 :
{
while ( ( curinput .indexfield > 15 ) && ( curinput .locfield == 0 ) )
endtokenlist () ;
if ( loopptr == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 732 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 733 ;
helpline [0 ]= 734 ;
}
error () ;
}
else resumeiteration () ;
}
break ;
case 9 :
{
getboolean () ;
if ( internal [6 ]> 65536L )
showcmdmod ( 35 , curexp ) ;
if ( curexp == 30 )
if ( loopptr == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 735 ) ;
}
{
helpptr = 1 ;
helpline [0 ]= 736 ;
}
if ( curcmd == 82 )
error () ;
else backerror () ;
}
else {
p = 0 ;
do {
if ( ( curinput .indexfield <= 15 ) )
endfilereading () ;
else {
if ( curinput .indexfield <= 17 )
p = curinput .startfield ;
endtokenlist () ;
}
} while ( ! ( p != 0 ) ) ;
if ( p != mem [loopptr ].hhfield .lhfield )
fatalerror ( 739 ) ;
stopiteration () ;
}
else if ( curcmd != 82 )
{
missingerr ( 59 ) ;
{
helpptr = 2 ;
helpline [1 ]= 737 ;
helpline [0 ]= 738 ;
}
backerror () ;
}
}
break ;
case 10 :
;
break ;
case 12 :
{
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
p = curtok () ;
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
if ( curcmd < 14 )
expand () ;
else backinput () ;
begintokenlist ( p , 19 ) ;
}
break ;
case 11 :
{
getxnext () ;
scanprimary () ;
if ( curtype != 4 )
{
disperr ( 0 , 740 ) ;
{
helpptr = 2 ;
helpline [1 ]= 741 ;
helpline [0 ]= 742 ;
}
putgetflusherror ( 0 ) ;
}
else {
backinput () ;
if ( ( strstart [nextstr [curexp ]]- strstart [curexp ]) > 0 )
{
beginfilereading () ;
curinput .namefield = 2 ;
k = first + ( strstart [nextstr [curexp ]]- strstart [curexp ]
) ;
if ( k >= maxbufstack )
{
if ( k >= bufsize )
{
maxbufstack = bufsize ;
overflow ( 256 , bufsize ) ;
}
maxbufstack = k + 1 ;
}
j = strstart [curexp ];
curinput .limitfield = k ;
while ( first < curinput .limitfield ) {
buffer [first ]= strpool [j ];
incr ( j ) ;
incr ( first ) ;
}
buffer [curinput .limitfield ]= 37 ;
first = curinput .limitfield + 1 ;
curinput .locfield = curinput .startfield ;
flushcurexp ( 0 ) ;
}
}
}
break ;
case 13 :
macrocall ( curmod , 0 , cursym ) ;
break ;
}
}
void
#ifdef HAVE_PROTOTYPES
getxnext ( void )
#else
getxnext ( )
#endif
{
halfword saveexp ;
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
if ( curcmd < 14 )
{
saveexp = stashcurexp () ;
do {
if ( curcmd == 13 )
macrocall ( curmod , 0 , cursym ) ;
else expand () ;
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
} while ( ! ( curcmd >= 14 ) ) ;
unstashcurexp ( saveexp ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zstackargument ( halfword p )
#else
zstackargument ( p )
halfword p ;
#endif
{
if ( paramptr == maxparamstack )
{
incr ( maxparamstack ) ;
if ( maxparamstack > 150 )
overflow ( 727 , 150 ) ;
}
paramstack [paramptr ]= p ;
incr ( paramptr ) ;
}
void
#ifdef HAVE_PROTOTYPES
passtext ( void )
#else
passtext ( )
#endif
{
/* 30 */ integer l ;
scannerstatus = 1 ;
l = 0 ;
warninginfo = trueline () ;
while ( true ) {
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
if ( curcmd <= 5 )
if ( curcmd < 5 )
incr ( l ) ;
else {
if ( l == 0 )
goto lab30 ;
if ( curmod == 2 )
decr ( l ) ;
}
else if ( curcmd == 41 )
{
if ( strref [curmod ]< 127 )
if ( strref [curmod ]> 1 )
decr ( strref [curmod ]) ;
else flushstring ( curmod ) ;
}
}
lab30: scannerstatus = 0 ;
}
void
#ifdef HAVE_PROTOTYPES
zchangeiflimit ( smallnumber l , halfword p )
#else
zchangeiflimit ( l , p )
smallnumber l ;
halfword p ;
#endif
{
/* 10 */ halfword q ;
if ( p == condptr )
iflimit = l ;
else {
q = condptr ;
while ( true ) {
if ( q == 0 )
confusion ( 758 ) ;
if ( mem [q ].hhfield .v.RH == p )
{
mem [q ].hhfield .b0 = l ;
goto lab10 ;
}
q = mem [q ].hhfield .v.RH ;
}
}
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
checkcolon ( void )
#else
checkcolon ( )
#endif
{
if ( curcmd != 80 )
{
missingerr ( 58 ) ;
{
helpptr = 2 ;
helpline [1 ]= 761 ;
helpline [0 ]= 738 ;
}
backerror () ;
}
}
void
#ifdef HAVE_PROTOTYPES
conditional ( void )
#else
conditional ( )
#endif
{
/* 10 30 21 40 */ halfword savecondptr ;
char newiflimit ;
halfword p ;
{
p = getnode ( 2 ) ;
mem [p ].hhfield .v.RH = condptr ;
mem [p ].hhfield .b0 = iflimit ;
mem [p ].hhfield .b1 = curif ;
mem [p + 1 ].cint = ifline ;
condptr = p ;
iflimit = 1 ;
ifline = trueline () ;
curif = 1 ;
}
savecondptr = condptr ;
lab21: getboolean () ;
newiflimit = 4 ;
if ( internal [6 ]> 65536L )
{
begindiagnostic () ;
if ( curexp == 30 )
print ( 762 ) ;
else print ( 763 ) ;
enddiagnostic ( false ) ;
}
lab40: checkcolon () ;
if ( curexp == 30 )
{
changeiflimit ( newiflimit , savecondptr ) ;
goto lab10 ;
}
while ( true ) {
passtext () ;
if ( condptr == savecondptr )
goto lab30 ;
else if ( curmod == 2 )
{
p = condptr ;
ifline = mem [p + 1 ].cint ;
curif = mem [p ].hhfield .b1 ;
iflimit = mem [p ].hhfield .b0 ;
condptr = mem [p ].hhfield .v.RH ;
freenode ( p , 2 ) ;
}
}
lab30: curif = curmod ;
ifline = trueline () ;
if ( curmod == 2 )
{
p = condptr ;
ifline = mem [p + 1 ].cint ;
curif = mem [p ].hhfield .b1 ;
iflimit = mem [p ].hhfield .b0 ;
condptr = mem [p ].hhfield .v.RH ;
freenode ( p , 2 ) ;
}
else if ( curmod == 4 )
goto lab21 ;
else {
curexp = 30 ;
newiflimit = 2 ;
getxnext () ;
goto lab40 ;
}
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zbadfor ( strnumber s )
#else
zbadfor ( s )
strnumber s ;
#endif
{
disperr ( 0 , 766 ) ;
print ( s ) ;
print ( 306 ) ;
{
helpptr = 4 ;
helpline [3 ]= 767 ;
helpline [2 ]= 768 ;
helpline [1 ]= 769 ;
helpline [0 ]= 308 ;
}
putgetflusherror ( 0 ) ;
}
void
#ifdef HAVE_PROTOTYPES
beginiteration ( void )
#else
beginiteration ( )
#endif
{
/* 22 30 */ halfword m ;
halfword n ;
halfword s ;
halfword p ;
halfword q ;
halfword pp ;
m = curmod ;
n = cursym ;
s = getnode ( 2 ) ;
if ( m == 1 )
{
mem [s + 1 ].hhfield .lhfield = 1 ;
p = 0 ;
getxnext () ;
}
else {
getsymbol () ;
p = getnode ( 2 ) ;
mem [p ].hhfield .lhfield = cursym ;
mem [p + 1 ].cint = m ;
getxnext () ;
if ( curcmd == 74 )
{
getxnext () ;
scanexpression () ;
if ( curtype != 10 )
{
disperr ( 0 , 782 ) ;
{
helpptr = 1 ;
helpline [0 ]= 783 ;
}
putgetflusherror ( getnode ( 8 ) ) ;
initedges ( curexp ) ;
curtype = 10 ;
}
mem [s + 1 ].hhfield .lhfield = curexp ;
curtype = 1 ;
q = mem [curexp + 7 ].hhfield .v.RH ;
if ( q != 0 )
if ( ( mem [q ].hhfield .b0 >= 4 ) )
if ( skip1component ( q ) == 0 )
q = mem [q ].hhfield .v.RH ;
mem [s + 1 ].hhfield .v.RH = q ;
}
else {
if ( ( curcmd != 53 ) && ( curcmd != 76 ) )
{
missingerr ( 61 ) ;
{
helpptr = 3 ;
helpline [2 ]= 770 ;
helpline [1 ]= 713 ;
helpline [0 ]= 771 ;
}
backerror () ;
}
mem [s + 1 ].hhfield .lhfield = 0 ;
q = s + 1 ;
mem [q ].hhfield .v.RH = 0 ;
do {
getxnext () ;
if ( m != 9772 )
scansuffix () ;
else {
if ( curcmd >= 80 )
if ( curcmd <= 81 )
goto lab22 ;
scanexpression () ;
if ( curcmd == 72 )
if ( q == s + 1 )
{
if ( curtype != 16 )
badfor ( 777 ) ;
pp = getnode ( 4 ) ;
mem [pp + 1 ].cint = curexp ;
getxnext () ;
scanexpression () ;
if ( curtype != 16 )
badfor ( 778 ) ;
mem [pp + 2 ].cint = curexp ;
if ( curcmd != 73 )
{
missingerr ( 500 ) ;
{
helpptr = 2 ;
helpline [1 ]= 779 ;
helpline [0 ]= 780 ;
}
backerror () ;
}
getxnext () ;
scanexpression () ;
if ( curtype != 16 )
badfor ( 781 ) ;
mem [pp + 3 ].cint = curexp ;
mem [s + 1 ].hhfield .v.RH = pp ;
mem [s + 1 ].hhfield .lhfield = 2 ;
goto lab30 ;
}
curexp = stashcurexp () ;
}
mem [q ].hhfield .v.RH = getavail () ;
q = mem [q ].hhfield .v.RH ;
mem [q ].hhfield .lhfield = curexp ;
curtype = 1 ;
lab22: ;
} while ( ! ( curcmd != 81 ) ) ;
lab30: ;
}
}
if ( curcmd != 80 )
{
missingerr ( 58 ) ;
{
helpptr = 3 ;
helpline [2 ]= 772 ;
helpline [1 ]= 773 ;
helpline [0 ]= 774 ;
}
backerror () ;
}
q = getavail () ;
mem [q ].hhfield .lhfield = 9758 ;
scannerstatus = 6 ;
warninginfo = n ;
mem [s ].hhfield .lhfield = scantoks ( 7 , p , q , 0 ) ;
scannerstatus = 0 ;
mem [s ].hhfield .v.RH = loopptr ;
loopptr = s ;
resumeiteration () ;
}
void
#ifdef HAVE_PROTOTYPES
resumeiteration ( void )
#else
resumeiteration ( )
#endif
{
/* 45 10 */ halfword p, q ;
p = mem [loopptr + 1 ].hhfield .lhfield ;
if ( p == 2 )
{
p = mem [loopptr + 1 ].hhfield .v.RH ;
curexp = mem [p + 1 ].cint ;
if ( ( ( mem [p + 2 ].cint > 0 ) && ( curexp > mem [p + 3 ].cint ) )
|| ( ( mem [p + 2 ].cint < 0 ) && ( curexp < mem [p + 3 ].cint ) ) )
goto lab45 ;
curtype = 16 ;
q = stashcurexp () ;
mem [p + 1 ].cint = curexp + mem [p + 2 ].cint ;
}
else if ( p == 0 )
{
p = mem [loopptr + 1 ].hhfield .v.RH ;
if ( p == 0 )
goto lab45 ;
mem [loopptr + 1 ].hhfield .v.RH = mem [p ].hhfield .v.RH ;
q = mem [p ].hhfield .lhfield ;
{
mem [p ].hhfield .v.RH = avail ;
avail = p ;
;
#ifdef STAT
decr ( dynused ) ;
#endif /* STAT */
}
}
else if ( p == 1 )
{
begintokenlist ( mem [loopptr ].hhfield .lhfield , 16 ) ;
goto lab10 ;
}
else {
q = mem [loopptr + 1 ].hhfield .v.RH ;
if ( q == 0 )
goto lab45 ;
if ( ! ( mem [q ].hhfield .b0 >= 4 ) )
q = mem [q ].hhfield .v.RH ;
else if ( ! ( mem [q ].hhfield .b0 >= 6 ) )
q = skip1component ( q ) ;
else goto lab45 ;
curexp = copyobjects ( mem [loopptr + 1 ].hhfield .v.RH , q ) ;
initbbox ( curexp ) ;
curtype = 10 ;
mem [loopptr + 1 ].hhfield .v.RH = q ;
q = stashcurexp () ;
}
begintokenlist ( mem [loopptr ].hhfield .lhfield , 17 ) ;
stackargument ( q ) ;
if ( internal [6 ]> 65536L )
{
begindiagnostic () ;
printnl ( 776 ) ;
if ( ( q != 0 ) && ( mem [q ].hhfield .v.RH == 1 ) )
printexp ( q , 1 ) ;
else showtokenlist ( q , 0 , 50 , 0 ) ;
printchar ( 125 ) ;
enddiagnostic ( false ) ;
}
goto lab10 ;
lab45: stopiteration () ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
stopiteration ( void )
#else
stopiteration ( )
#endif
{
halfword p, q ;
p = mem [loopptr + 1 ].hhfield .lhfield ;
if ( p == 2 )
freenode ( mem [loopptr + 1 ].hhfield .v.RH , 4 ) ;
else if ( p == 0 )
{
q = mem [loopptr + 1 ].hhfield .v.RH ;
while ( q != 0 ) {
p = mem [q ].hhfield .lhfield ;
if ( p != 0 )
if ( mem [p ].hhfield .v.RH == 1 )
{
recyclevalue ( p ) ;
freenode ( p , 2 ) ;
}
else flushtokenlist ( p ) ;
p = q ;
q = mem [q ].hhfield .v.RH ;
{
mem [p ].hhfield .v.RH = avail ;
avail = p ;
;
#ifdef STAT
decr ( dynused ) ;
#endif /* STAT */
}
}
}
else if ( p > 2 )
if ( mem [p ].hhfield .lhfield == 0 )
tossedges ( p ) ;
else decr ( mem [p ].hhfield .lhfield ) ;
p = loopptr ;
loopptr = mem [p ].hhfield .v.RH ;
flushtokenlist ( mem [p ].hhfield .lhfield ) ;
freenode ( p , 2 ) ;
}
void
#ifdef HAVE_PROTOTYPES
zpackbufferedname ( smallnumber n , integer a , integer b )
#else
zpackbufferedname ( n , a , b )
smallnumber n ;
integer a ;
integer b ;
#endif
{
integer k ;
ASCIIcode c ;
integer j ;
if ( n + b - a + 5 > maxint )
b = a + maxint - n - 5 ;
k = 0 ;
if ( (char*) nameoffile )
libcfree ( (char*) nameoffile ) ;
nameoffile = xmalloc ( 1 + n + ( b - a + 1 ) + 5 ) ;
{register integer for_end; j = 1 ;for_end = n ; if ( j <= for_end) do
{
c = xord [MPmemdefault [j ]];
incr ( k ) ;
if ( k <= maxint )
nameoffile [k ]= xchr [c ];
}
while ( j++ < for_end ) ;}
{register integer for_end; j = a ;for_end = b ; if ( j <= for_end) do
{
c = buffer [j ];
incr ( k ) ;
if ( k <= maxint )
nameoffile [k ]= xchr [c ];
}
while ( j++ < for_end ) ;}
{register integer for_end; j = memdefaultlength - 3 ;for_end =
memdefaultlength ; if ( j <= for_end) do
{
c = xord [MPmemdefault [j ]];
incr ( k ) ;
if ( k <= maxint )
nameoffile [k ]= xchr [c ];
}
while ( j++ < for_end ) ;}
if ( k <= maxint )
namelength = k ;
else namelength = maxint ;
nameoffile [namelength + 1 ]= 0 ;
}
strnumber
#ifdef HAVE_PROTOTYPES
makenamestring ( void )
#else
makenamestring ( )
#endif
{
register strnumber Result; integer k ;
if ( stroverflowed )
Result = 63 ;
else {
{
if ( poolptr + namelength > maxpoolptr )
if ( poolptr + namelength > poolsize )
docompaction ( namelength ) ;
else maxpoolptr = poolptr + namelength ;
}
{register integer for_end; k = 1 ;for_end = namelength ; if ( k <=
for_end) do
{
strpool [poolptr ]= xord [nameoffile [k ]];
incr ( poolptr ) ;
}
while ( k++ < for_end ) ;}
Result = makestring () ;
}
return Result ;
}
strnumber
#ifdef HAVE_PROTOTYPES
zamakenamestring ( alphafile f )
#else
zamakenamestring ( f )
alphafile f ;
#endif
{
register strnumber Result; Result = makenamestring () ;
return Result ;
}
strnumber
#ifdef HAVE_PROTOTYPES
zbmakenamestring ( bytefile f )
#else
zbmakenamestring ( f )
bytefile f ;
#endif
{
register strnumber Result; Result = makenamestring () ;
return Result ;
}
strnumber
#ifdef HAVE_PROTOTYPES
zwmakenamestring ( wordfile f )
#else
zwmakenamestring ( f )
wordfile f ;
#endif
{
register strnumber Result; Result = makenamestring () ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
scanfilename ( void )
#else
scanfilename ( )
#endif
{
/* 30 */ beginname () ;
while ( ( buffer [curinput .locfield ]== 32 ) || ( buffer [curinput
.locfield ]== 9 ) ) incr ( curinput .locfield ) ;
while ( true ) {
if ( ( buffer [curinput .locfield ]== 59 ) || ( buffer [curinput
.locfield ]== 37 ) )
goto lab30 ;
if ( ! morename ( buffer [curinput .locfield ]) )
goto lab30 ;
incr ( curinput .locfield ) ;
}
lab30: endname () ;
}
void
#ifdef HAVE_PROTOTYPES
zpackjobname ( strnumber s )
#else
zpackjobname ( s )
strnumber s ;
#endif
{
{
if ( strref [s ]< 127 )
incr ( strref [s ]) ;
}
{
if ( strref [curname ]< 127 )
if ( strref [curname ]> 1 )
decr ( strref [curname ]) ;
else flushstring ( curname ) ;
}
{
if ( strref [curarea ]< 127 )
if ( strref [curarea ]> 1 )
decr ( strref [curarea ]) ;
else flushstring ( curarea ) ;
}
{
if ( strref [curext ]< 127 )
if ( strref [curext ]> 1 )
decr ( strref [curext ]) ;
else flushstring ( curext ) ;
}
curarea = 284 ;
curext = s ;
curname = jobname ;
packfilename ( curname , curarea , curext ) ;
}
void
#ifdef HAVE_PROTOTYPES
zpromptfilename ( strnumber s , strnumber e )
#else
zpromptfilename ( s , e )
strnumber s ;
strnumber e ;
#endif
{
/* 30 */ integer k ;
if ( interaction == 2 )
;
if ( s == 785 )
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 786 ) ;
}
else {
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 787 ) ;
}
printfilename ( curname , curarea , curext ) ;
print ( 788 ) ;
if ( e == 284 )
showcontext () ;
printnl ( 789 ) ;
print ( s ) ;
if ( interaction < 2 )
fatalerror ( 790 ) ;
{
;
print ( 791 ) ;
terminput () ;
}
{
beginname () ;
k = first ;
while ( ( ( buffer [k ]== 32 ) || ( buffer [k ]== 9 ) ) && ( k < last
) ) incr ( k ) ;
while ( true ) {
if ( k == last )
goto lab30 ;
if ( ! morename ( buffer [k ]) )
goto lab30 ;
incr ( k ) ;
}
lab30: endname () ;
}
if ( curext == 284 )
curext = e ;
packfilename ( curname , curarea , curext ) ;
}
void
#ifdef HAVE_PROTOTYPES
openlogfile ( void )
#else
openlogfile ( )
#endif
{
char oldsetting ;
integer k ;
integer l ;
integer m ;
char * months ;
oldsetting = selector ;
if ( jobname == 0 )
jobname = 792 ;
packjobname ( 793 ) ;
while ( ! aopenout ( logfile ) ) {
selector = 8 ;
promptfilename ( 795 , 793 ) ;
}
texmflogname = amakenamestring ( logfile ) ;
selector = 9 ;
logopened = true ;
{
Fputs( logfile , "This is MetaPost, Version 0.641" ) ;
Fputs( logfile , versionstring ) ;
print ( memident ) ;
print ( 796 ) ;
printint ( roundunscaled ( internal [15 ]) ) ;
printchar ( 32 ) ;
months = " JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC" ;
m = roundunscaled ( internal [14 ]) ;
{register integer for_end; k = 3 * m - 2 ;for_end = 3 * m ; if ( k <=
for_end) do
putc ( months [k ], logfile );
while ( k++ < for_end ) ;}
printchar ( 32 ) ;
printint ( roundunscaled ( internal [13 ]) ) ;
printchar ( 32 ) ;
m = roundunscaled ( internal [16 ]) ;
printdd ( m / 60 ) ;
printchar ( 58 ) ;
printdd ( m % 60 ) ;
}
inputstack [inputptr ]= curinput ;
printnl ( 794 ) ;
l = inputstack [0 ].limitfield - 1 ;
{register integer for_end; k = 1 ;for_end = l ; if ( k <= for_end) do
print ( buffer [k ]) ;
while ( k++ < for_end ) ;}
println () ;
selector = oldsetting + 2 ;
}
boolean
#ifdef HAVE_PROTOTYPES
ztryextension ( strnumber ext )
#else
ztryextension ( ext )
strnumber ext ;
#endif
{
register boolean Result; packfilename ( curname , curarea , curext ) ;
inamestack [curinput .indexfield ]= curname ;
iareastack [curinput .indexfield ]= curarea ;
if ( strvsstr ( ext , 797 ) == 0 )
Result = aopenin ( inputfile [curinput .indexfield ], kpsemfformat ) ;
else Result = aopenin ( inputfile [curinput .indexfield ], kpsempformat )
;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zcopyoldname ( strnumber s )
#else
zcopyoldname ( s )
strnumber s ;
#endif
{
integer k ;
poolpointer j ;
k = 0 ;
if ( oldfilename )
libcfree ( oldfilename ) ;
oldfilename = xmalloc ( 1 + ( strstart [nextstr [s ]]- strstart [s ])
+ 1 ) ;
{register integer for_end; j = strstart [s ];for_end = strstart [
nextstr [s ]]- 1 ; if ( j <= for_end) do
{
incr ( k ) ;
if ( k <= maxint )
oldfilename [k ]= xchr [strpool [j ]];
}
while ( j++ < for_end ) ;}
if ( k <= maxint )
oldnamelength = k ;
else oldnamelength = maxint ;
oldfilename [oldnamelength + 1 ]= 0 ;
}
void
#ifdef HAVE_PROTOTYPES
startmpxinput ( void )
#else
startmpxinput ( )
#endif
{
/* 10 45 */ integer k ;
packfilename ( inamestack [curinput .indexfield ], iareastack [curinput
.indexfield ], 803 ) ;
copyoldname ( curinput .namefield ) ;
if ( ! callmakempx ( oldfilename + 1 , (char*) nameoffile + 1 ) )
goto lab45 ;
beginfilereading () ;
if ( ! aopenin ( inputfile [curinput .indexfield ], -1 ) )
{
endfilereading () ;
goto lab45 ;
}
curinput .namefield = amakenamestring ( inputfile [curinput .indexfield ])
;
mpxname [curinput .indexfield ]= curinput .namefield ;
{
if ( strref [curinput .namefield ]< 127 )
incr ( strref [curinput .namefield ]) ;
}
{
linestack [curinput .indexfield ]= 1 ;
if ( inputln ( inputfile [curinput .indexfield ], false ) )
;
firmuptheline () ;
buffer [curinput .limitfield ]= 37 ;
first = curinput .limitfield + 1 ;
curinput .locfield = curinput .startfield ;
}
goto lab10 ;
lab45: if ( interaction == 3 )
;
printnl ( 804 ) ;
{register integer for_end; k = 1 ;for_end = oldnamelength ; if ( k <=
for_end) do
print ( xord [oldfilename [k ]]) ;
while ( k++ < for_end ) ;}
printnl ( 804 ) ;
{register integer for_end; k = 1 ;for_end = namelength ; if ( k <=
for_end) do
print ( xord [nameoffile [k ]]) ;
while ( k++ < for_end ) ;}
printnl ( 805 ) ;
{
helpptr = 4 ;
helpline [3 ]= 806 ;
helpline [2 ]= 807 ;
helpline [1 ]= 808 ;
helpline [0 ]= 809 ;
}
{
if ( interaction == 3 )
interaction = 2 ;
if ( logopened )
error () ;
;
#ifdef TEXMF_DEBUG
if ( interaction > 0 )
debughelp () ;
#endif /* TEXMF_DEBUG */
history = 3 ;
jumpout () ;
}
lab10: ;
}
boolean
#ifdef HAVE_PROTOTYPES
zstartreadinput ( strnumber s , readfindex n )
#else
zstartreadinput ( s , n )
strnumber s ;
readfindex n ;
#endif
{
/* 10 45 */ register boolean Result; strscanfile ( s ) ;
packfilename ( curname , curarea , curext ) ;
beginfilereading () ;
if ( ! aopenin ( rdfile [n ], -1 ) )
goto lab45 ;
if ( ! inputln ( rdfile [n ], false ) )
{
aclose ( rdfile [n ]) ;
goto lab45 ;
}
rdfname [n ]= s ;
{
if ( strref [s ]< 127 )
incr ( strref [s ]) ;
}
Result = true ;
goto lab10 ;
lab45: endfilereading () ;
Result = false ;
lab10: ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zopenwritefile ( strnumber s , readfindex n )
#else
zopenwritefile ( s , n )
strnumber s ;
readfindex n ;
#endif
{
#ifdef AMIGA
/* 30 */ readfindex n0 ;
#endif /* AMIGA */
strscanfile ( s ) ;
packfilename ( curname , curarea , curext ) ;
;
#ifdef AMIGA
{register integer for_end; n0 = 0 ;for_end = readfiles - 1 ; if ( n0 <=
for_end) do
{
if ( rdfname [n0 ]!= 0 )
{
if ( strvsstr ( s , rdfname [n0 ]) == 0 )
{
aclose ( rdfile [n0 ]) ;
{
if ( strref [rdfname [n0 ]]< 127 )
if ( strref [rdfname [n0 ]]> 1 )
decr ( strref [rdfname [n0 ]]) ;
else flushstring ( rdfname [n0 ]) ;
}
rdfname [n0 ]= 0 ;
if ( n0 == readfiles - 1 )
readfiles = n0 ;
goto lab30 ;
}
}
}
while ( n0++ < for_end ) ;}
lab30: ;
#endif /* AMIGA */
while ( ! openoutnameok ( (char*) nameoffile + 1 ) || ! aopenout ( wrfile [n ]) )
promptfilename ( 810 , 284 ) ;
wrfname [n ]= s ;
{
if ( strref [s ]< 127 )
incr ( strref [s ]) ;
}
if ( logopened )
{
oldsetting = selector ;
if ( ( internal [12 ]<= 0 ) )
selector = 9 ;
else selector = 10 ;
printnl ( 502 ) ;
printint ( n ) ;
print ( 811 ) ;
printfilename ( curname , curarea , curext ) ;
print ( 788 ) ;
printnl ( 284 ) ;
println () ;
selector = oldsetting ;
}
}
void
#ifdef HAVE_PROTOTYPES
zbadexp ( strnumber s )
#else
zbadexp ( s )
strnumber s ;
#endif
{
char saveflag ;
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( s ) ;
}
print ( 819 ) ;
printcmdmod ( curcmd , curmod ) ;
printchar ( 39 ) ;
{
helpptr = 4 ;
helpline [3 ]= 820 ;
helpline [2 ]= 821 ;
helpline [1 ]= 822 ;
helpline [0 ]= 823 ;
}
backinput () ;
cursym = 0 ;
curcmd = 44 ;
curmod = 0 ;
inserror () ;
saveflag = varflag ;
varflag = 0 ;
getxnext () ;
varflag = saveflag ;
}
void
#ifdef HAVE_PROTOTYPES
zstashin ( halfword p )
#else
zstashin ( p )
halfword p ;
#endif
{
halfword q ;
mem [p ].hhfield .b0 = curtype ;
if ( curtype == 16 )
mem [p + 1 ].cint = curexp ;
else {
if ( curtype == 19 )
{
q = singledependency ( curexp ) ;
if ( q == depfinal )
{
mem [p ].hhfield .b0 = 16 ;
mem [p + 1 ].cint = 0 ;
freenode ( q , 2 ) ;
}
else {
mem [p ].hhfield .b0 = 17 ;
newdep ( p , q ) ;
}
recyclevalue ( curexp ) ;
}
else {
mem [p + 1 ]= mem [curexp + 1 ];
mem [mem [p + 1 ].hhfield .lhfield ].hhfield .v.RH = p ;
}
freenode ( curexp , 2 ) ;
}
curtype = 1 ;
}
void
#ifdef HAVE_PROTOTYPES
backexpr ( void )
#else
backexpr ( )
#endif
{
halfword p ;
p = stashcurexp () ;
mem [p ].hhfield .v.RH = 0 ;
begintokenlist ( p , 19 ) ;
}
void
#ifdef HAVE_PROTOTYPES
badsubscript ( void )
#else
badsubscript ( )
#endif
{
disperr ( 0 , 837 ) ;
{
helpptr = 3 ;
helpline [2 ]= 838 ;
helpline [1 ]= 839 ;
helpline [0 ]= 840 ;
}
flusherror ( 0 ) ;
}
void
#ifdef HAVE_PROTOTYPES
zobliterated ( halfword q )
#else
zobliterated ( q )
halfword q ;
#endif
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 841 ) ;
}
showtokenlist ( q , 0 , 1000 , 0 ) ;
print ( 842 ) ;
{
helpptr = 5 ;
helpline [4 ]= 843 ;
helpline [3 ]= 844 ;
helpline [2 ]= 845 ;
helpline [1 ]= 846 ;
helpline [0 ]= 847 ;
}
}
void
#ifdef HAVE_PROTOTYPES
zbinarymac ( halfword p , halfword c , halfword n )
#else
zbinarymac ( p , c , n )
halfword p ;
halfword c ;
halfword n ;
#endif
{
halfword q, r ;
q = getavail () ;
r = getavail () ;
mem [q ].hhfield .v.RH = r ;
mem [q ].hhfield .lhfield = p ;
mem [r ].hhfield .lhfield = stashcurexp () ;
macrocall ( c , q , n ) ;
}
void
#ifdef HAVE_PROTOTYPES
knownpair ( void )
#else
knownpair ( )
#endif
{
halfword p ;
if ( curtype != 14 )
{
disperr ( 0 , 858 ) ;
{
helpptr = 5 ;
helpline [4 ]= 859 ;
helpline [3 ]= 860 ;
helpline [2 ]= 861 ;
helpline [1 ]= 862 ;
helpline [0 ]= 863 ;
}
putgetflusherror ( 0 ) ;
curx = 0 ;
cury = 0 ;
}
else {
p = mem [curexp + 1 ].cint ;
if ( mem [p ].hhfield .b0 == 16 )
curx = mem [p + 1 ].cint ;
else {
disperr ( p , 864 ) ;
{
helpptr = 5 ;
helpline [4 ]= 865 ;
helpline [3 ]= 860 ;
helpline [2 ]= 861 ;
helpline [1 ]= 862 ;
helpline [0 ]= 863 ;
}
putgeterror () ;
recyclevalue ( p ) ;
curx = 0 ;
}
if ( mem [p + 2 ].hhfield .b0 == 16 )
cury = mem [p + 3 ].cint ;
else {
disperr ( p + 2 , 866 ) ;
{
helpptr = 5 ;
helpline [4 ]= 867 ;
helpline [3 ]= 860 ;
helpline [2 ]= 861 ;
helpline [1 ]= 862 ;
helpline [0 ]= 863 ;
}
putgeterror () ;
recyclevalue ( p + 2 ) ;
cury = 0 ;
}
flushcurexp ( 0 ) ;
}
}
halfword
#ifdef HAVE_PROTOTYPES
newknot ( void )
#else
newknot ( )
#endif
{
register halfword Result; halfword q ;
q = getnode ( 7 ) ;
mem [q ].hhfield .b0 = 0 ;
mem [q ].hhfield .b1 = 0 ;
mem [q ].hhfield .v.RH = q ;
knownpair () ;
mem [q + 1 ].cint = curx ;
mem [q + 2 ].cint = cury ;
Result = q ;
return Result ;
}
smallnumber
#ifdef HAVE_PROTOTYPES
scandirection ( void )
#else
scandirection ( )
#endif
{
register smallnumber Result; char t ;
scaled x ;
getxnext () ;
if ( curcmd == 62 )
{
getxnext () ;
scanexpression () ;
if ( ( curtype != 16 ) || ( curexp < 0 ) )
{
disperr ( 0 , 870 ) ;
{
helpptr = 1 ;
helpline [0 ]= 871 ;
}
putgetflusherror ( 65536L ) ;
}
t = 3 ;
}
else {
scanexpression () ;
if ( curtype > 14 )
{
if ( curtype != 16 )
{
disperr ( 0 , 864 ) ;
{
helpptr = 5 ;
helpline [4 ]= 865 ;
helpline [3 ]= 860 ;
helpline [2 ]= 861 ;
helpline [1 ]= 862 ;
helpline [0 ]= 863 ;
}
putgetflusherror ( 0 ) ;
}
x = curexp ;
if ( curcmd != 81 )
{
missingerr ( 44 ) ;
{
helpptr = 2 ;
helpline [1 ]= 872 ;
helpline [0 ]= 873 ;
}
backerror () ;
}
getxnext () ;
scanexpression () ;
if ( curtype != 16 )
{
disperr ( 0 , 866 ) ;
{
helpptr = 5 ;
helpline [4 ]= 867 ;
helpline [3 ]= 860 ;
helpline [2 ]= 861 ;
helpline [1 ]= 862 ;
helpline [0 ]= 863 ;
}
putgetflusherror ( 0 ) ;
}
cury = curexp ;
curx = x ;
}
else knownpair () ;
if ( ( curx == 0 ) && ( cury == 0 ) )
t = 4 ;
else {
t = 2 ;
curexp = narg ( curx , cury ) ;
}
}
if ( curcmd != 67 )
{
missingerr ( 125 ) ;
{
helpptr = 3 ;
helpline [2 ]= 868 ;
helpline [1 ]= 869 ;
helpline [0 ]= 738 ;
}
backerror () ;
}
getxnext () ;
Result = t ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
finishread ( void )
#else
finishread ( )
#endif
{
poolpointer k ;
{
if ( poolptr + last - curinput .startfield > maxpoolptr )
if ( poolptr + last - curinput .startfield > poolsize )
docompaction ( last - curinput .startfield ) ;
else maxpoolptr = poolptr + last - curinput .startfield ;
}
{register integer for_end; k = curinput .startfield ;for_end = last - 1
; if ( k <= for_end) do
{
strpool [poolptr ]= buffer [k ];
incr ( poolptr ) ;
}
while ( k++ < for_end ) ;}
endfilereading () ;
curtype = 4 ;
curexp = makestring () ;
}
void
#ifdef HAVE_PROTOTYPES
zdonullary ( quarterword c )
#else
zdonullary ( c )
quarterword c ;
#endif
{
{
if ( aritherror )
cleararith () ;
}
if ( internal [6 ]> 131072L )
showcmdmod ( 35 , c ) ;
switch ( c )
{case 30 :
case 31 :
{
curtype = 2 ;
curexp = c ;
}
break ;
case 32 :
{
curtype = 10 ;
curexp = getnode ( 8 ) ;
initedges ( curexp ) ;
}
break ;
case 33 :
{
curtype = 6 ;
curexp = getpencircle ( 0 ) ;
}
break ;
case 37 :
{
curtype = 16 ;
curexp = normrand () ;
}
break ;
case 36 :
{
curtype = 6 ;
curexp = getpencircle ( 65536L ) ;
}
break ;
case 34 :
{
if ( jobname == 0 )
openlogfile () ;
curtype = 4 ;
curexp = jobname ;
}
break ;
case 35 :
{
if ( interaction <= 1 )
fatalerror ( 884 ) ;
beginfilereading () ;
curinput .namefield = 1 ;
curinput .limitfield = curinput .startfield ;
{
;
print ( 284 ) ;
terminput () ;
}
finishread () ;
}
break ;
}
{
if ( aritherror )
cleararith () ;
}
}
boolean
#ifdef HAVE_PROTOTYPES
znicepair ( integer p , quarterword t )
#else
znicepair ( p , t )
integer p ;
quarterword t ;
#endif
{
/* 10 */ register boolean Result; if ( t == 14 )
{
p = mem [p + 1 ].cint ;
if ( mem [p ].hhfield .b0 == 16 )
if ( mem [p + 2 ].hhfield .b0 == 16 )
{
Result = true ;
goto lab10 ;
}
}
Result = false ;
lab10: ;
return Result ;
}
boolean
#ifdef HAVE_PROTOTYPES
znicecolororpair ( integer p , quarterword t )
#else
znicecolororpair ( p , t )
integer p ;
quarterword t ;
#endif
{
/* 10 */ register boolean Result; halfword q, r ;
if ( ( t != 14 ) && ( t != 13 ) )
Result = false ;
else {
q = mem [p + 1 ].cint ;
r = q + bignodesize [mem [p ].hhfield .b0 ];
do {
r = r - 2 ;
if ( mem [r ].hhfield .b0 != 16 )
{
Result = false ;
goto lab10 ;
}
} while ( ! ( r == q ) ) ;
Result = true ;
}
lab10: ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zprintknownorunknowntype ( smallnumber t , integer v )
#else
zprintknownorunknowntype ( t , v )
smallnumber t ;
integer v ;
#endif
{
printchar ( 40 ) ;
if ( t > 16 )
print ( 885 ) ;
else {
if ( ( t == 14 ) || ( t == 13 ) )
if ( ! nicecolororpair ( v , t ) )
print ( 886 ) ;
printtype ( t ) ;
}
printchar ( 41 ) ;
}
void
#ifdef HAVE_PROTOTYPES
zbadunary ( quarterword c )
#else
zbadunary ( c )
quarterword c ;
#endif
{
disperr ( 0 , 887 ) ;
printop ( c ) ;
printknownorunknowntype ( curtype , curexp ) ;
{
helpptr = 3 ;
helpline [2 ]= 888 ;
helpline [1 ]= 889 ;
helpline [0 ]= 890 ;
}
putgeterror () ;
}
void
#ifdef HAVE_PROTOTYPES
znegatedeplist ( halfword p )
#else
znegatedeplist ( p )
halfword p ;
#endif
{
/* 10 */ while ( true ) {
mem [p + 1 ].cint = - (integer) mem [p + 1 ].cint ;
if ( mem [p ].hhfield .lhfield == 0 )
goto lab10 ;
p = mem [p ].hhfield .v.RH ;
}
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
pairtopath ( void )
#else
pairtopath ( )
#endif
{
curexp = newknot () ;
curtype = 8 ;
}
void
#ifdef HAVE_PROTOTYPES
ztakepart ( quarterword c )
#else
ztakepart ( c )
quarterword c ;
#endif
{
halfword p ;
p = mem [curexp + 1 ].cint ;
mem [10 ].cint = p ;
mem [9 ].hhfield .b0 = curtype ;
mem [p ].hhfield .v.RH = 9 ;
freenode ( curexp , 2 ) ;
makeexpcopy ( p + sectoroffset [c - 49 ]) ;
recyclevalue ( 9 ) ;
}
void
#ifdef HAVE_PROTOTYPES
ztakepictpart ( quarterword c )
#else
ztakepictpart ( c )
quarterword c ;
#endif
{
/* 10 45 */ halfword p ;
p = mem [curexp + 7 ].hhfield .v.RH ;
if ( p != 0 )
{
switch ( c )
{case 54 :
case 55 :
case 56 :
case 57 :
case 58 :
case 59 :
if ( mem [p ].hhfield .b0 == 3 )
flushcurexp ( mem [p + c - 46 ].cint ) ;
else goto lab45 ;
break ;
case 60 :
case 61 :
case 62 :
if ( ( mem [p ].hhfield .b0 < 4 ) )
flushcurexp ( mem [p + c - 58 ].cint ) ;
else goto lab45 ;
break ;
case 64 :
if ( mem [p ].hhfield .b0 != 3 )
goto lab45 ;
else {
flushcurexp ( mem [p + 1 ].hhfield .v.RH ) ;
{
if ( strref [curexp ]< 127 )
incr ( strref [curexp ]) ;
}
curtype = 4 ;
}
break ;
case 63 :
if ( mem [p ].hhfield .b0 != 3 )
goto lab45 ;
else {
flushcurexp ( fontname [mem [p + 1 ].hhfield .lhfield ]) ;
{
if ( strref [curexp ]< 127 )
incr ( strref [curexp ]) ;
}
curtype = 4 ;
}
break ;
case 65 :
if ( mem [p ].hhfield .b0 == 3 )
goto lab45 ;
else if ( ( mem [p ].hhfield .b0 >= 6 ) )
confusion ( 892 ) ;
else {
flushcurexp ( copypath ( mem [p + 1 ].hhfield .v.RH ) ) ;
curtype = 8 ;
}
break ;
case 66 :
if ( ! ( mem [p ].hhfield .b0 < 3 ) )
goto lab45 ;
else if ( mem [p + 1 ].hhfield .lhfield == 0 )
goto lab45 ;
else {
flushcurexp ( makepen ( copypath ( mem [p + 1 ].hhfield .lhfield ) ,
false ) ) ;
curtype = 6 ;
}
break ;
case 67 :
if ( mem [p ].hhfield .b0 != 2 )
goto lab45 ;
else if ( mem [p + 6 ].hhfield .v.RH == 0 )
goto lab45 ;
else {
incr ( mem [mem [p + 6 ].hhfield .v.RH ].hhfield .lhfield ) ;
sesf = mem [p + 7 ].cint ;
sepic = mem [p + 6 ].hhfield .v.RH ;
scaleedges () ;
flushcurexp ( sepic ) ;
curtype = 10 ;
}
break ;
}
goto lab10 ;
}
lab45: switch ( c )
{case 64 :
case 63 :
{
flushcurexp ( 284 ) ;
curtype = 4 ;
}
break ;
case 65 :
{
flushcurexp ( getnode ( 7 ) ) ;
mem [curexp ].hhfield .b0 = 0 ;
mem [curexp ].hhfield .b1 = 0 ;
mem [curexp ].hhfield .v.RH = curexp ;
mem [curexp + 1 ].cint = 0 ;
mem [curexp + 2 ].cint = 0 ;
curtype = 8 ;
}
break ;
case 66 :
{
flushcurexp ( getpencircle ( 0 ) ) ;
curtype = 6 ;
}
break ;
case 67 :
{
flushcurexp ( getnode ( 8 ) ) ;
initedges ( curexp ) ;
curtype = 10 ;
}
break ;
default:
flushcurexp ( 0 ) ;
break ;
}
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zstrtonum ( quarterword c )
#else
zstrtonum ( c )
quarterword c ;
#endif
{
integer n ;
ASCIIcode m ;
poolpointer k ;
char b ;
boolean badchar ;
if ( c == 50 )
if ( ( strstart [nextstr [curexp ]]- strstart [curexp ]) == 0 )
n = -1 ;
else n = strpool [strstart [curexp ]];
else {
if ( c == 48 )
b = 8 ;
else b = 16 ;
n = 0 ;
badchar = false ;
{register integer for_end; k = strstart [curexp ];for_end = strstart [
nextstr [curexp ]]- 1 ; if ( k <= for_end) do
{
m = strpool [k ];
if ( ( m >= 48 ) && ( m <= 57 ) )
m = m - 48 ;
else if ( ( m >= 65 ) && ( m <= 70 ) )
m = m - 55 ;
else if ( ( m >= 97 ) && ( m <= 102 ) )
m = m - 87 ;
else {
badchar = true ;
m = 0 ;
}
if ( m >= b )
{
badchar = true ;
m = 0 ;
}
if ( n < 32768L / b )
n = n * b + m ;
else n = 32767 ;
}
while ( k++ < for_end ) ;}
if ( badchar )
{
disperr ( 0 , 893 ) ;
if ( c == 48 )
{
helpptr = 1 ;
helpline [0 ]= 894 ;
}
else {
helpptr = 1 ;
helpline [0 ]= 895 ;
}
putgeterror () ;
}
if ( ( n > 4095 ) )
if ( internal [30 ]> 0 )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 896 ) ;
}
printint ( n ) ;
printchar ( 41 ) ;
{
helpptr = 2 ;
helpline [1 ]= 897 ;
helpline [0 ]= 606 ;
}
putgeterror () ;
}
}
flushcurexp ( n * 65536L ) ;
}
scaled
#ifdef HAVE_PROTOTYPES
pathlength ( void )
#else
pathlength ( )
#endif
{
register scaled Result; scaled n ;
halfword p ;
p = curexp ;
if ( mem [p ].hhfield .b0 == 0 )
n = -65536L ;
else n = 0 ;
do {
p = mem [p ].hhfield .v.RH ;
n = n + 65536L ;
} while ( ! ( p == curexp ) ) ;
Result = n ;
return Result ;
}
scaled
#ifdef HAVE_PROTOTYPES
pictlength ( void )
#else
pictlength ( )
#endif
{
/* 40 */ register scaled Result; scaled n ;
halfword p ;
n = 0 ;
p = mem [curexp + 7 ].hhfield .v.RH ;
if ( p != 0 )
{
if ( ( mem [p ].hhfield .b0 >= 4 ) )
if ( skip1component ( p ) == 0 )
p = mem [p ].hhfield .v.RH ;
while ( p != 0 ) {
if ( ! ( mem [p ].hhfield .b0 >= 4 ) )
p = mem [p ].hhfield .v.RH ;
else if ( ! ( mem [p ].hhfield .b0 >= 6 ) )
p = skip1component ( p ) ;
else goto lab40 ;
n = n + 65536L ;
}
}
lab40: Result = n ;
return Result ;
}
scaled
#ifdef HAVE_PROTOTYPES
zcountturns ( halfword c )
#else
zcountturns ( c )
halfword c ;
#endif
{
register scaled Result; halfword p ;
integer t ;
t = 0 ;
p = c ;
do {
t = t + mem [p ].hhfield .lhfield - 16384 ;
p = mem [p ].hhfield .v.RH ;
} while ( ! ( p == c ) ) ;
Result = ( t / 3 ) * 65536L ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
ztestknown ( quarterword c )
#else
ztestknown ( c )
quarterword c ;
#endif
{
/* 30 */ char b ;
halfword p, q ;
b = 31 ;
switch ( curtype )
{case 1 :
case 2 :
case 4 :
case 6 :
case 8 :
case 10 :
case 16 :
b = 30 ;
break ;
case 12 :
case 13 :
case 14 :
{
p = mem [curexp + 1 ].cint ;
q = p + bignodesize [curtype ];
do {
q = q - 2 ;
if ( mem [q ].hhfield .b0 != 16 )
goto lab30 ;
} while ( ! ( q == p ) ) ;
b = 30 ;
lab30: ;
}
break ;
default:
;
break ;
}
if ( c == 41 )
flushcurexp ( b ) ;
else flushcurexp ( 61 - b ) ;
curtype = 2 ;
}
void
#ifdef HAVE_PROTOTYPES
zpairvalue ( scaled x , scaled y )
#else
zpairvalue ( x , y )
scaled x ;
scaled y ;
#endif
{
halfword p ;
p = getnode ( 2 ) ;
flushcurexp ( p ) ;
curtype = 14 ;
mem [p ].hhfield .b0 = 14 ;
mem [p ].hhfield .b1 = 14 ;
initbignode ( p ) ;
p = mem [p + 1 ].cint ;
mem [p ].hhfield .b0 = 16 ;
mem [p + 1 ].cint = x ;
mem [p + 2 ].hhfield .b0 = 16 ;
mem [p + 3 ].cint = y ;
}
boolean
#ifdef HAVE_PROTOTYPES
getcurbbox ( void )
#else
getcurbbox ( )
#endif
{
/* 10 */ register boolean Result; switch ( curtype )
{case 10 :
{
setbbox ( curexp , true ) ;
if ( mem [curexp + 2 ].cint > mem [curexp + 4 ].cint )
{
bbmin [0 ]= 0 ;
bbmax [0 ]= 0 ;
bbmin [1 ]= 0 ;
bbmax [1 ]= 0 ;
}
else {
bbmin [0 ]= mem [curexp + 2 ].cint ;
bbmax [0 ]= mem [curexp + 4 ].cint ;
bbmin [1 ]= mem [curexp + 3 ].cint ;
bbmax [1 ]= mem [curexp + 5 ].cint ;
}
}
break ;
case 8 :
pathbbox ( curexp ) ;
break ;
case 6 :
penbbox ( curexp ) ;
break ;
default:
{
Result = false ;
goto lab10 ;
}
break ;
}
Result = true ;
lab10: ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zdoreadorclose ( quarterword c )
#else
zdoreadorclose ( c )
quarterword c ;
#endif
{
/* 10 22 40 45 46 */ readfindex n, n0 ;
n = readfiles ;
n0 = readfiles ;
do {
lab22: if ( n > 0 )
decr ( n ) ;
else if ( c == 39 )
goto lab46 ;
else {
if ( n0 == readfiles )
if ( readfiles < maxreadfiles )
incr ( readfiles ) ;
else overflow ( 899 , maxreadfiles ) ;
n = n0 ;
if ( startreadinput ( curexp , n ) )
goto lab40 ;
else goto lab45 ;
}
if ( rdfname [n ]== 0 )
{
n0 = n ;
goto lab22 ;
}
} while ( ! ( strvsstr ( curexp , rdfname [n ]) == 0 ) ) ;
if ( c == 39 )
{
aclose ( rdfile [n ]) ;
goto lab45 ;
}
beginfilereading () ;
curinput .namefield = 1 ;
if ( inputln ( rdfile [n ], true ) )
goto lab40 ;
endfilereading () ;
lab45: {
if ( strref [rdfname [n ]]< 127 )
if ( strref [rdfname [n ]]> 1 )
decr ( strref [rdfname [n ]]) ;
else flushstring ( rdfname [n ]) ;
}
rdfname [n ]= 0 ;
if ( n == readfiles - 1 )
readfiles = n ;
if ( c == 39 )
goto lab46 ;
if ( eofline == 0 )
{
{
strpool [poolptr ]= 0 ;
incr ( poolptr ) ;
}
eofline = makestring () ;
strref [eofline ]= 127 ;
}
flushcurexp ( eofline ) ;
curtype = 4 ;
goto lab10 ;
lab46: flushcurexp ( 0 ) ;
curtype = 1 ;
goto lab10 ;
lab40: flushcurexp ( 0 ) ;
finishread () ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zdounary ( quarterword c )
#else
zdounary ( c )
quarterword c ;
#endif
{
halfword p, q, r ;
integer x ;
{
if ( aritherror )
cleararith () ;
}
if ( internal [6 ]> 131072L )
{
begindiagnostic () ;
printnl ( 123 ) ;
printop ( c ) ;
printchar ( 40 ) ;
printexp ( 0 , 0 ) ;
print ( 891 ) ;
enddiagnostic ( false ) ;
}
switch ( c )
{case 89 :
if ( curtype < 13 )
badunary ( 89 ) ;
break ;
case 90 :
switch ( curtype )
{case 13 :
case 14 :
case 19 :
{
q = curexp ;
makeexpcopy ( q ) ;
if ( curtype == 17 )
negatedeplist ( mem [curexp + 1 ].hhfield .v.RH ) ;
else if ( curtype <= 14 )
{
p = mem [curexp + 1 ].cint ;
r = p + bignodesize [curtype ];
do {
r = r - 2 ;
if ( mem [r ].hhfield .b0 == 16 )
mem [r + 1 ].cint = - (integer) mem [r + 1 ].cint ;
else negatedeplist ( mem [r + 1 ].hhfield .v.RH ) ;
} while ( ! ( r == p ) ) ;
}
recyclevalue ( q ) ;
freenode ( q , 2 ) ;
}
break ;
case 17 :
case 18 :
negatedeplist ( mem [curexp + 1 ].hhfield .v.RH ) ;
break ;
case 16 :
curexp = - (integer) curexp ;
break ;
default:
badunary ( 90 ) ;
break ;
}
break ;
case 43 :
if ( curtype != 2 )
badunary ( 43 ) ;
else curexp = 61 - curexp ;
break ;
case 68 :
case 69 :
case 70 :
case 71 :
case 72 :
case 73 :
case 74 :
case 40 :
case 75 :
if ( curtype != 16 )
badunary ( c ) ;
else switch ( c )
{case 68 :
curexp = squarert ( curexp ) ;
break ;
case 69 :
curexp = mexp ( curexp ) ;
break ;
case 70 :
curexp = mlog ( curexp ) ;
break ;
case 71 :
case 72 :
{
nsincos ( ( curexp % 23592960L ) * 16 ) ;
if ( c == 71 )
curexp = roundfraction ( nsin ) ;
else curexp = roundfraction ( ncos ) ;
}
break ;
case 73 :
curexp = floorscaled ( curexp ) ;
break ;
case 74 :
curexp = unifrand ( curexp ) ;
break ;
case 40 :
{
if ( odd ( roundunscaled ( curexp ) ) )
curexp = 30 ;
else curexp = 31 ;
curtype = 2 ;
}
break ;
case 75 :
{
curexp = roundunscaled ( curexp ) % 256 ;
if ( curexp < 0 )
curexp = curexp + 256 ;
if ( charexists [curexp ])
curexp = 30 ;
else curexp = 31 ;
curtype = 2 ;
}
break ;
}
break ;
case 82 :
if ( nicepair ( curexp , curtype ) )
{
p = mem [curexp + 1 ].cint ;
x = narg ( mem [p + 1 ].cint , mem [p + 3 ].cint ) ;
if ( x >= 0 )
flushcurexp ( ( x + 8 ) / 16 ) ;
else flushcurexp ( - (integer) ( ( - (integer) x + 8 ) / 16 ) ) ;
}
else badunary ( 82 ) ;
break ;
case 54 :
case 55 :
if ( ( curtype == 14 ) || ( curtype == 12 ) )
takepart ( c ) ;
else if ( curtype == 10 )
takepictpart ( c ) ;
else badunary ( c ) ;
break ;
case 56 :
case 57 :
case 58 :
case 59 :
if ( curtype == 12 )
takepart ( c ) ;
else if ( curtype == 10 )
takepictpart ( c ) ;
else badunary ( c ) ;
break ;
case 60 :
case 61 :
case 62 :
if ( curtype == 13 )
takepart ( c ) ;
else if ( curtype == 10 )
takepictpart ( c ) ;
else badunary ( c ) ;
break ;
case 63 :
case 64 :
case 65 :
case 66 :
case 67 :
if ( curtype == 10 )
takepictpart ( c ) ;
else badunary ( c ) ;
break ;
case 51 :
if ( curtype != 16 )
badunary ( 51 ) ;
else {
curexp = roundunscaled ( curexp ) % 256 ;
curtype = 4 ;
if ( curexp < 0 )
curexp = curexp + 256 ;
}
break ;
case 44 :
if ( curtype != 16 )
badunary ( 44 ) ;
else {
oldsetting = selector ;
selector = 4 ;
printscaled ( curexp ) ;
curexp = makestring () ;
selector = oldsetting ;
curtype = 4 ;
}
break ;
case 48 :
case 49 :
case 50 :
if ( curtype != 4 )
badunary ( c ) ;
else strtonum ( c ) ;
break ;
case 76 :
if ( curtype != 4 )
badunary ( 76 ) ;
else flushcurexp ( ( fontdsize [findfont ( curexp ) ]+ 8 ) / 16 ) ;
break ;
case 52 :
switch ( curtype )
{case 4 :
flushcurexp ( ( strstart [nextstr [curexp ]]- strstart [curexp ])
* 65536L ) ;
break ;
case 8 :
flushcurexp ( pathlength () ) ;
break ;
case 16 :
curexp = abs ( curexp ) ;
break ;
case 10 :
flushcurexp ( pictlength () ) ;
break ;
default:
if ( nicepair ( curexp , curtype ) )
flushcurexp ( pythadd ( mem [mem [curexp + 1 ].cint + 1 ].cint , mem
[mem [curexp + 1 ].cint + 3 ].cint ) ) ;
else badunary ( c ) ;
break ;
}
break ;
case 53 :
if ( curtype == 14 )
flushcurexp ( 0 ) ;
else if ( curtype != 8 )
badunary ( 53 ) ;
else if ( mem [curexp ].hhfield .b0 == 0 )
flushcurexp ( 0 ) ;
else {
curexp = offsetprep ( curexp , 13 ) ;
if ( internal [5 ]> 65536L )
printspec ( curexp , 13 , 898 ) ;
flushcurexp ( countturns ( curexp ) ) ;
}
break ;
case 2 :
{
if ( ( curtype >= 2 ) && ( curtype <= 3 ) )
flushcurexp ( 30 ) ;
else flushcurexp ( 31 ) ;
curtype = 2 ;
}
break ;
case 4 :
{
if ( ( curtype >= 4 ) && ( curtype <= 5 ) )
flushcurexp ( 30 ) ;
else flushcurexp ( 31 ) ;
curtype = 2 ;
}
break ;
case 6 :
{
if ( ( curtype >= 6 ) && ( curtype <= 7 ) )
flushcurexp ( 30 ) ;
else flushcurexp ( 31 ) ;
curtype = 2 ;
}
break ;
case 8 :
{
if ( ( curtype >= 8 ) && ( curtype <= 9 ) )
flushcurexp ( 30 ) ;
else flushcurexp ( 31 ) ;
curtype = 2 ;
}
break ;
case 10 :
{
if ( ( curtype >= 10 ) && ( curtype <= 11 ) )
flushcurexp ( 30 ) ;
else flushcurexp ( 31 ) ;
curtype = 2 ;
}
break ;
case 12 :
case 13 :
case 14 :
{
if ( curtype == c )
flushcurexp ( 30 ) ;
else flushcurexp ( 31 ) ;
curtype = 2 ;
}
break ;
case 15 :
{
if ( ( curtype >= 16 ) && ( curtype <= 19 ) )
flushcurexp ( 30 ) ;
else flushcurexp ( 31 ) ;
curtype = 2 ;
}
break ;
case 41 :
case 42 :
testknown ( c ) ;
break ;
case 83 :
{
if ( curtype != 8 )
flushcurexp ( 31 ) ;
else if ( mem [curexp ].hhfield .b0 != 0 )
flushcurexp ( 30 ) ;
else flushcurexp ( 31 ) ;
curtype = 2 ;
}
break ;
case 81 :
{
if ( curtype == 14 )
pairtopath () ;
if ( curtype != 8 )
badunary ( 81 ) ;
else flushcurexp ( getarclength ( curexp ) ) ;
}
break ;
case 84 :
case 85 :
case 86 :
case 87 :
case 88 :
{
if ( curtype != 10 )
flushcurexp ( 31 ) ;
else if ( mem [curexp + 7 ].hhfield .v.RH == 0 )
flushcurexp ( 31 ) ;
else if ( mem [mem [curexp + 7 ].hhfield .v.RH ].hhfield .b0 == c -
83 )
flushcurexp ( 30 ) ;
else flushcurexp ( 31 ) ;
curtype = 2 ;
}
break ;
case 47 :
{
if ( curtype == 14 )
pairtopath () ;
if ( curtype != 8 )
badunary ( 47 ) ;
else {
curtype = 6 ;
curexp = makepen ( curexp , true ) ;
}
}
break ;
case 46 :
if ( curtype != 6 )
badunary ( 46 ) ;
else {
curtype = 8 ;
makepath ( curexp ) ;
}
break ;
case 45 :
if ( curtype == 8 )
{
p = htapypoc ( curexp ) ;
if ( mem [p ].hhfield .b1 == 0 )
p = mem [p ].hhfield .v.RH ;
tossknotlist ( curexp ) ;
curexp = p ;
}
else if ( curtype == 14 )
pairtopath () ;
else badunary ( 45 ) ;
break ;
case 77 :
if ( ! getcurbbox () )
badunary ( 77 ) ;
else pairvalue ( bbmin [0 ], bbmin [1 ]) ;
break ;
case 78 :
if ( ! getcurbbox () )
badunary ( 78 ) ;
else pairvalue ( bbmax [0 ], bbmin [1 ]) ;
break ;
case 79 :
if ( ! getcurbbox () )
badunary ( 79 ) ;
else pairvalue ( bbmin [0 ], bbmax [1 ]) ;
break ;
case 80 :
if ( ! getcurbbox () )
badunary ( 80 ) ;
else pairvalue ( bbmax [0 ], bbmax [1 ]) ;
break ;
case 38 :
case 39 :
if ( curtype != 4 )
badunary ( c ) ;
else doreadorclose ( c ) ;
break ;
}
{
if ( aritherror )
cleararith () ;
}
}
void
#ifdef HAVE_PROTOTYPES
zbadbinary ( halfword p , quarterword c )
#else
zbadbinary ( p , c )
halfword p ;
quarterword c ;
#endif
{
disperr ( p , 284 ) ;
disperr ( 0 , 887 ) ;
if ( c >= 115 )
printop ( c ) ;
printknownorunknowntype ( mem [p ].hhfield .b0 , p ) ;
if ( c >= 115 )
print ( 489 ) ;
else printop ( c ) ;
printknownorunknowntype ( curtype , curexp ) ;
{
helpptr = 3 ;
helpline [2 ]= 888 ;
helpline [1 ]= 900 ;
helpline [0 ]= 901 ;
}
putgeterror () ;
}
halfword
#ifdef HAVE_PROTOTYPES
ztarnished ( halfword p )
#else
ztarnished ( p )
halfword p ;
#endif
{
/* 10 */ register halfword Result; halfword q ;
halfword r ;
q = mem [p + 1 ].cint ;
r = q + bignodesize [mem [p ].hhfield .b0 ];
do {
r = r - 2 ;
if ( mem [r ].hhfield .b0 == 19 )
{
Result = 1 ;
goto lab10 ;
}
} while ( ! ( r == q ) ) ;
Result = 0 ;
lab10: ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zdepfinish ( halfword v , halfword q , smallnumber t )
#else
zdepfinish ( v , q , t )
halfword v ;
halfword q ;
smallnumber t ;
#endif
{
halfword p ;
scaled vv ;
if ( q == 0 )
p = curexp ;
else p = q ;
mem [p + 1 ].hhfield .v.RH = v ;
mem [p ].hhfield .b0 = t ;
if ( mem [v ].hhfield .lhfield == 0 )
{
vv = mem [v + 1 ].cint ;
if ( q == 0 )
flushcurexp ( vv ) ;
else {
recyclevalue ( p ) ;
mem [q ].hhfield .b0 = 16 ;
mem [q + 1 ].cint = vv ;
}
}
else if ( q == 0 )
curtype = t ;
if ( fixneeded )
fixdependencies () ;
}
void
#ifdef HAVE_PROTOTYPES
zaddorsubtract ( halfword p , halfword q , quarterword c )
#else
zaddorsubtract ( p , q , c )
halfword p ;
halfword q ;
quarterword c ;
#endif
{
/* 30 10 */ smallnumber s, t ;
halfword r ;
integer v ;
if ( q == 0 )
{
t = curtype ;
if ( t < 17 )
v = curexp ;
else v = mem [curexp + 1 ].hhfield .v.RH ;
}
else {
t = mem [q ].hhfield .b0 ;
if ( t < 17 )
v = mem [q + 1 ].cint ;
else v = mem [q + 1 ].hhfield .v.RH ;
}
if ( t == 16 )
{
if ( c == 90 )
v = - (integer) v ;
if ( mem [p ].hhfield .b0 == 16 )
{
v = slowadd ( mem [p + 1 ].cint , v ) ;
if ( q == 0 )
curexp = v ;
else mem [q + 1 ].cint = v ;
goto lab10 ;
}
r = mem [p + 1 ].hhfield .v.RH ;
while ( mem [r ].hhfield .lhfield != 0 ) r = mem [r ].hhfield .v.RH ;
mem [r + 1 ].cint = slowadd ( mem [r + 1 ].cint , v ) ;
if ( q == 0 )
{
q = getnode ( 2 ) ;
curexp = q ;
curtype = mem [p ].hhfield .b0 ;
mem [q ].hhfield .b1 = 14 ;
}
mem [q + 1 ].hhfield .v.RH = mem [p + 1 ].hhfield .v.RH ;
mem [q ].hhfield .b0 = mem [p ].hhfield .b0 ;
mem [q + 1 ].hhfield .lhfield = mem [p + 1 ].hhfield .lhfield ;
mem [mem [p + 1 ].hhfield .lhfield ].hhfield .v.RH = q ;
mem [p ].hhfield .b0 = 16 ;
}
else {
if ( c == 90 )
negatedeplist ( v ) ;
if ( mem [p ].hhfield .b0 == 16 )
{
while ( mem [v ].hhfield .lhfield != 0 ) v = mem [v ].hhfield .v.RH
;
mem [v + 1 ].cint = slowadd ( mem [p + 1 ].cint , mem [v + 1 ]
.cint ) ;
}
else {
s = mem [p ].hhfield .b0 ;
r = mem [p + 1 ].hhfield .v.RH ;
if ( t == 17 )
{
if ( s == 17 )
if ( maxcoef ( r ) + maxcoef ( v ) < 626349397L )
{
v = pplusq ( v , r , 17 ) ;
goto lab30 ;
}
t = 18 ;
v = poverv ( v , 65536L , 17 , 18 ) ;
}
if ( s == 18 )
v = pplusq ( v , r , 18 ) ;
else v = pplusfq ( v , 65536L , r , 18 , 17 ) ;
lab30: if ( q != 0 )
depfinish ( v , q , t ) ;
else {
curtype = t ;
depfinish ( v , 0 , t ) ;
}
}
}
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zdepmult ( halfword p , integer v , boolean visscaled )
#else
zdepmult ( p , v , visscaled )
halfword p ;
integer v ;
boolean visscaled ;
#endif
{
/* 10 */ halfword q ;
smallnumber s, t ;
if ( p == 0 )
q = curexp ;
else if ( mem [p ].hhfield .b0 != 16 )
q = p ;
else {
if ( visscaled )
mem [p + 1 ].cint = takescaled ( mem [p + 1 ].cint , v ) ;
else mem [p + 1 ].cint = takefraction ( mem [p + 1 ].cint , v ) ;
goto lab10 ;
}
t = mem [q ].hhfield .b0 ;
q = mem [q + 1 ].hhfield .v.RH ;
s = t ;
if ( t == 17 )
if ( visscaled )
if ( abvscd ( maxcoef ( q ) , abs ( v ) , 626349396L , 65536L ) >= 0 )
t = 18 ;
q = ptimesv ( q , v , s , t , visscaled ) ;
depfinish ( q , p , t ) ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zhardtimes ( halfword p )
#else
zhardtimes ( p )
halfword p ;
#endif
{
/* 30 */ halfword q ;
halfword r ;
scaled v ;
if ( mem [p ].hhfield .b0 <= 14 )
{
q = stashcurexp () ;
unstashcurexp ( p ) ;
p = q ;
}
r = mem [curexp + 1 ].cint + bignodesize [curtype ];
while ( true ) {
r = r - 2 ;
v = mem [r + 1 ].cint ;
mem [r ].hhfield .b0 = mem [p ].hhfield .b0 ;
if ( r == mem [curexp + 1 ].cint )
goto lab30 ;
newdep ( r , copydeplist ( mem [p + 1 ].hhfield .v.RH ) ) ;
depmult ( r , v , true ) ;
}
lab30: mem [r + 1 ]= mem [p + 1 ];
mem [mem [p + 1 ].hhfield .lhfield ].hhfield .v.RH = r ;
freenode ( p , 2 ) ;
depmult ( r , v , true ) ;
}
void
#ifdef HAVE_PROTOTYPES
zdepdiv ( halfword p , scaled v )
#else
zdepdiv ( p , v )
halfword p ;
scaled v ;
#endif
{
/* 10 */ halfword q ;
smallnumber s, t ;
if ( p == 0 )
q = curexp ;
else if ( mem [p ].hhfield .b0 != 16 )
q = p ;
else {
mem [p + 1 ].cint = makescaled ( mem [p + 1 ].cint , v ) ;
goto lab10 ;
}
t = mem [q ].hhfield .b0 ;
q = mem [q + 1 ].hhfield .v.RH ;
s = t ;
if ( t == 17 )
if ( abvscd ( maxcoef ( q ) , 65536L , 626349396L , abs ( v ) ) >= 0 )
t = 18 ;
q = poverv ( q , v , s , t ) ;
depfinish ( q , p , t ) ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zsetuptrans ( quarterword c )
#else
zsetuptrans ( c )
quarterword c ;
#endif
{
/* 30 10 */ halfword p, q, r ;
if ( ( c != 108 ) || ( curtype != 12 ) )
{
p = stashcurexp () ;
curexp = idtransform () ;
curtype = 12 ;
q = mem [curexp + 1 ].cint ;
switch ( c )
{case 104 :
if ( mem [p ].hhfield .b0 == 16 )
{
nsincos ( ( mem [p + 1 ].cint % 23592960L ) * 16 ) ;
mem [q + 5 ].cint = roundfraction ( ncos ) ;
mem [q + 9 ].cint = roundfraction ( nsin ) ;
mem [q + 7 ].cint = - (integer) mem [q + 9 ].cint ;
mem [q + 11 ].cint = mem [q + 5 ].cint ;
goto lab30 ;
}
break ;
case 105 :
if ( mem [p ].hhfield .b0 > 14 )
{
install ( q + 6 , p ) ;
goto lab30 ;
}
break ;
case 106 :
if ( mem [p ].hhfield .b0 > 14 )
{
install ( q + 4 , p ) ;
install ( q + 10 , p ) ;
goto lab30 ;
}
break ;
case 107 :
if ( mem [p ].hhfield .b0 == 14 )
{
r = mem [p + 1 ].cint ;
install ( q , r ) ;
install ( q + 2 , r + 2 ) ;
goto lab30 ;
}
break ;
case 109 :
if ( mem [p ].hhfield .b0 > 14 )
{
install ( q + 4 , p ) ;
goto lab30 ;
}
break ;
case 110 :
if ( mem [p ].hhfield .b0 > 14 )
{
install ( q + 10 , p ) ;
goto lab30 ;
}
break ;
case 111 :
if ( mem [p ].hhfield .b0 == 14 )
{
r = mem [p + 1 ].cint ;
install ( q + 4 , r ) ;
install ( q + 10 , r ) ;
install ( q + 8 , r + 2 ) ;
if ( mem [r + 2 ].hhfield .b0 == 16 )
mem [r + 3 ].cint = - (integer) mem [r + 3 ].cint ;
else negatedeplist ( mem [r + 3 ].hhfield .v.RH ) ;
install ( q + 6 , r + 2 ) ;
goto lab30 ;
}
break ;
case 108 :
;
break ;
}
disperr ( p , 910 ) ;
{
helpptr = 3 ;
helpline [2 ]= 911 ;
helpline [1 ]= 912 ;
helpline [0 ]= 913 ;
}
putgeterror () ;
lab30: recyclevalue ( p ) ;
freenode ( p , 2 ) ;
}
q = mem [curexp + 1 ].cint ;
r = q + 12 ;
do {
r = r - 2 ;
if ( mem [r ].hhfield .b0 != 16 )
goto lab10 ;
} while ( ! ( r == q ) ) ;
txx = mem [q + 5 ].cint ;
txy = mem [q + 7 ].cint ;
tyx = mem [q + 9 ].cint ;
tyy = mem [q + 11 ].cint ;
tx = mem [q + 1 ].cint ;
ty = mem [q + 3 ].cint ;
flushcurexp ( 0 ) ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zsetupknowntrans ( quarterword c )
#else
zsetupknowntrans ( c )
quarterword c ;
#endif
{
setuptrans ( c ) ;
if ( curtype != 16 )
{
disperr ( 0 , 914 ) ;
{
helpptr = 3 ;
helpline [2 ]= 915 ;
helpline [1 ]= 916 ;
helpline [0 ]= 913 ;
}
putgetflusherror ( 0 ) ;
txx = 65536L ;
txy = 0 ;
tyx = 0 ;
tyy = 65536L ;
tx = 0 ;
ty = 0 ;
}
}
void
#ifdef HAVE_PROTOTYPES
ztrans ( halfword p , halfword q )
#else
ztrans ( p , q )
halfword p ;
halfword q ;
#endif
{
scaled v ;
v = takescaled ( mem [p ].cint , txx ) + takescaled ( mem [q ].cint ,
txy ) + tx ;
mem [q ].cint = takescaled ( mem [p ].cint , tyx ) + takescaled ( mem [
q ].cint , tyy ) + ty ;
mem [p ].cint = v ;
}
void
#ifdef HAVE_PROTOTYPES
zdopathtrans ( halfword p )
#else
zdopathtrans ( p )
halfword p ;
#endif
{
/* 10 */ halfword q ;
q = p ;
do {
if ( mem [q ].hhfield .b0 != 0 )
trans ( q + 3 , q + 4 ) ;
trans ( q + 1 , q + 2 ) ;
if ( mem [q ].hhfield .b1 != 0 )
trans ( q + 5 , q + 6 ) ;
q = mem [q ].hhfield .v.RH ;
} while ( ! ( q == p ) ) ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zdopentrans ( halfword p )
#else
zdopentrans ( p )
halfword p ;
#endif
{
/* 10 */ halfword q ;
if ( ( p == mem [p ].hhfield .v.RH ) )
{
trans ( p + 3 , p + 4 ) ;
trans ( p + 5 , p + 6 ) ;
}
q = p ;
do {
trans ( q + 1 , q + 2 ) ;
q = mem [q ].hhfield .v.RH ;
} while ( ! ( q == p ) ) ;
lab10: ;
}
halfword
#ifdef HAVE_PROTOTYPES
zedgestrans ( halfword h )
#else
zedgestrans ( h )
halfword h ;
#endif
{
/* 31 */ register halfword Result; halfword q ;
halfword r, s ;
scaled sx, sy ;
scaled sqdet ;
integer sgndet ;
scaled v ;
h = privateedges ( h ) ;
sqdet = sqrtdet ( txx , txy , tyx , tyy ) ;
sgndet = abvscd ( txx , tyy , txy , tyx ) ;
if ( mem [h ].hhfield .v.RH != 2 )
if ( ( txy != 0 ) || ( tyx != 0 ) || ( ty != 0 ) || ( abs ( txx ) != abs (
tyy ) ) )
flushdashlist ( h ) ;
else {
if ( txx < 0 )
{
r = mem [h ].hhfield .v.RH ;
mem [h ].hhfield .v.RH = 2 ;
while ( r != 2 ) {
s = r ;
r = mem [r ].hhfield .v.RH ;
v = mem [s + 1 ].cint ;
mem [s + 1 ].cint = mem [s + 2 ].cint ;
mem [s + 2 ].cint = v ;
mem [s ].hhfield .v.RH = mem [h ].hhfield .v.RH ;
mem [h ].hhfield .v.RH = s ;
}
}
r = mem [h ].hhfield .v.RH ;
while ( r != 2 ) {
mem [r + 1 ].cint = takescaled ( mem [r + 1 ].cint , txx ) + tx ;
mem [r + 2 ].cint = takescaled ( mem [r + 2 ].cint , txx ) + tx ;
r = mem [r ].hhfield .v.RH ;
}
mem [h + 1 ].cint = takescaled ( mem [h + 1 ].cint , abs ( tyy ) ) ;
}
if ( ( txx == 0 ) && ( tyy == 0 ) )
{
v = mem [h + 2 ].cint ;
mem [h + 2 ].cint = mem [h + 3 ].cint ;
mem [h + 3 ].cint = v ;
v = mem [h + 4 ].cint ;
mem [h + 4 ].cint = mem [h + 5 ].cint ;
mem [h + 5 ].cint = v ;
}
else if ( ( txy != 0 ) || ( tyx != 0 ) )
{
initbbox ( h ) ;
goto lab31 ;
}
if ( mem [h + 2 ].cint <= mem [h + 4 ].cint )
{
mem [h + 2 ].cint = takescaled ( mem [h + 2 ].cint , txx + txy ) + tx
;
mem [h + 4 ].cint = takescaled ( mem [h + 4 ].cint , txx + txy ) + tx
;
mem [h + 3 ].cint = takescaled ( mem [h + 3 ].cint , tyx + tyy ) + ty
;
mem [h + 5 ].cint = takescaled ( mem [h + 5 ].cint , tyx + tyy ) + ty
;
if ( txx + txy < 0 )
{
v = mem [h + 2 ].cint ;
mem [h + 2 ].cint = mem [h + 4 ].cint ;
mem [h + 4 ].cint = v ;
}
if ( tyx + tyy < 0 )
{
v = mem [h + 3 ].cint ;
mem [h + 3 ].cint = mem [h + 5 ].cint ;
mem [h + 5 ].cint = v ;
}
}
lab31: ;
q = mem [h + 7 ].hhfield .v.RH ;
while ( q != 0 ) {
switch ( mem [q ].hhfield .b0 )
{case 1 :
case 2 :
{
dopathtrans ( mem [q + 1 ].hhfield .v.RH ) ;
if ( mem [q + 1 ].hhfield .lhfield != 0 )
{
sx = tx ;
sy = ty ;
tx = 0 ;
ty = 0 ;
dopentrans ( mem [q + 1 ].hhfield .lhfield ) ;
if ( ( ( mem [q ].hhfield .b0 == 2 ) && ( mem [q + 6 ].hhfield
.v.RH != 0 ) ) )
mem [q + 7 ].cint = takescaled ( mem [q + 7 ].cint , sqdet ) ;
if ( ! ( mem [q + 1 ].hhfield .lhfield == mem [mem [q + 1 ]
.hhfield .lhfield ].hhfield .v.RH ) )
if ( sgndet < 0 )
mem [q + 1 ].hhfield .lhfield = makepen ( copypath ( mem [q + 1 ]
.hhfield .lhfield ) , true ) ;
tx = sx ;
ty = sy ;
}
}
break ;
case 4 :
case 5 :
dopathtrans ( mem [q + 1 ].hhfield .v.RH ) ;
break ;
case 3 :
{
r = q + 8 ;
trans ( r , r + 1 ) ;
sx = tx ;
sy = ty ;
tx = 0 ;
ty = 0 ;
trans ( r + 2 , r + 4 ) ;
trans ( r + 3 , r + 5 ) ;
tx = sx ;
ty = sy ;
}
break ;
case 6 :
case 7 :
;
break ;
}
q = mem [q ].hhfield .v.RH ;
}
Result = h ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zdoedgestrans ( halfword p , quarterword c )
#else
zdoedgestrans ( p , c )
halfword p ;
quarterword c ;
#endif
{
setupknowntrans ( c ) ;
mem [p + 1 ].cint = edgestrans ( mem [p + 1 ].cint ) ;
unstashcurexp ( p ) ;
}
void
#ifdef HAVE_PROTOTYPES
scaleedges ( void )
#else
scaleedges ( )
#endif
{
txx = sesf ;
tyy = sesf ;
txy = 0 ;
tyx = 0 ;
tx = 0 ;
ty = 0 ;
sepic = edgestrans ( sepic ) ;
}
void
#ifdef HAVE_PROTOTYPES
zbilin1 ( halfword p , scaled t , halfword q , scaled u , scaled delta )
#else
zbilin1 ( p , t , q , u , delta )
halfword p ;
scaled t ;
halfword q ;
scaled u ;
scaled delta ;
#endif
{
halfword r ;
if ( t != 65536L )
depmult ( p , t , true ) ;
if ( u != 0 )
if ( mem [q ].hhfield .b0 == 16 )
delta = delta + takescaled ( mem [q + 1 ].cint , u ) ;
else {
if ( mem [p ].hhfield .b0 != 18 )
{
if ( mem [p ].hhfield .b0 == 16 )
newdep ( p , constdependency ( mem [p + 1 ].cint ) ) ;
else mem [p + 1 ].hhfield .v.RH = ptimesv ( mem [p + 1 ].hhfield
.v.RH , 65536L , 17 , 18 , true ) ;
mem [p ].hhfield .b0 = 18 ;
}
mem [p + 1 ].hhfield .v.RH = pplusfq ( mem [p + 1 ].hhfield .v.RH , u
, mem [q + 1 ].hhfield .v.RH , 18 , mem [q ].hhfield .b0 ) ;
}
if ( mem [p ].hhfield .b0 == 16 )
mem [p + 1 ].cint = mem [p + 1 ].cint + delta ;
else {
r = mem [p + 1 ].hhfield .v.RH ;
while ( mem [r ].hhfield .lhfield != 0 ) r = mem [r ].hhfield .v.RH ;
delta = mem [r + 1 ].cint + delta ;
if ( r != mem [p + 1 ].hhfield .v.RH )
mem [r + 1 ].cint = delta ;
else {
recyclevalue ( p ) ;
mem [p ].hhfield .b0 = 16 ;
mem [p + 1 ].cint = delta ;
}
}
if ( fixneeded )
fixdependencies () ;
}
void
#ifdef HAVE_PROTOTYPES
zaddmultdep ( halfword p , scaled v , halfword r )
#else
zaddmultdep ( p , v , r )
halfword p ;
scaled v ;
halfword r ;
#endif
{
if ( mem [r ].hhfield .b0 == 16 )
mem [depfinal + 1 ].cint = mem [depfinal + 1 ].cint + takescaled ( mem [
r + 1 ].cint , v ) ;
else {
mem [p + 1 ].hhfield .v.RH = pplusfq ( mem [p + 1 ].hhfield .v.RH , v
, mem [r + 1 ].hhfield .v.RH , 18 , mem [r ].hhfield .b0 ) ;
if ( fixneeded )
fixdependencies () ;
}
}
void
#ifdef HAVE_PROTOTYPES
zbilin2 ( halfword p , halfword t , scaled v , halfword u , halfword q )
#else
zbilin2 ( p , t , v , u , q )
halfword p ;
halfword t ;
scaled v ;
halfword u ;
halfword q ;
#endif
{
scaled vv ;
vv = mem [p + 1 ].cint ;
mem [p ].hhfield .b0 = 18 ;
newdep ( p , constdependency ( 0 ) ) ;
if ( vv != 0 )
addmultdep ( p , vv , t ) ;
if ( v != 0 )
addmultdep ( p , v , u ) ;
if ( q != 0 )
addmultdep ( p , 65536L , q ) ;
if ( mem [p + 1 ].hhfield .v.RH == depfinal )
{
vv = mem [depfinal + 1 ].cint ;
recyclevalue ( p ) ;
mem [p ].hhfield .b0 = 16 ;
mem [p + 1 ].cint = vv ;
}
}
void
#ifdef HAVE_PROTOTYPES
zbilin3 ( halfword p , scaled t , scaled v , scaled u , scaled delta )
#else
zbilin3 ( p , t , v , u , delta )
halfword p ;
scaled t ;
scaled v ;
scaled u ;
scaled delta ;
#endif
{
if ( t != 65536L )
delta = delta + takescaled ( mem [p + 1 ].cint , t ) ;
else delta = delta + mem [p + 1 ].cint ;
if ( u != 0 )
mem [p + 1 ].cint = delta + takescaled ( v , u ) ;
else mem [p + 1 ].cint = delta ;
}
void
#ifdef HAVE_PROTOTYPES
zbigtrans ( halfword p , quarterword c )
#else
zbigtrans ( p , c )
halfword p ;
quarterword c ;
#endif
{
/* 10 */ halfword q, r, pp, qq ;
smallnumber s ;
s = bignodesize [mem [p ].hhfield .b0 ];
q = mem [p + 1 ].cint ;
r = q + s ;
do {
r = r - 2 ;
if ( mem [r ].hhfield .b0 != 16 )
{
setupknowntrans ( c ) ;
makeexpcopy ( p ) ;
r = mem [curexp + 1 ].cint ;
if ( curtype == 12 )
{
bilin1 ( r + 10 , tyy , q + 6 , tyx , 0 ) ;
bilin1 ( r + 8 , tyy , q + 4 , tyx , 0 ) ;
bilin1 ( r + 6 , txx , q + 10 , txy , 0 ) ;
bilin1 ( r + 4 , txx , q + 8 , txy , 0 ) ;
}
bilin1 ( r + 2 , tyy , q , tyx , ty ) ;
bilin1 ( r , txx , q + 2 , txy , tx ) ;
goto lab10 ;
}
} while ( ! ( r == q ) ) ;
setuptrans ( c ) ;
if ( curtype == 16 )
{
makeexpcopy ( p ) ;
r = mem [curexp + 1 ].cint ;
if ( curtype == 12 )
{
bilin3 ( r + 10 , tyy , mem [q + 7 ].cint , tyx , 0 ) ;
bilin3 ( r + 8 , tyy , mem [q + 5 ].cint , tyx , 0 ) ;
bilin3 ( r + 6 , txx , mem [q + 11 ].cint , txy , 0 ) ;
bilin3 ( r + 4 , txx , mem [q + 9 ].cint , txy , 0 ) ;
}
bilin3 ( r + 2 , tyy , mem [q + 1 ].cint , tyx , ty ) ;
bilin3 ( r , txx , mem [q + 3 ].cint , txy , tx ) ;
}
else {
pp = stashcurexp () ;
qq = mem [pp + 1 ].cint ;
makeexpcopy ( p ) ;
r = mem [curexp + 1 ].cint ;
if ( curtype == 12 )
{
bilin2 ( r + 10 , qq + 10 , mem [q + 7 ].cint , qq + 8 , 0 ) ;
bilin2 ( r + 8 , qq + 10 , mem [q + 5 ].cint , qq + 8 , 0 ) ;
bilin2 ( r + 6 , qq + 4 , mem [q + 11 ].cint , qq + 6 , 0 ) ;
bilin2 ( r + 4 , qq + 4 , mem [q + 9 ].cint , qq + 6 , 0 ) ;
}
bilin2 ( r + 2 , qq + 10 , mem [q + 1 ].cint , qq + 8 , qq + 2 ) ;
bilin2 ( r , qq + 4 , mem [q + 3 ].cint , qq + 6 , qq ) ;
recyclevalue ( pp ) ;
freenode ( pp , 2 ) ;
}
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zcat ( halfword p )
#else
zcat ( p )
halfword p ;
#endif
{
strnumber a, b ;
poolpointer k ;
a = mem [p + 1 ].cint ;
b = curexp ;
{
if ( poolptr + ( strstart [nextstr [a ]]- strstart [a ]) + (
strstart [nextstr [b ]]- strstart [b ]) > maxpoolptr )
if ( poolptr + ( strstart [nextstr [a ]]- strstart [a ]) + (
strstart [nextstr [b ]]- strstart [b ]) > poolsize )
docompaction ( ( strstart [nextstr [a ]]- strstart [a ]) + (
strstart [nextstr [b ]]- strstart [b ]) ) ;
else maxpoolptr = poolptr + ( strstart [nextstr [a ]]- strstart [a ]
) + ( strstart [nextstr [b ]]- strstart [b ]) ;
}
{register integer for_end; k = strstart [a ];for_end = strstart [
nextstr [a ]]- 1 ; if ( k <= for_end) do
{
strpool [poolptr ]= strpool [k ];
incr ( poolptr ) ;
}
while ( k++ < for_end ) ;}
{register integer for_end; k = strstart [b ];for_end = strstart [
nextstr [b ]]- 1 ; if ( k <= for_end) do
{
strpool [poolptr ]= strpool [k ];
incr ( poolptr ) ;
}
while ( k++ < for_end ) ;}
curexp = makestring () ;
{
if ( strref [b ]< 127 )
if ( strref [b ]> 1 )
decr ( strref [b ]) ;
else flushstring ( b ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zchopstring ( halfword p )
#else
zchopstring ( p )
halfword p ;
#endif
{
integer a, b ;
integer l ;
integer k ;
strnumber s ;
boolean reversed ;
a = roundunscaled ( mem [p + 1 ].cint ) ;
b = roundunscaled ( mem [p + 3 ].cint ) ;
if ( a <= b )
reversed = false ;
else {
reversed = true ;
k = a ;
a = b ;
b = k ;
}
s = curexp ;
l = ( strstart [nextstr [s ]]- strstart [s ]) ;
if ( a < 0 )
{
a = 0 ;
if ( b < 0 )
b = 0 ;
}
if ( b > l )
{
b = l ;
if ( a > l )
a = l ;
}
{
if ( poolptr + b - a > maxpoolptr )
if ( poolptr + b - a > poolsize )
docompaction ( b - a ) ;
else maxpoolptr = poolptr + b - a ;
}
if ( reversed )
{register integer for_end; k = strstart [s ]+ b - 1 ;for_end = strstart
[s ]+ a ; if ( k >= for_end) do
{
strpool [poolptr ]= strpool [k ];
incr ( poolptr ) ;
}
while ( k-- > for_end ) ;}
else {
register integer for_end; k = strstart [s ]+ a ;for_end = strstart
[s ]+ b - 1 ; if ( k <= for_end) do
{
strpool [poolptr ]= strpool [k ];
incr ( poolptr ) ;
}
while ( k++ < for_end ) ;}
curexp = makestring () ;
{
if ( strref [s ]< 127 )
if ( strref [s ]> 1 )
decr ( strref [s ]) ;
else flushstring ( s ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zchoppath ( halfword p )
#else
zchoppath ( p )
halfword p ;
#endif
{
halfword q ;
halfword pp, qq, rr, ss ;
scaled a, b, k, l ;
boolean reversed ;
l = pathlength () ;
a = mem [p + 1 ].cint ;
b = mem [p + 3 ].cint ;
if ( a <= b )
reversed = false ;
else {
reversed = true ;
k = a ;
a = b ;
b = k ;
}
if ( a < 0 )
if ( mem [curexp ].hhfield .b0 == 0 )
{
a = 0 ;
if ( b < 0 )
b = 0 ;
}
else do {
a = a + l ;
b = b + l ;
} while ( ! ( a >= 0 ) ) ;
if ( b > l )
if ( mem [curexp ].hhfield .b0 == 0 )
{
b = l ;
if ( a > l )
a = l ;
}
else while ( a >= l ) {
a = a - l ;
b = b - l ;
}
q = curexp ;
while ( a >= 65536L ) {
q = mem [q ].hhfield .v.RH ;
a = a - 65536L ;
b = b - 65536L ;
}
if ( b == a )
{
if ( a > 0 )
{
splitcubic ( q , a * 4096 ) ;
q = mem [q ].hhfield .v.RH ;
}
pp = copyknot ( q ) ;
qq = pp ;
}
else {
pp = copyknot ( q ) ;
qq = pp ;
do {
q = mem [q ].hhfield .v.RH ;
rr = qq ;
qq = copyknot ( q ) ;
mem [rr ].hhfield .v.RH = qq ;
b = b - 65536L ;
} while ( ! ( b <= 0 ) ) ;
if ( a > 0 )
{
ss = pp ;
pp = mem [pp ].hhfield .v.RH ;
splitcubic ( ss , a * 4096 ) ;
pp = mem [ss ].hhfield .v.RH ;
freenode ( ss , 7 ) ;
if ( rr == ss )
{
b = makescaled ( b , 65536L - a ) ;
rr = pp ;
}
}
if ( b < 0 )
{
splitcubic ( rr , ( b + 65536L ) * 4096 ) ;
freenode ( qq , 7 ) ;
qq = mem [rr ].hhfield .v.RH ;
}
}
mem [pp ].hhfield .b0 = 0 ;
mem [qq ].hhfield .b1 = 0 ;
mem [qq ].hhfield .v.RH = pp ;
tossknotlist ( curexp ) ;
if ( reversed )
{
curexp = mem [htapypoc ( pp ) ].hhfield .v.RH ;
tossknotlist ( pp ) ;
}
else curexp = pp ;
}
void
#ifdef HAVE_PROTOTYPES
zsetupoffset ( halfword p )
#else
zsetupoffset ( p )
halfword p ;
#endif
{
findoffset ( mem [p + 1 ].cint , mem [p + 3 ].cint , curexp ) ;
pairvalue ( curx , cury ) ;
}
void
#ifdef HAVE_PROTOTYPES
zsetupdirectiontime ( halfword p )
#else
zsetupdirectiontime ( p )
halfword p ;
#endif
{
flushcurexp ( finddirectiontime ( mem [p + 1 ].cint , mem [p + 3 ]
.cint , curexp ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
zfindpoint ( scaled v , quarterword c )
#else
zfindpoint ( v , c )
scaled v ;
quarterword c ;
#endif
{
halfword p ;
scaled n ;
p = curexp ;
if ( mem [p ].hhfield .b0 == 0 )
n = -65536L ;
else n = 0 ;
do {
p = mem [p ].hhfield .v.RH ;
n = n + 65536L ;
} while ( ! ( p == curexp ) ) ;
if ( n == 0 )
v = 0 ;
else if ( v < 0 )
if ( mem [p ].hhfield .b0 == 0 )
v = 0 ;
else v = n - 1 - ( ( - (integer) v - 1 ) % n ) ;
else if ( v > n )
if ( mem [p ].hhfield .b0 == 0 )
v = n ;
else v = v % n ;
p = curexp ;
while ( v >= 65536L ) {
p = mem [p ].hhfield .v.RH ;
v = v - 65536L ;
}
if ( v != 0 )
{
splitcubic ( p , v * 4096 ) ;
p = mem [p ].hhfield .v.RH ;
}
switch ( c )
{case 118 :
pairvalue ( mem [p + 1 ].cint , mem [p + 2 ].cint ) ;
break ;
case 119 :
if ( mem [p ].hhfield .b0 == 0 )
pairvalue ( mem [p + 1 ].cint , mem [p + 2 ].cint ) ;
else pairvalue ( mem [p + 3 ].cint , mem [p + 4 ].cint ) ;
break ;
case 120 :
if ( mem [p ].hhfield .b1 == 0 )
pairvalue ( mem [p + 1 ].cint , mem [p + 2 ].cint ) ;
else pairvalue ( mem [p + 5 ].cint , mem [p + 6 ].cint ) ;
break ;
}
}
void
#ifdef HAVE_PROTOTYPES
zdoinfont ( halfword p )
#else
zdoinfont ( p )
halfword p ;
#endif
{
halfword q ;
q = getnode ( 8 ) ;
initedges ( q ) ;
mem [mem [q + 7 ].hhfield .lhfield ].hhfield .v.RH = newtextnode (
curexp , mem [p + 1 ].cint ) ;
mem [q + 7 ].hhfield .lhfield = mem [mem [q + 7 ].hhfield .lhfield ]
.hhfield .v.RH ;
freenode ( p , 2 ) ;
flushcurexp ( q ) ;
curtype = 10 ;
}
void
#ifdef HAVE_PROTOTYPES
zdobinary ( halfword p , quarterword c )
#else
zdobinary ( p , c )
halfword p ;
quarterword c ;
#endif
{
/* 30 31 10 */ halfword q, r, rr ;
halfword oldp, oldexp ;
integer v ;
{
if ( aritherror )
cleararith () ;
}
if ( internal [6 ]> 131072L )
{
begindiagnostic () ;
printnl ( 902 ) ;
printexp ( p , 0 ) ;
printchar ( 41 ) ;
printop ( c ) ;
printchar ( 40 ) ;
printexp ( 0 , 0 ) ;
print ( 891 ) ;
enddiagnostic ( false ) ;
}
switch ( mem [p ].hhfield .b0 )
{case 12 :
case 13 :
case 14 :
oldp = tarnished ( p ) ;
break ;
case 19 :
oldp = 1 ;
break ;
default:
oldp = 0 ;
break ;
}
if ( oldp != 0 )
{
q = stashcurexp () ;
oldp = p ;
makeexpcopy ( oldp ) ;
p = stashcurexp () ;
unstashcurexp ( q ) ;
}
switch ( curtype )
{case 12 :
case 13 :
case 14 :
oldexp = tarnished ( curexp ) ;
break ;
case 19 :
oldexp = 1 ;
break ;
default:
oldexp = 0 ;
break ;
}
if ( oldexp != 0 )
{
oldexp = curexp ;
makeexpcopy ( oldexp ) ;
}
switch ( c )
{case 89 :
case 90 :
if ( ( curtype < 13 ) || ( mem [p ].hhfield .b0 < 13 ) )
badbinary ( p , c ) ;
else if ( ( curtype > 14 ) && ( mem [p ].hhfield .b0 > 14 ) )
addorsubtract ( p , 0 , c ) ;
else if ( curtype != mem [p ].hhfield .b0 )
badbinary ( p , c ) ;
else {
q = mem [p + 1 ].cint ;
r = mem [curexp + 1 ].cint ;
rr = r + bignodesize [curtype ];
while ( r < rr ) {
addorsubtract ( q , r , c ) ;
q = q + 2 ;
r = r + 2 ;
}
}
break ;
case 97 :
case 98 :
case 99 :
case 100 :
case 101 :
case 102 :
{
{
if ( aritherror )
cleararith () ;
}
if ( ( curtype > 14 ) && ( mem [p ].hhfield .b0 > 14 ) )
addorsubtract ( p , 0 , 90 ) ;
else if ( curtype != mem [p ].hhfield .b0 )
{
badbinary ( p , c ) ;
goto lab30 ;
}
else if ( curtype == 4 )
flushcurexp ( strvsstr ( mem [p + 1 ].cint , curexp ) ) ;
else if ( ( curtype == 5 ) || ( curtype == 3 ) )
{
q = mem [curexp + 1 ].cint ;
while ( ( q != curexp ) && ( q != p ) ) q = mem [q + 1 ].cint ;
if ( q == p )
flushcurexp ( 0 ) ;
}
else if ( ( curtype <= 14 ) && ( curtype >= 12 ) )
{
q = mem [p + 1 ].cint ;
r = mem [curexp + 1 ].cint ;
rr = r + bignodesize [curtype ]- 2 ;
while ( true ) {
addorsubtract ( q , r , 90 ) ;
if ( mem [r ].hhfield .b0 != 16 )
goto lab31 ;
if ( mem [r + 1 ].cint != 0 )
goto lab31 ;
if ( r == rr )
goto lab31 ;
q = q + 2 ;
r = r + 2 ;
}
lab31: takepart ( mem [r ].hhfield .b1 + 49 ) ;
}
else if ( curtype == 2 )
flushcurexp ( curexp - mem [p + 1 ].cint ) ;
else {
badbinary ( p , c ) ;
goto lab30 ;
}
if ( curtype != 16 )
{
if ( curtype < 16 )
{
disperr ( p , 284 ) ;
{
helpptr = 1 ;
helpline [0 ]= 903 ;
}
}
else {
helpptr = 2 ;
helpline [1 ]= 904 ;
helpline [0 ]= 905 ;
}
disperr ( 0 , 906 ) ;
putgetflusherror ( 31 ) ;
}
else switch ( c )
{case 97 :
if ( curexp < 0 )
curexp = 30 ;
else curexp = 31 ;
break ;
case 98 :
if ( curexp <= 0 )
curexp = 30 ;
else curexp = 31 ;
break ;
case 99 :
if ( curexp > 0 )
curexp = 30 ;
else curexp = 31 ;
break ;
case 100 :
if ( curexp >= 0 )
curexp = 30 ;
else curexp = 31 ;
break ;
case 101 :
if ( curexp == 0 )
curexp = 30 ;
else curexp = 31 ;
break ;
case 102 :
if ( curexp != 0 )
curexp = 30 ;
else curexp = 31 ;
break ;
}
curtype = 2 ;
lab30: aritherror = false ;
}
break ;
case 96 :
case 95 :
if ( ( mem [p ].hhfield .b0 != 2 ) || ( curtype != 2 ) )
badbinary ( p , c ) ;
else if ( mem [p + 1 ].cint == c - 65 )
curexp = mem [p + 1 ].cint ;
break ;
case 91 :
if ( ( curtype < 13 ) || ( mem [p ].hhfield .b0 < 13 ) )
badbinary ( p , 91 ) ;
else if ( ( curtype == 16 ) || ( mem [p ].hhfield .b0 == 16 ) )
{
if ( mem [p ].hhfield .b0 == 16 )
{
v = mem [p + 1 ].cint ;
freenode ( p , 2 ) ;
}
else {
v = curexp ;
unstashcurexp ( p ) ;
}
if ( curtype == 16 )
curexp = takescaled ( curexp , v ) ;
else if ( ( curtype == 14 ) || ( curtype == 13 ) )
{
p = mem [curexp + 1 ].cint + bignodesize [curtype ];
do {
p = p - 2 ;
depmult ( p , v , true ) ;
} while ( ! ( p == mem [curexp + 1 ].cint ) ) ;
}
else depmult ( 0 , v , true ) ;
goto lab10 ;
}
else if ( ( nicecolororpair ( p , mem [p ].hhfield .b0 ) && ( curtype >
14 ) ) || ( nicecolororpair ( curexp , curtype ) && ( mem [p ].hhfield
.b0 > 14 ) ) )
{
hardtimes ( p ) ;
goto lab10 ;
}
else badbinary ( p , 91 ) ;
break ;
case 92 :
if ( ( curtype != 16 ) || ( mem [p ].hhfield .b0 < 13 ) )
badbinary ( p , 92 ) ;
else {
v = curexp ;
unstashcurexp ( p ) ;
if ( v == 0 )
{
disperr ( 0 , 835 ) ;
{
helpptr = 2 ;
helpline [1 ]= 908 ;
helpline [0 ]= 909 ;
}
putgeterror () ;
}
else {
if ( curtype == 16 )
curexp = makescaled ( curexp , v ) ;
else if ( curtype <= 14 )
{
p = mem [curexp + 1 ].cint + bignodesize [curtype ];
do {
p = p - 2 ;
depdiv ( p , v ) ;
} while ( ! ( p == mem [curexp + 1 ].cint ) ) ;
}
else depdiv ( 0 , v ) ;
}
goto lab10 ;
}
break ;
case 93 :
case 94 :
if ( ( curtype == 16 ) && ( mem [p ].hhfield .b0 == 16 ) )
if ( c == 93 )
curexp = pythadd ( mem [p + 1 ].cint , curexp ) ;
else curexp = pythsub ( mem [p + 1 ].cint , curexp ) ;
else badbinary ( p , c ) ;
break ;
case 104 :
case 105 :
case 106 :
case 107 :
case 108 :
case 109 :
case 110 :
case 111 :
if ( mem [p ].hhfield .b0 == 8 )
{
{
setupknowntrans ( c ) ;
unstashcurexp ( p ) ;
dopathtrans ( curexp ) ;
}
goto lab10 ;
}
else if ( mem [p ].hhfield .b0 == 6 )
{
{
setupknowntrans ( c ) ;
unstashcurexp ( p ) ;
dopentrans ( curexp ) ;
}
curexp = convexhull ( curexp ) ;
goto lab10 ;
}
else if ( ( mem [p ].hhfield .b0 == 14 ) || ( mem [p ].hhfield .b0 ==
12 ) )
bigtrans ( p , c ) ;
else if ( mem [p ].hhfield .b0 == 10 )
{
doedgestrans ( p , c ) ;
goto lab10 ;
}
else badbinary ( p , c ) ;
break ;
case 103 :
if ( ( curtype == 4 ) && ( mem [p ].hhfield .b0 == 4 ) )
cat ( p ) ;
else badbinary ( p , 103 ) ;
break ;
case 115 :
if ( nicepair ( p , mem [p ].hhfield .b0 ) && ( curtype == 4 ) )
chopstring ( mem [p + 1 ].cint ) ;
else badbinary ( p , 115 ) ;
break ;
case 116 :
{
if ( curtype == 14 )
pairtopath () ;
if ( nicepair ( p , mem [p ].hhfield .b0 ) && ( curtype == 8 ) )
choppath ( mem [p + 1 ].cint ) ;
else badbinary ( p , 116 ) ;
}
break ;
case 118 :
case 119 :
case 120 :
{
if ( curtype == 14 )
pairtopath () ;
if ( ( curtype == 8 ) && ( mem [p ].hhfield .b0 == 16 ) )
findpoint ( mem [p + 1 ].cint , c ) ;
else badbinary ( p , c ) ;
}
break ;
case 121 :
if ( ( curtype == 6 ) && nicepair ( p , mem [p ].hhfield .b0 ) )
setupoffset ( mem [p + 1 ].cint ) ;
else badbinary ( p , 121 ) ;
break ;
case 117 :
{
if ( curtype == 14 )
pairtopath () ;
if ( ( curtype == 8 ) && nicepair ( p , mem [p ].hhfield .b0 ) )
setupdirectiontime ( mem [p + 1 ].cint ) ;
else badbinary ( p , 117 ) ;
}
break ;
case 122 :
{
if ( curtype == 14 )
pairtopath () ;
if ( ( curtype == 8 ) && ( mem [p ].hhfield .b0 == 16 ) )
flushcurexp ( getarctime ( curexp , mem [p + 1 ].cint ) ) ;
else badbinary ( p , c ) ;
}
break ;
case 113 :
{
if ( mem [p ].hhfield .b0 == 14 )
{
q = stashcurexp () ;
unstashcurexp ( p ) ;
pairtopath () ;
p = stashcurexp () ;
unstashcurexp ( q ) ;
}
if ( curtype == 14 )
pairtopath () ;
if ( ( curtype == 8 ) && ( mem [p ].hhfield .b0 == 8 ) )
{
pathintersection ( mem [p + 1 ].cint , curexp ) ;
pairvalue ( curt , curtt ) ;
}
else badbinary ( p , 113 ) ;
}
break ;
case 112 :
if ( ( curtype != 4 ) || ( mem [p ].hhfield .b0 != 4 ) )
badbinary ( p , 112 ) ;
else {
doinfont ( p ) ;
goto lab10 ;
}
break ;
}
recyclevalue ( p ) ;
freenode ( p , 2 ) ;
lab10: {
if ( aritherror )
cleararith () ;
}
if ( oldp != 0 )
{
recyclevalue ( oldp ) ;
freenode ( oldp , 2 ) ;
}
if ( oldexp != 0 )
{
recyclevalue ( oldexp ) ;
freenode ( oldexp , 2 ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zfracmult ( scaled n , scaled d )
#else
zfracmult ( n , d )
scaled n ;
scaled d ;
#endif
{
halfword p ;
halfword oldexp ;
fraction v ;
if ( internal [6 ]> 131072L )
{
begindiagnostic () ;
printnl ( 902 ) ;
printscaled ( n ) ;
printchar ( 47 ) ;
printscaled ( d ) ;
print ( 907 ) ;
printexp ( 0 , 0 ) ;
print ( 891 ) ;
enddiagnostic ( false ) ;
}
switch ( curtype )
{case 12 :
case 13 :
case 14 :
oldexp = tarnished ( curexp ) ;
break ;
case 19 :
oldexp = 1 ;
break ;
default:
oldexp = 0 ;
break ;
}
if ( oldexp != 0 )
{
oldexp = curexp ;
makeexpcopy ( oldexp ) ;
}
v = makefraction ( n , d ) ;
if ( curtype == 16 )
curexp = takefraction ( curexp , v ) ;
else if ( curtype <= 14 )
{
p = mem [curexp + 1 ].cint + bignodesize [curtype ];
do {
p = p - 2 ;
depmult ( p , v , false ) ;
} while ( ! ( p == mem [curexp + 1 ].cint ) ) ;
}
else depmult ( 0 , v , false ) ;
if ( oldexp != 0 )
{
recyclevalue ( oldexp ) ;
freenode ( oldexp , 2 ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
ztryeq ( halfword l , halfword r )
#else
ztryeq ( l , r )
halfword l ;
halfword r ;
#endif
{
/* 30 31 */ halfword p ;
char t ;
halfword q ;
halfword pp ;
char tt ;
boolean copied ;
t = mem [l ].hhfield .b0 ;
if ( t == 16 )
{
t = 17 ;
p = constdependency ( - (integer) mem [l + 1 ].cint ) ;
q = p ;
}
else if ( t == 19 )
{
t = 17 ;
p = singledependency ( l ) ;
mem [p + 1 ].cint = - (integer) mem [p + 1 ].cint ;
q = depfinal ;
}
else {
p = mem [l + 1 ].hhfield .v.RH ;
q = p ;
while ( true ) {
mem [q + 1 ].cint = - (integer) mem [q + 1 ].cint ;
if ( mem [q ].hhfield .lhfield == 0 )
goto lab30 ;
q = mem [q ].hhfield .v.RH ;
}
lab30: mem [mem [l + 1 ].hhfield .lhfield ].hhfield .v.RH = mem [q ]
.hhfield .v.RH ;
mem [mem [q ].hhfield .v.RH + 1 ].hhfield .lhfield = mem [l + 1 ]
.hhfield .lhfield ;
mem [l ].hhfield .b0 = 16 ;
}
if ( r == 0 )
if ( curtype == 16 )
{
mem [q + 1 ].cint = mem [q + 1 ].cint + curexp ;
goto lab31 ;
}
else {
tt = curtype ;
if ( tt == 19 )
pp = singledependency ( curexp ) ;
else pp = mem [curexp + 1 ].hhfield .v.RH ;
}
else if ( mem [r ].hhfield .b0 == 16 )
{
mem [q + 1 ].cint = mem [q + 1 ].cint + mem [r + 1 ].cint ;
goto lab31 ;
}
else {
tt = mem [r ].hhfield .b0 ;
if ( tt == 19 )
pp = singledependency ( r ) ;
else pp = mem [r + 1 ].hhfield .v.RH ;
}
if ( tt != 19 )
copied = false ;
else {
copied = true ;
tt = 17 ;
}
watchcoefs = false ;
if ( t == tt )
p = pplusq ( p , pp , t ) ;
else if ( t == 18 )
p = pplusfq ( p , 65536L , pp , 18 , 17 ) ;
else {
q = p ;
while ( mem [q ].hhfield .lhfield != 0 ) {
mem [q + 1 ].cint = roundfraction ( mem [q + 1 ].cint ) ;
q = mem [q ].hhfield .v.RH ;
}
t = 18 ;
p = pplusq ( p , pp , t ) ;
}
watchcoefs = true ;
if ( copied )
flushnodelist ( pp ) ;
lab31: ;
if ( mem [p ].hhfield .lhfield == 0 )
{
if ( abs ( mem [p + 1 ].cint ) > 64 )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 945 ) ;
}
print ( 947 ) ;
printscaled ( mem [p + 1 ].cint ) ;
printchar ( 41 ) ;
{
helpptr = 2 ;
helpline [1 ]= 946 ;
helpline [0 ]= 944 ;
}
putgeterror () ;
}
else if ( r == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 611 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 612 ;
helpline [0 ]= 613 ;
}
putgeterror () ;
}
freenode ( p , 2 ) ;
}
else {
lineareq ( p , t ) ;
if ( r == 0 )
if ( curtype != 16 )
if ( mem [curexp ].hhfield .b0 == 16 )
{
pp = curexp ;
curexp = mem [curexp + 1 ].cint ;
curtype = 16 ;
freenode ( pp , 2 ) ;
}
}
}
void
#ifdef HAVE_PROTOTYPES
zmakeeq ( halfword lhs )
#else
zmakeeq ( lhs )
halfword lhs ;
#endif
{
/* 20 30 45 */ smallnumber t ;
integer v ;
halfword p, q ;
lab20: t = mem [lhs ].hhfield .b0 ;
if ( t <= 14 )
v = mem [lhs + 1 ].cint ;
switch ( t )
{case 2 :
case 4 :
case 6 :
case 8 :
case 10 :
if ( curtype == t + 1 )
{
nonlineareq ( v , curexp , false ) ;
goto lab30 ;
}
else if ( curtype == t )
{
if ( curtype <= 4 )
{
if ( curtype == 4 )
{
if ( strvsstr ( v , curexp ) != 0 )
goto lab45 ;
}
else if ( v != curexp )
goto lab45 ;
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 611 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 612 ;
helpline [0 ]= 613 ;
}
putgeterror () ;
}
goto lab30 ;
}
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 942 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 943 ;
helpline [0 ]= 944 ;
}
putgeterror () ;
goto lab30 ;
lab45: {
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 945 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 946 ;
helpline [0 ]= 944 ;
}
putgeterror () ;
goto lab30 ;
}
break ;
case 3 :
case 5 :
case 7 :
case 11 :
case 9 :
if ( curtype == t - 1 )
{
nonlineareq ( curexp , lhs , true ) ;
goto lab30 ;
}
else if ( curtype == t )
{
ringmerge ( lhs , curexp ) ;
goto lab30 ;
}
else if ( curtype == 14 )
if ( t == 9 )
{
pairtopath () ;
goto lab20 ;
}
break ;
case 12 :
case 13 :
case 14 :
if ( curtype == t )
{
p = v + bignodesize [t ];
q = mem [curexp + 1 ].cint + bignodesize [t ];
do {
p = p - 2 ;
q = q - 2 ;
tryeq ( p , q ) ;
} while ( ! ( p == v ) ) ;
goto lab30 ;
}
break ;
case 16 :
case 17 :
case 18 :
case 19 :
if ( curtype >= 16 )
{
tryeq ( lhs , 0 ) ;
goto lab30 ;
}
break ;
case 1 :
;
break ;
}
disperr ( lhs , 284 ) ;
disperr ( 0 , 939 ) ;
if ( mem [lhs ].hhfield .b0 <= 14 )
printtype ( mem [lhs ].hhfield .b0 ) ;
else print ( 340 ) ;
printchar ( 61 ) ;
if ( curtype <= 14 )
printtype ( curtype ) ;
else print ( 340 ) ;
printchar ( 41 ) ;
{
helpptr = 2 ;
helpline [1 ]= 940 ;
helpline [0 ]= 941 ;
}
putgeterror () ;
lab30: {
if ( aritherror )
cleararith () ;
}
recyclevalue ( lhs ) ;
freenode ( lhs , 2 ) ;
}
void
#ifdef HAVE_PROTOTYPES
doequation ( void )
#else
doequation ( )
#endif
{
halfword lhs ;
halfword p ;
lhs = stashcurexp () ;
getxnext () ;
varflag = 76 ;
scanexpression () ;
if ( curcmd == 53 )
doequation () ;
else if ( curcmd == 76 )
doassignment () ;
if ( internal [6 ]> 131072L )
{
begindiagnostic () ;
printnl ( 902 ) ;
printexp ( lhs , 0 ) ;
print ( 934 ) ;
printexp ( 0 , 0 ) ;
print ( 891 ) ;
enddiagnostic ( false ) ;
}
if ( curtype == 9 )
if ( mem [lhs ].hhfield .b0 == 14 )
{
p = stashcurexp () ;
unstashcurexp ( lhs ) ;
lhs = p ;
}
makeeq ( lhs ) ;
}
void
#ifdef HAVE_PROTOTYPES
doassignment ( void )
#else
doassignment ( )
#endif
{
halfword lhs ;
halfword p ;
halfword q ;
if ( curtype != 20 )
{
disperr ( 0 , 931 ) ;
{
helpptr = 2 ;
helpline [1 ]= 932 ;
helpline [0 ]= 933 ;
}
error () ;
doequation () ;
}
else {
lhs = curexp ;
curtype = 1 ;
getxnext () ;
varflag = 76 ;
scanexpression () ;
if ( curcmd == 53 )
doequation () ;
else if ( curcmd == 76 )
doassignment () ;
if ( internal [6 ]> 131072L )
{
begindiagnostic () ;
printnl ( 123 ) ;
if ( mem [lhs ].hhfield .lhfield > 9771 )
print ( intname [mem [lhs ].hhfield .lhfield - ( 9771 ) ]) ;
else showtokenlist ( lhs , 0 , 1000 , 0 ) ;
print ( 476 ) ;
printexp ( 0 , 0 ) ;
printchar ( 125 ) ;
enddiagnostic ( false ) ;
}
if ( mem [lhs ].hhfield .lhfield > 9771 )
if ( curtype == 16 )
internal [mem [lhs ].hhfield .lhfield - ( 9771 ) ]= curexp ;
else {
disperr ( 0 , 935 ) ;
print ( intname [mem [lhs ].hhfield .lhfield - ( 9771 ) ]) ;
print ( 936 ) ;
{
helpptr = 2 ;
helpline [1 ]= 937 ;
helpline [0 ]= 938 ;
}
putgeterror () ;
}
else {
p = findvariable ( lhs ) ;
if ( p != 0 )
{
q = stashcurexp () ;
curtype = undtype ( p ) ;
recyclevalue ( p ) ;
mem [p ].hhfield .b0 = curtype ;
mem [p + 1 ].cint = 0 ;
makeexpcopy ( p ) ;
p = stashcurexp () ;
unstashcurexp ( q ) ;
makeeq ( p ) ;
}
else {
obliterated ( lhs ) ;
putgeterror () ;
}
}
flushnodelist ( lhs ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
dotypedeclaration ( void )
#else
dotypedeclaration ( )
#endif
{
smallnumber t ;
halfword p ;
halfword q ;
if ( curmod >= 12 )
t = curmod ;
else t = curmod + 1 ;
do {
p = scandeclaredvariable () ;
flushvariable ( eqtb [mem [p ].hhfield .lhfield ].v.RH , mem [p ]
.hhfield .v.RH , false ) ;
q = findvariable ( p ) ;
if ( q != 0 )
{
mem [q ].hhfield .b0 = t ;
mem [q + 1 ].cint = 0 ;
}
else {
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 948 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 949 ;
helpline [0 ]= 950 ;
}
putgeterror () ;
}
flushlist ( p ) ;
if ( curcmd < 81 )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 951 ) ;
}
{
helpptr = 5 ;
helpline [4 ]= 952 ;
helpline [3 ]= 953 ;
helpline [2 ]= 954 ;
helpline [1 ]= 955 ;
helpline [0 ]= 956 ;
}
if ( curcmd == 44 )
helpline [2 ]= 957 ;
putgeterror () ;
scannerstatus = 2 ;
do {
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
if ( curcmd == 41 )
{
if ( strref [curmod ]< 127 )
if ( strref [curmod ]> 1 )
decr ( strref [curmod ]) ;
else flushstring ( curmod ) ;
}
} while ( ! ( curcmd >= 81 ) ) ;
scannerstatus = 0 ;
}
} while ( ! ( curcmd > 81 ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
dorandomseed ( void )
#else
dorandomseed ( )
#endif
{
getxnext () ;
if ( curcmd != 76 )
{
missingerr ( 476 ) ;
{
helpptr = 1 ;
helpline [0 ]= 962 ;
}
backerror () ;
}
getxnext () ;
scanexpression () ;
if ( curtype != 16 )
{
disperr ( 0 , 963 ) ;
{
helpptr = 2 ;
helpline [1 ]= 964 ;
helpline [0 ]= 965 ;
}
putgetflusherror ( 0 ) ;
}
else {
initrandoms ( curexp ) ;
if ( selector >= 9 )
{
oldsetting = selector ;
selector = 9 ;
printnl ( 966 ) ;
printscaled ( curexp ) ;
printchar ( 125 ) ;
printnl ( 284 ) ;
selector = oldsetting ;
}
}
}
void
#ifdef HAVE_PROTOTYPES
doprotection ( void )
#else
doprotection ( )
#endif
{
char m ;
halfword t ;
m = curmod ;
do {
getsymbol () ;
t = eqtb [cursym ].lhfield ;
if ( m == 0 )
{
if ( t >= 85 )
eqtb [cursym ].lhfield = t - 85 ;
}
else if ( t < 85 )
eqtb [cursym ].lhfield = t + 85 ;
getxnext () ;
} while ( ! ( curcmd != 81 ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
defdelims ( void )
#else
defdelims ( )
#endif
{
halfword ldelim, rdelim ;
getclearsymbol () ;
ldelim = cursym ;
getclearsymbol () ;
rdelim = cursym ;
eqtb [ldelim ].lhfield = 33 ;
eqtb [ldelim ].v.RH = rdelim ;
eqtb [rdelim ].lhfield = 64 ;
eqtb [rdelim ].v.RH = ldelim ;
getxnext () ;
}
void
#ifdef HAVE_PROTOTYPES
dointerim ( void )
#else
dointerim ( )
#endif
{
getxnext () ;
if ( curcmd != 42 )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 972 ) ;
}
if ( cursym == 0 )
print ( 977 ) ;
else print ( hash [cursym ].v.RH ) ;
print ( 978 ) ;
{
helpptr = 1 ;
helpline [0 ]= 979 ;
}
backerror () ;
}
else {
saveinternal ( curmod ) ;
backinput () ;
}
dostatement () ;
}
void
#ifdef HAVE_PROTOTYPES
dolet ( void )
#else
dolet ( )
#endif
{
halfword l ;
getsymbol () ;
l = cursym ;
getxnext () ;
if ( curcmd != 53 )
if ( curcmd != 76 )
{
missingerr ( 61 ) ;
{
helpptr = 3 ;
helpline [2 ]= 980 ;
helpline [1 ]= 713 ;
helpline [0 ]= 981 ;
}
backerror () ;
}
getsymbol () ;
switch ( curcmd )
{case 13 :
case 55 :
case 46 :
case 51 :
incr ( mem [curmod ].hhfield .lhfield ) ;
break ;
default:
;
break ;
}
clearsymbol ( l , false ) ;
eqtb [l ].lhfield = curcmd ;
if ( curcmd == 43 )
eqtb [l ].v.RH = 0 ;
else eqtb [l ].v.RH = curmod ;
getxnext () ;
}
void
#ifdef HAVE_PROTOTYPES
donewinternal ( void )
#else
donewinternal ( )
#endif
{
do {
if ( intptr == maxinternal )
overflow ( 982 , maxinternal ) ;
getclearsymbol () ;
incr ( intptr ) ;
eqtb [cursym ].lhfield = 42 ;
eqtb [cursym ].v.RH = intptr ;
intname [intptr ]= hash [cursym ].v.RH ;
internal [intptr ]= 0 ;
getxnext () ;
} while ( ! ( curcmd != 81 ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
doshow ( void )
#else
doshow ( )
#endif
{
do {
getxnext () ;
scanexpression () ;
printnl ( 804 ) ;
printexp ( 0 , 2 ) ;
flushcurexp ( 0 ) ;
} while ( ! ( curcmd != 81 ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
disptoken ( void )
#else
disptoken ( )
#endif
{
printnl ( 988 ) ;
if ( cursym == 0 )
{
if ( curcmd == 44 )
printscaled ( curmod ) ;
else if ( curcmd == 40 )
{
gpointer = curmod ;
printcapsule () ;
}
else {
printchar ( 34 ) ;
print ( curmod ) ;
printchar ( 34 ) ;
{
if ( strref [curmod ]< 127 )
if ( strref [curmod ]> 1 )
decr ( strref [curmod ]) ;
else flushstring ( curmod ) ;
}
}
}
else {
print ( hash [cursym ].v.RH ) ;
printchar ( 61 ) ;
if ( eqtb [cursym ].lhfield >= 85 )
print ( 989 ) ;
printcmdmod ( curcmd , curmod ) ;
if ( curcmd == 13 )
{
println () ;
showmacro ( curmod , 0 , 100000L ) ;
}
}
}
void
#ifdef HAVE_PROTOTYPES
doshowtoken ( void )
#else
doshowtoken ( )
#endif
{
do {
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
disptoken () ;
getxnext () ;
} while ( ! ( curcmd != 81 ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
doshowstats ( void )
#else
doshowstats ( )
#endif
{
printnl ( 998 ) ;
;
#ifdef STAT
printint ( varused ) ;
printchar ( 38 ) ;
printint ( dynused ) ;
if ( false )
#endif /* STAT */
print ( 359 ) ;
print ( 999 ) ;
printint ( himemmin - lomemmax - 1 ) ;
print ( 1000 ) ;
println () ;
printnl ( 1001 ) ;
;
#ifdef STAT
printint ( strsinuse - initstruse ) ;
printchar ( 38 ) ;
printint ( poolinuse - initpoolptr ) ;
if ( false )
#endif /* STAT */
print ( 359 ) ;
print ( 999 ) ;
printint ( maxstrings - 1 - strsusedup ) ;
printchar ( 38 ) ;
printint ( poolsize - poolptr ) ;
print ( 1002 ) ;
println () ;
getxnext () ;
}
void
#ifdef HAVE_PROTOTYPES
zdispvar ( halfword p )
#else
zdispvar ( p )
halfword p ;
#endif
{
halfword q ;
integer n ;
if ( mem [p ].hhfield .b0 == 21 )
{
q = mem [p + 1 ].hhfield .lhfield ;
do {
dispvar ( q ) ;
q = mem [q ].hhfield .v.RH ;
} while ( ! ( q == 9 ) ) ;
q = mem [p + 1 ].hhfield .v.RH ;
while ( mem [q ].hhfield .b1 == 3 ) {
dispvar ( q ) ;
q = mem [q ].hhfield .v.RH ;
}
}
else if ( mem [p ].hhfield .b0 >= 22 )
{
printnl ( 284 ) ;
printvariablename ( p ) ;
if ( mem [p ].hhfield .b0 > 22 )
print ( 705 ) ;
print ( 1003 ) ;
if ( fileoffset >= maxprintline - 20 )
n = 5 ;
else n = maxprintline - fileoffset - 15 ;
showmacro ( mem [p + 1 ].cint , 0 , n ) ;
}
else if ( mem [p ].hhfield .b0 != 0 )
{
printnl ( 284 ) ;
printvariablename ( p ) ;
printchar ( 61 ) ;
printexp ( p , 0 ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
doshowvar ( void )
#else
doshowvar ( )
#endif
{
/* 30 */ do {
{
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
if ( cursym > 0 )
if ( cursym <= 9771 )
if ( curcmd == 43 )
if ( curmod != 0 )
{
dispvar ( curmod ) ;
goto lab30 ;
}
disptoken () ;
lab30: getxnext () ;
} while ( ! ( curcmd != 81 ) ) ;
}
void
#ifdef HAVE_PROTOTYPES
doshowdependencies ( void )
#else
doshowdependencies ( )
#endif
{
halfword p ;
p = mem [5 ].hhfield .v.RH ;
while ( p != 5 ) {
if ( interesting ( p ) )
{
printnl ( 284 ) ;
printvariablename ( p ) ;
if ( mem [p ].hhfield .b0 == 17 )
printchar ( 61 ) ;
else print ( 817 ) ;
printdependency ( mem [p + 1 ].hhfield .v.RH , mem [p ].hhfield .b0
) ;
}
p = mem [p + 1 ].hhfield .v.RH ;
while ( mem [p ].hhfield .lhfield != 0 ) p = mem [p ].hhfield .v.RH ;
p = mem [p ].hhfield .v.RH ;
}
getxnext () ;
}
void
#ifdef HAVE_PROTOTYPES
doshowwhatever ( void )
#else
doshowwhatever ( )
#endif
{
if ( interaction == 3 )
;
switch ( curmod )
{case 0 :
doshowtoken () ;
break ;
case 1 :
doshowstats () ;
break ;
case 2 :
doshow () ;
break ;
case 3 :
doshowvar () ;
break ;
case 4 :
doshowdependencies () ;
break ;
}
if ( internal [25 ]> 0 )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 1004 ) ;
}
if ( interaction < 3 )
{
helpptr = 0 ;
decr ( errorcount ) ;
}
else {
helpptr = 1 ;
helpline [0 ]= 1005 ;
}
if ( curcmd == 82 )
error () ;
else putgeterror () ;
}
}
void
#ifdef HAVE_PROTOTYPES
zscanwithlist ( halfword p )
#else
zscanwithlist ( p )
halfword p ;
#endif
{
/* 30 31 32 */ smallnumber t ;
halfword q ;
halfword cp, pp, dp ;
cp = 1 ;
pp = 1 ;
dp = 1 ;
while ( curcmd == 68 ) {
t = curmod ;
getxnext () ;
scanexpression () ;
if ( curtype != t )
{
disperr ( 0 , 1012 ) ;
{
helpptr = 2 ;
helpline [1 ]= 1013 ;
helpline [0 ]= 1014 ;
}
if ( t == 10 )
helpline [1 ]= 1015 ;
else if ( t == 13 )
helpline [1 ]= 1016 ;
putgetflusherror ( 0 ) ;
}
else if ( t == 13 )
{
if ( cp == 1 )
{
cp = p ;
while ( cp != 0 ) {
if ( ( mem [cp ].hhfield .b0 < 4 ) )
goto lab30 ;
cp = mem [cp ].hhfield .v.RH ;
}
lab30: ;
}
if ( cp != 0 )
{
q = mem [curexp + 1 ].cint ;
mem [cp + 2 ].cint = mem [q + 1 ].cint ;
mem [cp + 3 ].cint = mem [q + 3 ].cint ;
mem [cp + 4 ].cint = mem [q + 5 ].cint ;
if ( mem [cp + 2 ].cint < 0 )
mem [cp + 2 ].cint = 0 ;
if ( mem [cp + 3 ].cint < 0 )
mem [cp + 3 ].cint = 0 ;
if ( mem [cp + 4 ].cint < 0 )
mem [cp + 4 ].cint = 0 ;
if ( mem [cp + 2 ].cint > 65536L )
mem [cp + 2 ].cint = 65536L ;
if ( mem [cp + 3 ].cint > 65536L )
mem [cp + 3 ].cint = 65536L ;
if ( mem [cp + 4 ].cint > 65536L )
mem [cp + 4 ].cint = 65536L ;
}
flushcurexp ( 0 ) ;
}
else if ( t == 6 )
{
if ( pp == 1 )
{
pp = p ;
while ( pp != 0 ) {
if ( ( mem [pp ].hhfield .b0 < 3 ) )
goto lab31 ;
pp = mem [pp ].hhfield .v.RH ;
}
lab31: ;
}
if ( pp != 0 )
{
if ( mem [pp + 1 ].hhfield .lhfield != 0 )
tossknotlist ( mem [pp + 1 ].hhfield .lhfield ) ;
mem [pp + 1 ].hhfield .lhfield = curexp ;
curtype = 1 ;
}
}
else {
if ( dp == 1 )
{
dp = p ;
while ( dp != 0 ) {
if ( mem [dp ].hhfield .b0 == 2 )
goto lab32 ;
dp = mem [dp ].hhfield .v.RH ;
}
lab32: ;
}
if ( dp != 0 )
{
if ( mem [dp + 6 ].hhfield .v.RH != 0 )
if ( mem [mem [dp + 6 ].hhfield .v.RH ].hhfield .lhfield == 0 )
tossedges ( mem [dp + 6 ].hhfield .v.RH ) ;
else decr ( mem [mem [dp + 6 ].hhfield .v.RH ].hhfield .lhfield )
;
mem [dp + 6 ].hhfield .v.RH = makedashes ( curexp ) ;
mem [dp + 7 ].cint = 65536L ;
curtype = 1 ;
}
}
}
if ( cp > 1 )
{
q = mem [cp ].hhfield .v.RH ;
while ( q != 0 ) {
if ( ( mem [q ].hhfield .b0 < 4 ) )
{
mem [q + 2 ].cint = mem [cp + 2 ].cint ;
mem [q + 3 ].cint = mem [cp + 3 ].cint ;
mem [q + 4 ].cint = mem [cp + 4 ].cint ;
}
q = mem [q ].hhfield .v.RH ;
}
}
if ( pp > 1 )
{
q = mem [pp ].hhfield .v.RH ;
while ( q != 0 ) {
if ( ( mem [q ].hhfield .b0 < 3 ) )
{
if ( mem [q + 1 ].hhfield .lhfield != 0 )
tossknotlist ( mem [q + 1 ].hhfield .lhfield ) ;
mem [q + 1 ].hhfield .lhfield = makepen ( copypath ( mem [pp + 1 ]
.hhfield .lhfield ) , false ) ;
}
q = mem [q ].hhfield .v.RH ;
}
}
if ( dp > 1 )
{
q = mem [dp ].hhfield .v.RH ;
while ( q != 0 ) {
if ( mem [q ].hhfield .b0 == 2 )
{
if ( mem [q + 6 ].hhfield .v.RH != 0 )
if ( mem [mem [q + 6 ].hhfield .v.RH ].hhfield .lhfield == 0 )
tossedges ( mem [q + 6 ].hhfield .v.RH ) ;
else decr ( mem [mem [q + 6 ].hhfield .v.RH ].hhfield .lhfield ) ;
mem [q + 6 ].hhfield .v.RH = mem [dp + 6 ].hhfield .v.RH ;
mem [q + 7 ].cint = 65536L ;
if ( mem [q + 6 ].hhfield .v.RH != 0 )
incr ( mem [mem [q + 6 ].hhfield .v.RH ].hhfield .lhfield ) ;
}
q = mem [q ].hhfield .v.RH ;
}
}
}
halfword
#ifdef HAVE_PROTOTYPES
zfindedgesvar ( halfword t )
#else
zfindedgesvar ( t )
halfword t ;
#endif
{
register halfword Result; halfword p ;
halfword curedges ;
p = findvariable ( t ) ;
curedges = 0 ;
if ( p == 0 )
{
obliterated ( t ) ;
putgeterror () ;
}
else if ( mem [p ].hhfield .b0 != 10 )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 841 ) ;
}
showtokenlist ( t , 0 , 1000 , 0 ) ;
print ( 1017 ) ;
printtype ( mem [p ].hhfield .b0 ) ;
printchar ( 41 ) ;
{
helpptr = 2 ;
helpline [1 ]= 1018 ;
helpline [0 ]= 1019 ;
}
putgeterror () ;
}
else {
mem [p + 1 ].cint = privateedges ( mem [p + 1 ].cint ) ;
curedges = mem [p + 1 ].cint ;
}
flushnodelist ( t ) ;
Result = curedges ;
return Result ;
}
halfword
#ifdef HAVE_PROTOTYPES
zstartdrawcmd ( quarterword sep )
#else
zstartdrawcmd ( sep )
quarterword sep ;
#endif
{
register halfword Result; halfword lhv ;
quarterword addtype ;
lhv = 0 ;
getxnext () ;
varflag = sep ;
scanprimary () ;
if ( curtype != 20 )
{
disperr ( 0 , 1022 ) ;
{
helpptr = 4 ;
helpline [3 ]= 1023 ;
helpline [2 ]= 1024 ;
helpline [1 ]= 1025 ;
helpline [0 ]= 1019 ;
}
putgetflusherror ( 0 ) ;
}
else {
lhv = curexp ;
addtype = curmod ;
curtype = 1 ;
getxnext () ;
scanexpression () ;
}
lastaddtype = addtype ;
Result = lhv ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
dobounds ( void )
#else
dobounds ( )
#endif
{
halfword lhv, lhe ;
halfword p ;
integer m ;
m = curmod ;
lhv = startdrawcmd ( 71 ) ;
if ( lhv != 0 )
{
lhe = findedgesvar ( lhv ) ;
if ( lhe == 0 )
flushcurexp ( 0 ) ;
else if ( curtype != 8 )
{
disperr ( 0 , 1026 ) ;
{
helpptr = 2 ;
helpline [1 ]= 1027 ;
helpline [0 ]= 1019 ;
}
putgetflusherror ( 0 ) ;
}
else if ( mem [curexp ].hhfield .b0 == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 1028 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 1029 ;
helpline [0 ]= 1019 ;
}
putgeterror () ;
}
else {
p = newboundsnode ( curexp , m ) ;
mem [p ].hhfield .v.RH = mem [lhe + 7 ].hhfield .v.RH ;
mem [lhe + 7 ].hhfield .v.RH = p ;
if ( mem [lhe + 7 ].hhfield .lhfield == lhe + 7 )
mem [lhe + 7 ].hhfield .lhfield = p ;
p = getnode ( grobjectsize [( m + 2 ) ]) ;
mem [p ].hhfield .b0 = ( m + 2 ) ;
mem [mem [lhe + 7 ].hhfield .lhfield ].hhfield .v.RH = p ;
mem [lhe + 7 ].hhfield .lhfield = p ;
initbbox ( lhe ) ;
}
}
}
void
#ifdef HAVE_PROTOTYPES
doaddto ( void )
#else
doaddto ( )
#endif
{
halfword lhv, lhe ;
halfword p ;
halfword e ;
quarterword addtype ;
lhv = startdrawcmd ( 69 ) ;
addtype = lastaddtype ;
if ( lhv != 0 )
{
if ( addtype == 2 )
{
p = 0 ;
e = 0 ;
if ( curtype != 10 )
{
disperr ( 0 , 1030 ) ;
{
helpptr = 2 ;
helpline [1 ]= 1031 ;
helpline [0 ]= 1019 ;
}
putgetflusherror ( 0 ) ;
}
else {
e = privateedges ( curexp ) ;
curtype = 1 ;
p = mem [e + 7 ].hhfield .v.RH ;
}
}
else {
e = 0 ;
p = 0 ;
if ( curtype == 14 )
pairtopath () ;
if ( curtype != 8 )
{
disperr ( 0 , 1030 ) ;
{
helpptr = 2 ;
helpline [1 ]= 1027 ;
helpline [0 ]= 1019 ;
}
putgetflusherror ( 0 ) ;
}
else if ( addtype == 1 )
if ( mem [curexp ].hhfield .b0 == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 1028 ) ;
}
{
helpptr = 2 ;
helpline [1 ]= 1029 ;
helpline [0 ]= 1019 ;
}
putgeterror () ;
}
else {
p = newfillnode ( curexp ) ;
curtype = 1 ;
}
else {
p = newstrokednode ( curexp ) ;
curtype = 1 ;
}
}
scanwithlist ( p ) ;
lhe = findedgesvar ( lhv ) ;
if ( lhe == 0 )
{
if ( ( e == 0 ) && ( p != 0 ) )
e = tossgrobject ( p ) ;
if ( e != 0 )
if ( mem [e ].hhfield .lhfield == 0 )
tossedges ( e ) ;
else decr ( mem [e ].hhfield .lhfield ) ;
}
else if ( addtype == 2 )
if ( e != 0 )
{
if ( mem [e + 7 ].hhfield .v.RH != 0 )
{
mem [mem [lhe + 7 ].hhfield .lhfield ].hhfield .v.RH = mem [e + 7
].hhfield .v.RH ;
mem [lhe + 7 ].hhfield .lhfield = mem [e + 7 ].hhfield .lhfield ;
mem [e + 7 ].hhfield .lhfield = e + 7 ;
mem [e + 7 ].hhfield .v.RH = 0 ;
flushdashlist ( lhe ) ;
}
tossedges ( e ) ;
}
else ;
else if ( p != 0 )
{
mem [mem [lhe + 7 ].hhfield .lhfield ].hhfield .v.RH = p ;
mem [lhe + 7 ].hhfield .lhfield = p ;
if ( addtype == 0 )
if ( mem [p + 1 ].hhfield .lhfield == 0 )
mem [p + 1 ].hhfield .lhfield = getpencircle ( 0 ) ;
}
}
}
scaled
#ifdef HAVE_PROTOTYPES
ztfmcheck ( smallnumber m )
#else
ztfmcheck ( m )
smallnumber m ;
#endif
{
register scaled Result; if ( abs ( internal [m ]) >= 134217728L )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 1048 ) ;
}
print ( intname [m ]) ;
print ( 1049 ) ;
{
helpptr = 1 ;
helpline [0 ]= 1050 ;
}
putgeterror () ;
if ( internal [m ]> 0 )
Result = 134217727L ;
else Result = -134217727L ;
}
else Result = internal [m ];
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
readpsnametable ( void )
#else
readpsnametable ( )
#endif
{
/* 50 30 */ fontnumber k ;
integer lmax ;
integer j ;
ASCIIcode c ;
strnumber s ;
namelength = strlen ( pstabname ) ;
nameoffile = xmalloc ( 1 + namelength + 1 ) ;
strcpy ( (char*) nameoffile + 1 , pstabname ) ;
if ( aopenin ( pstabfile , kpsedvipsconfigformat ) )
{
lmax = 0 ;
{register integer for_end; k = lastpsfnum + 1 ;for_end = lastfnum ; if (
k <= for_end) do
if ( ( strstart [nextstr [fontname [k ]]]- strstart [fontname [k
]]) > lmax )
lmax = ( strstart [nextstr [fontname [k ]]]- strstart [fontname [
k ]]) ;
while ( k++ < for_end ) ;}
while ( ! eof ( pstabfile ) ) {
{
if ( poolptr + lmax > maxpoolptr )
if ( poolptr + lmax > poolsize )
docompaction ( lmax ) ;
else maxpoolptr = poolptr + lmax ;
}
j = lmax ;
while ( true ) {
if ( eoln ( pstabfile ) )
if ( j == lmax )
{
poolptr = strstart [strptr ];
goto lab50 ;
}
else fatalerror ( 1113 ) ;
read ( pstabfile , c ) ;
if ( ( ( c == '%' ) || ( c == '*' ) || ( c == ';' ) || ( c == '#' ) )
)
{
poolptr = strstart [strptr ];
goto lab50 ;
}
if ( ( ( c == ' ' ) || ( c == 9 ) ) )
goto lab30 ;
decr ( j ) ;
if ( j >= 0 )
{
strpool [poolptr ]= xord [c ];
incr ( poolptr ) ;
}
else {
poolptr = strstart [strptr ];
goto lab50 ;
}
}
lab30: s = makestring () ;
{register integer for_end; k = lastpsfnum + 1 ;for_end = lastfnum
; if ( k <= for_end) do
if ( strvsstr ( s , fontname [k ]) == 0 )
{
flushstring ( s ) ;
j = 32 ;
{
if ( poolptr + j > maxpoolptr )
if ( poolptr + j > poolsize )
docompaction ( j ) ;
else maxpoolptr = poolptr + j ;
}
do {
if ( eoln ( pstabfile ) )
fatalerror ( 1113 ) ;
read ( pstabfile , c ) ;
} while ( ! ( ( ( c != ' ' ) && ( c != 9 ) ) ) ) ;
do {
decr ( j ) ;
if ( j < 0 )
fatalerror ( 1113 ) ;
{
strpool [poolptr ]= xord [c ];
incr ( poolptr ) ;
}
if ( eoln ( pstabfile ) )
c = ' ' ;
else read ( pstabfile , c ) ;
} while ( ! ( ( ( c == ' ' ) || ( c == 9 ) ) ) ) ;
{
if ( strref [fontpsname [k ]]< 127 )
if ( strref [fontpsname [k ]]> 1 )
decr ( strref [fontpsname [k ]]) ;
else flushstring ( fontpsname [k ]) ;
}
fontpsname [k ]= makestring () ;
goto lab50 ;
}
while ( k++ < for_end ) ;}
flushstring ( s ) ;
lab50: readln ( pstabfile ) ;
}
lastpsfnum = lastfnum ;
aclose ( pstabfile ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
openoutputfile ( void )
#else
openoutputfile ( )
#endif
{
integer c ;
char oldsetting ;
strnumber s ;
if ( jobname == 0 )
openlogfile () ;
c = roundunscaled ( internal [17 ]) ;
if ( c < 0 )
s = 1114 ;
else {
oldsetting = selector ;
selector = 4 ;
printchar ( 46 ) ;
printint ( c ) ;
s = makestring () ;
selector = oldsetting ;
}
packjobname ( s ) ;
while ( ! aopenout ( psfile ) ) promptfilename ( 1115 , s ) ;
{
if ( strref [s ]< 127 )
if ( strref [s ]> 1 )
decr ( strref [s ]) ;
else flushstring ( s ) ;
}
if ( ( c < firstoutputcode ) && ( firstoutputcode >= 0 ) )
{
firstoutputcode = c ;
{
if ( strref [firstfilename ]< 127 )
if ( strref [firstfilename ]> 1 )
decr ( strref [firstfilename ]) ;
else flushstring ( firstfilename ) ;
}
firstfilename = amakenamestring ( psfile ) ;
}
if ( c >= lastoutputcode )
{
lastoutputcode = c ;
{
if ( strref [lastfilename ]< 127 )
if ( strref [lastfilename ]> 1 )
decr ( strref [lastfilename ]) ;
else flushstring ( lastfilename ) ;
}
lastfilename = amakenamestring ( psfile ) ;
}
if ( termoffset > maxprintline - 6 )
println () ;
else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) )
printchar ( 32 ) ;
printchar ( 91 ) ;
if ( c >= 0 )
printint ( c ) ;
}
void
#ifdef HAVE_PROTOTYPES
zpspairout ( scaled x , scaled y )
#else
zpspairout ( x , y )
scaled x ;
scaled y ;
#endif
{
if ( psoffset + 26 > maxprintline )
println () ;
printscaled ( x ) ;
printchar ( 32 ) ;
printscaled ( y ) ;
printchar ( 32 ) ;
}
void
#ifdef HAVE_PROTOTYPES
zpsprint ( strnumber s )
#else
zpsprint ( s )
strnumber s ;
#endif
{
if ( psoffset + ( strstart [nextstr [s ]]- strstart [s ]) >
maxprintline )
println () ;
print ( s ) ;
}
void
#ifdef HAVE_PROTOTYPES
zpspathout ( halfword h )
#else
zpspathout ( h )
halfword h ;
#endif
{
/* 10 */ halfword p, q ;
scaled d ;
boolean curved ;
if ( psoffset + 40 > maxprintline )
println () ;
if ( neednewpath )
print ( 1118 ) ;
neednewpath = true ;
pspairout ( mem [h + 1 ].cint , mem [h + 2 ].cint ) ;
print ( 1119 ) ;
p = h ;
do {
if ( mem [p ].hhfield .b1 == 0 )
{
if ( p == h )
psprint ( 1120 ) ;
goto lab10 ;
}
q = mem [p ].hhfield .v.RH ;
curved = true ;
if ( mem [p + 5 ].cint == mem [p + 1 ].cint )
if ( mem [p + 6 ].cint == mem [p + 2 ].cint )
if ( mem [q + 3 ].cint == mem [q + 1 ].cint )
if ( mem [q + 4 ].cint == mem [q + 2 ].cint )
curved = false ;
d = mem [q + 3 ].cint - mem [p + 5 ].cint ;
if ( abs ( mem [p + 5 ].cint - mem [p + 1 ].cint - d ) <= 131 )
if ( abs ( mem [q + 1 ].cint - mem [q + 3 ].cint - d ) <= 131 )
{
d = mem [q + 4 ].cint - mem [p + 6 ].cint ;
if ( abs ( mem [p + 6 ].cint - mem [p + 2 ].cint - d ) <= 131 )
if ( abs ( mem [q + 2 ].cint - mem [q + 4 ].cint - d ) <= 131 )
curved = false ;
}
println () ;
if ( curved )
{
pspairout ( mem [p + 5 ].cint , mem [p + 6 ].cint ) ;
pspairout ( mem [q + 3 ].cint , mem [q + 4 ].cint ) ;
pspairout ( mem [q + 1 ].cint , mem [q + 2 ].cint ) ;
psprint ( 1122 ) ;
}
else if ( q != h )
{
pspairout ( mem [q + 1 ].cint , mem [q + 2 ].cint ) ;
psprint ( 1123 ) ;
}
p = q ;
} while ( ! ( p == h ) ) ;
psprint ( 1121 ) ;
lab10: ;
}
void
#ifdef HAVE_PROTOTYPES
zunknowngraphicsstate ( scaled c )
#else
zunknowngraphicsstate ( c )
scaled c ;
#endif
{
gsred = c ;
gsgreen = c ;
gsblue = c ;
gsljoin = 3 ;
gslcap = 3 ;
gsmiterlim = 0 ;
gsdashp = 1 ;
gsdashsc = 0 ;
gswidth = -1 ;
}
boolean
#ifdef HAVE_PROTOTYPES
zcoordrangeOK ( halfword h , smallnumber zoff , scaled dz )
#else
zcoordrangeOK ( h , zoff , dz )
halfword h ;
smallnumber zoff ;
scaled dz ;
#endif
{
/* 40 45 10 */ register boolean Result; halfword p ;
scaled zlo, zhi ;
scaled z ;
zlo = mem [h + zoff ].cint ;
zhi = zlo ;
p = h ;
while ( mem [p ].hhfield .b1 != 0 ) {
z = mem [p + zoff + 4 ].cint ;
if ( z < zlo )
zlo = z ;
else if ( z > zhi )
zhi = z ;
if ( zhi - zlo > dz )
goto lab40 ;
p = mem [p ].hhfield .v.RH ;
z = mem [p + zoff + 2 ].cint ;
if ( z < zlo )
zlo = z ;
else if ( z > zhi )
zhi = z ;
if ( zhi - zlo > dz )
goto lab40 ;
z = mem [p + zoff ].cint ;
if ( z < zlo )
zlo = z ;
else if ( z > zhi )
zhi = z ;
if ( zhi - zlo > dz )
goto lab40 ;
if ( p == h )
goto lab45 ;
}
lab45: Result = true ;
goto lab10 ;
lab40: Result = false ;
lab10: ;
return Result ;
}
boolean
#ifdef HAVE_PROTOTYPES
zsamedashes ( halfword h , halfword hh )
#else
zsamedashes ( h , hh )
halfword h ;
halfword hh ;
#endif
{
/* 30 */ register boolean Result; halfword p, pp ;
if ( h == hh )
Result = true ;
else if ( ( h <= 1 ) || ( hh <= 1 ) )
Result = false ;
else if ( mem [h + 1 ].cint != mem [hh + 1 ].cint )
Result = false ;
else {
p = mem [h ].hhfield .v.RH ;
pp = mem [hh ].hhfield .v.RH ;
while ( ( p != 2 ) && ( pp != 2 ) ) if ( ( mem [p + 1 ].cint != mem [pp
+ 1 ].cint ) || ( mem [p + 2 ].cint != mem [pp + 2 ].cint ) )
goto lab30 ;
else {
p = mem [p ].hhfield .v.RH ;
pp = mem [pp ].hhfield .v.RH ;
}
lab30: Result = p == pp ;
}
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zfixgraphicsstate ( halfword p )
#else
zfixgraphicsstate ( p )
halfword p ;
#endif
{
halfword hh, pp ;
scaled wx, wy, ww ;
boolean adjwx ;
integer tx, ty ;
scaled scf ;
if ( ( mem [p ].hhfield .b0 < 4 ) )
if ( ( gsred != mem [p + 2 ].cint ) || ( gsgreen != mem [p + 3 ].cint )
|| ( gsblue != mem [p + 4 ].cint ) )
{
gsred = mem [p + 2 ].cint ;
gsgreen = mem [p + 3 ].cint ;
gsblue = mem [p + 4 ].cint ;
if ( ( gsred == gsgreen ) && ( gsgreen == gsblue ) )
{
if ( psoffset + 16 > maxprintline )
println () ;
printchar ( 32 ) ;
printscaled ( gsred ) ;
print ( 1127 ) ;
}
else {
if ( psoffset + 36 > maxprintline )
println () ;
printchar ( 32 ) ;
printscaled ( gsred ) ;
printchar ( 32 ) ;
printscaled ( gsgreen ) ;
printchar ( 32 ) ;
printscaled ( gsblue ) ;
print ( 1128 ) ;
}
}
if ( ( mem [p ].hhfield .b0 == 1 ) || ( mem [p ].hhfield .b0 == 2 ) )
if ( mem [p + 1 ].hhfield .lhfield != 0 )
if ( ( mem [p + 1 ].hhfield .lhfield == mem [mem [p + 1 ].hhfield
.lhfield ].hhfield .v.RH ) )
{
pp = mem [p + 1 ].hhfield .lhfield ;
if ( ( mem [pp + 5 ].cint == mem [pp + 1 ].cint ) && ( mem [pp + 4 ]
.cint == mem [pp + 2 ].cint ) )
{
wx = abs ( mem [pp + 3 ].cint - mem [pp + 1 ].cint ) ;
wy = abs ( mem [pp + 6 ].cint - mem [pp + 2 ].cint ) ;
}
else {
wx = pythadd ( mem [pp + 3 ].cint - mem [pp + 1 ].cint , mem [pp +
5 ].cint - mem [pp + 1 ].cint ) ;
wy = pythadd ( mem [pp + 4 ].cint - mem [pp + 2 ].cint , mem [pp +
6 ].cint - mem [pp + 2 ].cint ) ;
}
tx = 1 ;
ty = 1 ;
if ( coordrangeOK ( mem [p + 1 ].hhfield .v.RH , 2 , wy ) )
tx = 10 ;
else if ( coordrangeOK ( mem [p + 1 ].hhfield .v.RH , 1 , wx ) )
ty = 10 ;
if ( wy / ty >= wx / tx )
{
ww = wy ;
adjwx = false ;
}
else {
ww = wx ;
adjwx = true ;
}
if ( ( ww != gswidth ) || ( adjwx != gsadjwx ) )
{
if ( adjwx )
{
if ( psoffset + 13 > maxprintline )
println () ;
printchar ( 32 ) ;
printscaled ( ww ) ;
psprint ( 1129 ) ;
}
else {
if ( psoffset + 15 > maxprintline )
println () ;
print ( 1130 ) ;
printscaled ( ww ) ;
psprint ( 1131 ) ;
}
gswidth = ww ;
gsadjwx = adjwx ;
}
if ( mem [p ].hhfield .b0 == 1 )
hh = 0 ;
else {
hh = mem [p + 6 ].hhfield .v.RH ;
scf = getpenscale ( mem [p + 1 ].hhfield .lhfield ) ;
if ( scf == 0 )
if ( gswidth == 0 )
scf = mem [p + 7 ].cint ;
else hh = 0 ;
else {
scf = makescaled ( gswidth , scf ) ;
scf = takescaled ( scf , mem [p + 7 ].cint ) ;
}
}
if ( hh == 0 )
{
if ( gsdashp != 0 )
{
psprint ( 1132 ) ;
gsdashp = 0 ;
}
}
else if ( ( gsdashsc != scf ) || ! samedashes ( gsdashp , hh ) )
{
gsdashp = hh ;
gsdashsc = scf ;
if ( ( mem [hh + 1 ].cint == 0 ) || ( abs ( mem [hh + 1 ].cint ) /
65536L >= 2147483647L / scf ) )
psprint ( 1132 ) ;
else {
pp = mem [hh ].hhfield .v.RH ;
mem [3 ].cint = mem [pp + 1 ].cint + mem [hh + 1 ].cint ;
if ( psoffset + 28 > maxprintline )
println () ;
print ( 1133 ) ;
while ( pp != 2 ) {
pspairout ( takescaled ( mem [pp + 2 ].cint - mem [pp + 1 ].cint
, scf ) , takescaled ( mem [mem [pp ].hhfield .v.RH + 1 ].cint -
mem [pp + 2 ].cint , scf ) ) ;
pp = mem [pp ].hhfield .v.RH ;
}
if ( psoffset + 22 > maxprintline )
println () ;
print ( 1134 ) ;
printscaled ( takescaled ( dashoffset ( hh ) , scf ) ) ;
print ( 1135 ) ;
}
}
if ( mem [p ].hhfield .b0 == 2 )
if ( ( mem [mem [p + 1 ].hhfield .v.RH ].hhfield .b0 == 0 ) || ( mem [
p + 6 ].hhfield .v.RH != 0 ) )
if ( gslcap != mem [p + 6 ].hhfield .b0 )
{
if ( psoffset + 13 > maxprintline )
println () ;
printchar ( 32 ) ;
printchar ( 48 + mem [p + 6 ].hhfield .b0 ) ;
print ( 1124 ) ;
gslcap = mem [p + 6 ].hhfield .b0 ;
}
if ( gsljoin != mem [p ].hhfield .b1 )
{
if ( psoffset + 14 > maxprintline )
println () ;
printchar ( 32 ) ;
printchar ( 48 + mem [p ].hhfield .b1 ) ;
print ( 1125 ) ;
gsljoin = mem [p ].hhfield .b1 ;
}
if ( gsmiterlim != mem [p + 5 ].cint )
{
if ( psoffset + 27 > maxprintline )
println () ;
printchar ( 32 ) ;
printscaled ( mem [p + 5 ].cint ) ;
print ( 1126 ) ;
gsmiterlim = mem [p + 5 ].cint ;
}
}
if ( psoffset > 0 )
println () ;
}
void
#ifdef HAVE_PROTOTYPES
zstrokeellipse ( halfword h , boolean fillalso )
#else
zstrokeellipse ( h , fillalso )
halfword h ;
boolean fillalso ;
#endif
{
scaled txx, txy, tyx, tyy ;
halfword p ;
scaled d1, det ;
integer s ;
boolean transformed ;
transformed = false ;
p = mem [h + 1 ].hhfield .lhfield ;
txx = mem [p + 3 ].cint ;
tyx = mem [p + 4 ].cint ;
txy = mem [p + 5 ].cint ;
tyy = mem [p + 6 ].cint ;
if ( ( mem [p + 1 ].cint != 0 ) || ( mem [p + 2 ].cint != 0 ) )
{
printnl ( 1139 ) ;
pspairout ( mem [p + 1 ].cint , mem [p + 2 ].cint ) ;
psprint ( 1140 ) ;
txx = txx - mem [p + 1 ].cint ;
tyx = tyx - mem [p + 2 ].cint ;
txy = txy - mem [p + 1 ].cint ;
tyy = tyy - mem [p + 2 ].cint ;
transformed = true ;
}
else printnl ( 284 ) ;
if ( gswidth != 65536L )
if ( gswidth == 0 )
{
txx = 65536L ;
tyy = 65536L ;
}
else {
txx = makescaled ( txx , gswidth ) ;
txy = makescaled ( txy , gswidth ) ;
tyx = makescaled ( tyx , gswidth ) ;
tyy = makescaled ( tyy , gswidth ) ;
}
if ( ( txy != 0 ) || ( tyx != 0 ) || ( txx != 65536L ) || ( tyy != 65536L )
)
if ( ( ! transformed ) )
{
psprint ( 1139 ) ;
transformed = true ;
}
det = takescaled ( txx , tyy ) - takescaled ( txy , tyx ) ;
d1 = 4 * 10 + 1 ;
if ( abs ( det ) < d1 )
{
if ( det >= 0 )
{
d1 = d1 - det ;
s = 1 ;
}
else {
d1 = - (integer) d1 - det ;
s = -1 ;
}
d1 = d1 * 65536L ;
if ( abs ( txx ) + abs ( tyy ) >= abs ( txy ) + abs ( tyy ) )
if ( abs ( txx ) > abs ( tyy ) )
tyy = tyy + ( d1 + s * abs ( txx ) ) / txx ;
else txx = txx + ( d1 + s * abs ( tyy ) ) / tyy ;
else if ( abs ( txy ) > abs ( tyx ) )
tyx = tyx + ( d1 + s * abs ( txy ) ) / txy ;
else txy = txy + ( d1 + s * abs ( tyx ) ) / tyx ;
}
pspathout ( mem [h + 1 ].hhfield .v.RH ) ;
if ( fillalso )
printnl ( 1136 ) ;
if ( ( txy != 0 ) || ( tyx != 0 ) )
{
println () ;
printchar ( 91 ) ;
pspairout ( txx , tyx ) ;
pspairout ( txy , tyy ) ;
psprint ( 1141 ) ;
}
else if ( ( txx != 65536L ) || ( tyy != 65536L ) )
{
println () ;
pspairout ( txx , tyy ) ;
print ( 1142 ) ;
}
psprint ( 1137 ) ;
if ( transformed )
psprint ( 1138 ) ;
println () ;
}
void
#ifdef HAVE_PROTOTYPES
zpsfillout ( halfword p )
#else
zpsfillout ( p )
halfword p ;
#endif
{
pspathout ( p ) ;
psprint ( 1143 ) ;
println () ;
}
void
#ifdef HAVE_PROTOTYPES
zdoouterenvelope ( halfword p , halfword h )
#else
zdoouterenvelope ( p , h )
halfword p ;
halfword h ;
#endif
{
p = makeenvelope ( p , mem [h + 1 ].hhfield .lhfield , mem [h ]
.hhfield .b1 , 0 , mem [h + 5 ].cint ) ;
psfillout ( p ) ;
tossknotlist ( p ) ;
}
scaled
#ifdef HAVE_PROTOTYPES
zchoosescale ( halfword p )
#else
zchoosescale ( p )
halfword p ;
#endif
{
register scaled Result; scaled a, b, c, d, ad, bc ;
a = mem [p + 10 ].cint ;
b = mem [p + 11 ].cint ;
c = mem [p + 12 ].cint ;
d = mem [p + 13 ].cint ;
if ( ( a < 0 ) )
a = - (integer) a ;
if ( ( b < 0 ) )
b = - (integer) b ;
if ( ( c < 0 ) )
c = - (integer) c ;
if ( ( d < 0 ) )
d = - (integer) d ;
ad = half ( a - d ) ;
bc = half ( b - c ) ;
Result = pythadd ( pythadd ( d + ad , ad ) , pythadd ( c + bc , bc ) ) ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zpsstringout ( strnumber s )
#else
zpsstringout ( s )
strnumber s ;
#endif
{
poolpointer i ;
ASCIIcode k ;
print ( 40 ) ;
i = strstart [s ];
while ( i < strstart [nextstr [s ]]) {
if ( psoffset + 5 > maxprintline )
{
printchar ( 92 ) ;
println () ;
}
k = strpool [i ];
if ( ( ( k < 32 ) || ( k > 126 ) ) )
{
printchar ( 92 ) ;
printchar ( 48 + ( k / 64 ) ) ;
printchar ( 48 + ( ( k / 8 ) % 8 ) ) ;
printchar ( 48 + ( k % 8 ) ) ;
}
else {
if ( ( k == 40 ) || ( k == 41 ) || ( k == 92 ) )
printchar ( 92 ) ;
printchar ( k ) ;
}
incr ( i ) ;
}
print ( 41 ) ;
}
boolean
#ifdef HAVE_PROTOTYPES
zispsname ( strnumber s )
#else
zispsname ( s )
strnumber s ;
#endif
{
/* 45 10 */ register boolean Result; poolpointer i ;
ASCIIcode k ;
i = strstart [s ];
while ( i < strstart [nextstr [s ]]) {
k = strpool [i ];
if ( ( k <= 32 ) || ( k > 126 ) )
goto lab45 ;
if ( ( k == 40 ) || ( k == 41 ) || ( k == 60 ) || ( k == 62 ) || ( k ==
123 ) || ( k == 125 ) || ( k == 47 ) || ( k == 37 ) )
goto lab45 ;
incr ( i ) ;
}
Result = true ;
goto lab10 ;
lab45: Result = false ;
lab10: ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zpsnameout ( strnumber s , boolean lit )
#else
zpsnameout ( s , lit )
strnumber s ;
boolean lit ;
#endif
{
if ( psoffset + ( strstart [nextstr [s ]]- strstart [s ]) + 2 >
maxprintline )
println () ;
printchar ( 32 ) ;
if ( ispsname ( s ) )
{
if ( lit )
printchar ( 47 ) ;
print ( s ) ;
}
else {
psstringout ( s ) ;
if ( ! lit )
psprint ( 1144 ) ;
psprint ( 1145 ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
zunmarkfont ( fontnumber f )
#else
zunmarkfont ( f )
fontnumber f ;
#endif
{
integer k ;
{register integer for_end; k = charbase [f ]+ fontbc [f ];for_end =
charbase [f ]+ fontec [f ]; if ( k <= for_end) do
fontinfo [k ].qqqq .b3 = 0 ;
while ( k++ < for_end ) ;}
}
void
#ifdef HAVE_PROTOTYPES
zmarkstringchars ( fontnumber f , strnumber s )
#else
zmarkstringchars ( f , s )
fontnumber f ;
strnumber s ;
#endif
{
integer b ;
poolASCIIcode bc, ec ;
poolpointer k ;
b = charbase [f ];
bc = fontbc [f ];
ec = fontec [f ];
k = strstart [nextstr [s ]];
while ( k > strstart [s ]) {
decr ( k ) ;
if ( ( strpool [k ]>= bc ) && ( strpool [k ]<= ec ) )
fontinfo [b + strpool [k ]].qqqq .b3 = 1 ;
}
}
void
#ifdef HAVE_PROTOTYPES
zhexdigitout ( smallnumber d )
#else
zhexdigitout ( d )
smallnumber d ;
#endif
{
if ( d < 10 )
printchar ( d + 48 ) ;
else printchar ( d + 87 ) ;
}
halfword
#ifdef HAVE_PROTOTYPES
zpsmarksout ( fontnumber f , eightbits c )
#else
zpsmarksout ( f , c )
fontnumber f ;
eightbits c ;
#endif
{
register halfword Result; eightbits bc, ec ;
integer lim ;
integer p ;
char d, b ;
lim = 4 * ( emergencylinelength - psoffset - 4 ) ;
bc = fontbc [f ];
ec = fontec [f ];
if ( c > bc )
bc = c ;
p = charbase [f ]+ bc ;
while ( ( fontinfo [p ].qqqq .b3 == 0 ) && ( bc < ec ) ) {
incr ( p ) ;
incr ( bc ) ;
}
if ( ec >= bc + lim )
ec = bc + lim - 1 ;
p = charbase [f ]+ ec ;
while ( ( fontinfo [p ].qqqq .b3 == 0 ) && ( bc < ec ) ) {
decr ( p ) ;
decr ( ec ) ;
}
printchar ( 32 ) ;
hexdigitout ( bc / 16 ) ;
hexdigitout ( bc % 16 ) ;
printchar ( 58 ) ;
b = 8 ;
d = 0 ;
{register integer for_end; p = charbase [f ]+ bc ;for_end = charbase [f
]+ ec ; if ( p <= for_end) do
{
if ( b == 0 )
{
hexdigitout ( d ) ;
d = 0 ;
b = 8 ;
}
if ( fontinfo [p ].qqqq .b3 != 0 )
d = d + b ;
b = halfp ( b ) ;
}
while ( p++ < for_end ) ;}
hexdigitout ( d ) ;
while ( ( ec < fontec [f ]) && ( fontinfo [p ].qqqq .b3 == 0 ) ) {
incr ( p ) ;
incr ( ec ) ;
}
Result = ec + 1 ;
return Result ;
}
boolean
#ifdef HAVE_PROTOTYPES
zcheckpsmarks ( fontnumber f , integer c )
#else
zcheckpsmarks ( f , c )
fontnumber f ;
integer c ;
#endif
{
/* 10 */ register boolean Result; integer p ;
{register integer for_end; p = charbase [f ]+ c ;for_end = charbase [f
]+ fontec [f ]; if ( p <= for_end) do
if ( fontinfo [p ].qqqq .b3 == 1 )
{
Result = true ;
goto lab10 ;
}
while ( p++ < for_end ) ;}
Result = false ;
lab10: ;
return Result ;
}
quarterword
#ifdef HAVE_PROTOTYPES
zsizeindex ( fontnumber f , scaled s )
#else
zsizeindex ( f , s )
fontnumber f ;
scaled s ;
#endif
{
/* 40 */ register quarterword Result; halfword p, q ;
quarterword i ;
q = fontsizes [f ];
i = 0 ;
while ( q != 0 ) {
if ( abs ( s - mem [q + 1 ].cint ) <= 65 )
goto lab40 ;
else {
p = q ;
q = mem [q ].hhfield .v.RH ;
incr ( i ) ;
}
if ( i == 255 )
overflow ( 1146 , 255 ) ;
}
q = getnode ( 2 ) ;
mem [q + 1 ].cint = s ;
if ( i == 0 )
fontsizes [f ]= q ;
else mem [p ].hhfield .v.RH = q ;
lab40: Result = i ;
return Result ;
}
scaled
#ifdef HAVE_PROTOTYPES
zindexedsize ( fontnumber f , quarterword j )
#else
zindexedsize ( f , j )
fontnumber f ;
quarterword j ;
#endif
{
register scaled Result; halfword p ;
quarterword i ;
p = fontsizes [f ];
i = 0 ;
if ( p == 0 )
confusion ( 1147 ) ;
while ( ( i != j ) ) {
incr ( i ) ;
p = mem [p ].hhfield .v.RH ;
if ( p == 0 )
confusion ( 1147 ) ;
}
Result = mem [p + 1 ].cint ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
clearsizes ( void )
#else
clearsizes ( )
#endif
{
fontnumber f ;
halfword p ;
{register integer for_end; f = 1 ;for_end = lastfnum ; if ( f <= for_end)
do
while ( fontsizes [f ]!= 0 ) {
p = fontsizes [f ];
fontsizes [f ]= mem [p ].hhfield .v.RH ;
freenode ( p , 2 ) ;
}
while ( f++ < for_end ) ;}
}
void
#ifdef HAVE_PROTOTYPES
zshipout ( halfword h )
#else
zshipout ( h )
halfword h ;
#endif
{
/* 30 40 */ halfword p ;
halfword q ;
integer t ;
fontnumber f, ff ;
fontnumber ldf ;
boolean donefonts ;
quarterword nextsize ;
halfword curfsize[fontmax + 1] ;
scaled ds, scf ;
boolean transformed ;
openoutputfile () ;
if ( ( internal [32 ]> 0 ) && ( lastpsfnum < lastfnum ) )
readpsnametable () ;
nonpssetting = selector ;
selector = 5 ;
print ( 1156 ) ;
if ( internal [32 ]> 0 )
print ( 1157 ) ;
printnl ( 1158 ) ;
setbbox ( h , true ) ;
if ( mem [h + 2 ].cint > mem [h + 4 ].cint )
print ( 1159 ) ;
else if ( internal [32 ]< 0 )
{
pspairout ( mem [h + 2 ].cint , mem [h + 3 ].cint ) ;
pspairout ( mem [h + 4 ].cint , mem [h + 5 ].cint ) ;
}
else {
pspairout ( floorscaled ( mem [h + 2 ].cint ) , floorscaled ( mem [h +
3 ].cint ) ) ;
pspairout ( - (integer) floorscaled ( - (integer) mem [h + 4 ].cint ) ,
- (integer) floorscaled ( - (integer) mem [h + 5 ].cint ) ) ;
}
printnl ( 1160 ) ;
printnl ( 1161 ) ;
printint ( roundunscaled ( internal [13 ]) ) ;
printchar ( 46 ) ;
printdd ( roundunscaled ( internal [14 ]) ) ;
printchar ( 46 ) ;
printdd ( roundunscaled ( internal [15 ]) ) ;
printchar ( 58 ) ;
t = roundunscaled ( internal [16 ]) ;
printdd ( t / 60 ) ;
printdd ( t % 60 ) ;
printnl ( 1162 ) ;
{register integer for_end; f = 1 ;for_end = lastfnum ; if ( f <= for_end)
do
fontsizes [f ]= 0 ;
while ( f++ < for_end ) ;}
p = mem [h + 7 ].hhfield .v.RH ;
while ( p != 0 ) {
if ( mem [p ].hhfield .b0 == 3 )
if ( mem [p + 1 ].hhfield .lhfield != 0 )
{
f = mem [p + 1 ].hhfield .lhfield ;
if ( internal [32 ]> 0 )
fontsizes [f ]= 1 ;
else {
if ( fontsizes [f ]== 0 )
unmarkfont ( f ) ;
mem [p ].hhfield .b1 = sizeindex ( f , choosescale ( p ) ) ;
if ( mem [p ].hhfield .b1 == 0 )
markstringchars ( f , mem [p + 1 ].hhfield .v.RH ) ;
}
}
p = mem [p ].hhfield .v.RH ;
}
if ( internal [32 ]> 0 )
{
ldf = 0 ;
{register integer for_end; f = 1 ;for_end = lastfnum ; if ( f <=
for_end) do
if ( fontsizes [f ]!= 0 )
{
if ( ldf == 0 )
printnl ( 1163 ) ;
{register integer for_end; ff = ldf ;for_end = 0 ; if ( ff >=
for_end) do
if ( fontsizes [ff ]!= 0 )
if ( strvsstr ( fontpsname [f ], fontpsname [ff ]) == 0 )
goto lab40 ;
while ( ff-- > for_end ) ;}
if ( psoffset + 1 + ( strstart [nextstr [fontpsname [f ]]]-
strstart [fontpsname [f ]]) > maxprintline )
printnl ( 1164 ) ;
printchar ( 32 ) ;
print ( fontpsname [f ]) ;
ldf = f ;
lab40: ;
}
while ( f++ < for_end ) ;}
}
else {
nextsize = 0 ;
{register integer for_end; f = 1 ;for_end = lastfnum ; if ( f <=
for_end) do
curfsize [f ]= fontsizes [f ];
while ( f++ < for_end ) ;}
do {
donefonts = true ;
{register integer for_end; f = 1 ;for_end = lastfnum ; if ( f <=
for_end) do
{
if ( curfsize [f ]!= 0 )
{
t = 0 ;
while ( checkpsmarks ( f , t ) ) {
printnl ( 1165 ) ;
if ( psoffset + ( strstart [nextstr [fontname [f ]]]-
strstart [fontname [f ]]) + 12 > emergencylinelength )
goto lab30 ;
print ( fontname [f ]) ;
printchar ( 32 ) ;
ds = ( fontdsize [f ]+ 8 ) / 16 ;
printscaled ( takescaled ( ds , mem [curfsize [f ]+ 1 ].cint
) ) ;
if ( psoffset + 12 > emergencylinelength )
goto lab30 ;
printchar ( 32 ) ;
printscaled ( ds ) ;
if ( psoffset + 5 > emergencylinelength )
goto lab30 ;
t = psmarksout ( f , t ) ;
}
lab30: curfsize [f ]= mem [curfsize [f ]].hhfield .v.RH ;
}
if ( curfsize [f ]!= 0 )
{
unmarkfont ( f ) ;
donefonts = false ;
}
}
while ( f++ < for_end ) ;}
if ( ! donefonts )
{
incr ( nextsize ) ;
p = mem [h + 7 ].hhfield .v.RH ;
while ( p != 0 ) {
if ( mem [p ].hhfield .b0 == 3 )
if ( mem [p + 1 ].hhfield .lhfield != 0 )
if ( mem [p ].hhfield .b1 == nextsize )
markstringchars ( mem [p + 1 ].hhfield .lhfield , mem [p + 1 ]
.hhfield .v.RH ) ;
p = mem [p ].hhfield .v.RH ;
}
}
} while ( ! ( donefonts ) ) ;
}
println () ;
if ( internal [32 ]> 0 )
{
if ( ldf != 0 )
{
{register integer for_end; f = 1 ;for_end = lastfnum ; if ( f <=
for_end) do
if ( fontsizes [f ]!= 0 )
{
psnameout ( fontname [f ], true ) ;
psnameout ( fontpsname [f ], true ) ;
psprint ( 1166 ) ;
println () ;
}
while ( f++ < for_end ) ;}
print ( 1167 ) ;
println () ;
}
}
print ( 1151 ) ;
printnl ( 1152 ) ;
println () ;
t = mem [memtop - 3 ].hhfield .v.RH ;
while ( t != 0 ) {
if ( ( strstart [nextstr [mem [t + 1 ].cint ]]- strstart [mem [t +
1 ].cint ]) <= emergencylinelength )
print ( mem [t + 1 ].cint ) ;
else overflow ( 1150 , emergencylinelength ) ;
println () ;
t = mem [t ].hhfield .v.RH ;
}
flushtokenlist ( mem [memtop - 3 ].hhfield .v.RH ) ;
mem [memtop - 3 ].hhfield .v.RH = 0 ;
lastpending = memtop - 3 ;
unknowngraphicsstate ( 0 ) ;
neednewpath = true ;
p = mem [h + 7 ].hhfield .v.RH ;
while ( p != 0 ) {
fixgraphicsstate ( p ) ;
switch ( mem [p ].hhfield .b0 )
{case 4 :
{
printnl ( 1139 ) ;
pspathout ( mem [p + 1 ].hhfield .v.RH ) ;
psprint ( 1168 ) ;
println () ;
}
break ;
case 6 :
{
printnl ( 1169 ) ;
println () ;
unknowngraphicsstate ( -1 ) ;
}
break ;
case 1 :
if ( mem [p + 1 ].hhfield .lhfield == 0 )
psfillout ( mem [p + 1 ].hhfield .v.RH ) ;
else if ( ( mem [p + 1 ].hhfield .lhfield == mem [mem [p + 1 ]
.hhfield .lhfield ].hhfield .v.RH ) )
strokeellipse ( p , true ) ;
else {
doouterenvelope ( copypath ( mem [p + 1 ].hhfield .v.RH ) , p ) ;
doouterenvelope ( htapypoc ( mem [p + 1 ].hhfield .v.RH ) , p ) ;
}
break ;
case 2 :
if ( ( mem [p + 1 ].hhfield .lhfield == mem [mem [p + 1 ].hhfield
.lhfield ].hhfield .v.RH ) )
strokeellipse ( p , false ) ;
else {
q = copypath ( mem [p + 1 ].hhfield .v.RH ) ;
t = mem [p + 6 ].hhfield .b0 ;
if ( mem [q ].hhfield .b0 != 0 )
{
mem [insertknot ( q , mem [q + 1 ].cint , mem [q + 2 ].cint ) ]
.hhfield .b0 = 0 ;
mem [q ].hhfield .b1 = 0 ;
q = mem [q ].hhfield .v.RH ;
t = 1 ;
}
q = makeenvelope ( q , mem [p + 1 ].hhfield .lhfield , mem [p ]
.hhfield .b1 , t , mem [p + 5 ].cint ) ;
psfillout ( q ) ;
tossknotlist ( q ) ;
}
break ;
case 3 :
if ( ( mem [p + 1 ].hhfield .lhfield != 0 ) && ( ( strstart [nextstr
[mem [p + 1 ].hhfield .v.RH ]]- strstart [mem [p + 1 ].hhfield
.v.RH ]) > 0 ) )
{
if ( internal [32 ]> 0 )
scf = choosescale ( p ) ;
else scf = indexedsize ( mem [p + 1 ].hhfield .lhfield , mem [p ]
.hhfield .b1 ) ;
transformed = ( mem [p + 10 ].cint != scf ) || ( mem [p + 13 ]
.cint != scf ) || ( mem [p + 11 ].cint != 0 ) || ( mem [p + 12 ]
.cint != 0 ) ;
if ( transformed )
{
print ( 1171 ) ;
pspairout ( makescaled ( mem [p + 10 ].cint , scf ) , makescaled (
mem [p + 12 ].cint , scf ) ) ;
pspairout ( makescaled ( mem [p + 11 ].cint , scf ) , makescaled (
mem [p + 13 ].cint , scf ) ) ;
pspairout ( mem [p + 8 ].cint , mem [p + 9 ].cint ) ;
psprint ( 1172 ) ;
}
else {
pspairout ( mem [p + 8 ].cint , mem [p + 9 ].cint ) ;
psprint ( 1119 ) ;
}
println () ;
psstringout ( mem [p + 1 ].hhfield .v.RH ) ;
psnameout ( fontname [mem [p + 1 ].hhfield .lhfield ], false ) ;
if ( psoffset + 18 > maxprintline )
println () ;
printchar ( 32 ) ;
ds = ( fontdsize [mem [p + 1 ].hhfield .lhfield ]+ 8 ) / 16 ;
printscaled ( takescaled ( ds , scf ) ) ;
print ( 1170 ) ;
if ( transformed )
psprint ( 1138 ) ;
println () ;
}
break ;
case 5 :
case 7 :
;
break ;
}
p = mem [p ].hhfield .v.RH ;
}
print ( 1153 ) ;
println () ;
print ( 1154 ) ;
println () ;
aclose ( psfile ) ;
selector = nonpssetting ;
if ( internal [32 ]<= 0 )
clearsizes () ;
printchar ( 93 ) ;
fflush ( stdout ) ;
incr ( totalshipped ) ;
if ( internal [9 ]> 0 )
printedges ( h , 1155 , true ) ;
}
void
#ifdef HAVE_PROTOTYPES
doshipout ( void )
#else
doshipout ( )
#endif
{
integer c ;
getxnext () ;
scanexpression () ;
if ( curtype != 10 )
{
disperr ( 0 , 1032 ) ;
{
helpptr = 1 ;
helpline [0 ]= 1033 ;
}
putgetflusherror ( 0 ) ;
}
else {
c = roundunscaled ( internal [17 ]) % 256 ;
if ( c < 0 )
c = c + 256 ;
if ( c < bc )
bc = c ;
if ( c > ec )
ec = c ;
charexists [c ]= true ;
tfmwidth [c ]= tfmcheck ( 19 ) ;
tfmheight [c ]= tfmcheck ( 20 ) ;
tfmdepth [c ]= tfmcheck ( 21 ) ;
tfmitalcorr [c ]= tfmcheck ( 22 ) ;
shipout ( curexp ) ;
flushcurexp ( 0 ) ;
}
}
void
#ifdef HAVE_PROTOTYPES
znostringerr ( strnumber s )
#else
znostringerr ( s )
strnumber s ;
#endif
{
disperr ( 0 , 740 ) ;
{
helpptr = 1 ;
helpline [0 ]= s ;
}
putgeterror () ;
}
void
#ifdef HAVE_PROTOTYPES
domessage ( void )
#else
domessage ( )
#endif
{
char m ;
m = curmod ;
getxnext () ;
scanexpression () ;
if ( curtype != 4 )
nostringerr ( 1037 ) ;
else switch ( m )
{case 0 :
{
printnl ( 284 ) ;
print ( curexp ) ;
}
break ;
case 1 :
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 284 ) ;
}
print ( curexp ) ;
if ( errhelp != 0 )
useerrhelp = true ;
else if ( longhelpseen )
{
helpptr = 1 ;
helpline [0 ]= 1038 ;
}
else {
if ( interaction < 3 )
longhelpseen = true ;
{
helpptr = 4 ;
helpline [3 ]= 1039 ;
helpline [2 ]= 1040 ;
helpline [1 ]= 1041 ;
helpline [0 ]= 1042 ;
}
}
putgeterror () ;
useerrhelp = false ;
}
break ;
case 2 :
{
if ( errhelp != 0 )
{
if ( strref [errhelp ]< 127 )
if ( strref [errhelp ]> 1 )
decr ( strref [errhelp ]) ;
else flushstring ( errhelp ) ;
}
if ( ( strstart [nextstr [curexp ]]- strstart [curexp ]) == 0 )
errhelp = 0 ;
else {
errhelp = curexp ;
{
if ( strref [errhelp ]< 127 )
incr ( strref [errhelp ]) ;
}
}
}
break ;
}
flushcurexp ( 0 ) ;
}
void
#ifdef HAVE_PROTOTYPES
dowrite ( void )
#else
dowrite ( )
#endif
{
/* 22 */ strnumber t ;
writeindex n, n0 ;
char oldsetting ;
getxnext () ;
scanexpression () ;
if ( curtype != 4 )
nostringerr ( 1043 ) ;
else if ( curcmd != 71 )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 1044 ) ;
}
{
helpptr = 1 ;
helpline [0 ]= 1045 ;
}
putgeterror () ;
}
else {
t = curexp ;
curtype = 1 ;
getxnext () ;
scanexpression () ;
if ( curtype != 4 )
nostringerr ( 1046 ) ;
else {
n = writefiles ;
n0 = writefiles ;
do {
lab22: if ( n == 0 )
{
if ( n0 == writefiles )
if ( writefiles < 4 )
incr ( writefiles ) ;
else overflow ( 1047 , 4 ) ;
n = n0 ;
openwritefile ( curexp , n ) ;
}
else {
decr ( n ) ;
if ( wrfname [n ]== 0 )
{
n0 = n ;
goto lab22 ;
}
}
} while ( ! ( strvsstr ( curexp , wrfname [n ]) == 0 ) ) ;
if ( eofline == 0 )
{
{
strpool [poolptr ]= 0 ;
incr ( poolptr ) ;
}
eofline = makestring () ;
strref [eofline ]= 127 ;
}
if ( strvsstr ( t , eofline ) == 0 )
{
aclose ( wrfile [n ]) ;
{
if ( strref [wrfname [n ]]< 127 )
if ( strref [wrfname [n ]]> 1 )
decr ( strref [wrfname [n ]]) ;
else flushstring ( wrfname [n ]) ;
}
wrfname [n ]= 0 ;
if ( n == writefiles - 1 )
writefiles = n ;
}
else {
oldsetting = selector ;
selector = n ;
print ( t ) ;
println () ;
selector = oldsetting ;
}
}
{
if ( strref [t ]< 127 )
if ( strref [t ]> 1 )
decr ( strref [t ]) ;
else flushstring ( t ) ;
}
}
flushcurexp ( 0 ) ;
}
eightbits
#ifdef HAVE_PROTOTYPES
getcode ( void )
#else
getcode ( )
#endif
{
/* 40 */ register eightbits Result; integer c ;
getxnext () ;
scanexpression () ;
if ( curtype == 16 )
{
c = roundunscaled ( curexp ) ;
if ( c >= 0 )
if ( c < 256 )
goto lab40 ;
}
else if ( curtype == 4 )
if ( ( strstart [nextstr [curexp ]]- strstart [curexp ]) == 1 )
{
c = strpool [strstart [curexp ]];
goto lab40 ;
}
disperr ( 0 , 1056 ) ;
{
helpptr = 2 ;
helpline [1 ]= 1057 ;
helpline [0 ]= 1058 ;
}
putgetflusherror ( 0 ) ;
c = 0 ;
lab40: Result = c ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
zsettag ( halfword c , smallnumber t , halfword r )
#else
zsettag ( c , t , r )
halfword c ;
smallnumber t ;
halfword r ;
#endif
{
if ( chartag [c ]== 0 )
{
chartag [c ]= t ;
charremainder [c ]= r ;
if ( t == 1 )
{
incr ( labelptr ) ;
labelloc [labelptr ]= r ;
labelchar [labelptr ]= c ;
}
}
else {
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 1059 ) ;
}
if ( ( c > 32 ) && ( c < 127 ) )
print ( c ) ;
else if ( c == 256 )
print ( 1060 ) ;
else {
print ( 1061 ) ;
printint ( c ) ;
}
print ( 1062 ) ;
switch ( chartag [c ])
{case 1 :
print ( 1063 ) ;
break ;
case 2 :
print ( 1064 ) ;
break ;
case 3 :
print ( 1053 ) ;
break ;
}
{
helpptr = 2 ;
helpline [1 ]= 1065 ;
helpline [0 ]= 1019 ;
}
putgeterror () ;
}
}
void
#ifdef HAVE_PROTOTYPES
dotfmcommand ( void )
#else
dotfmcommand ( )
#endif
{
/* 22 30 */ short c, cc ;
integer k ;
integer j ;
switch ( curmod )
{case 0 :
{
c = getcode () ;
while ( curcmd == 80 ) {
cc = getcode () ;
settag ( c , 2 , cc ) ;
c = cc ;
}
}
break ;
case 1 :
{
lkstarted = false ;
lab22: getxnext () ;
if ( ( curcmd == 77 ) && lkstarted )
{
c = getcode () ;
if ( nl - skiptable [c ]> 128 )
{
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 1082 ) ;
}
{
helpptr = 1 ;
helpline [0 ]= 1083 ;
}
error () ;
ll = skiptable [c ];
do {
lll = ligkern [ll ].b0 ;
ligkern [ll ].b0 = 128 ;
ll = ll - lll ;
} while ( ! ( lll == 0 ) ) ;
}
skiptable [c ]= ligtablesize ;
}
if ( skiptable [c ]== ligtablesize )
ligkern [nl - 1 ].b0 = 0 ;
else ligkern [nl - 1 ].b0 = nl - skiptable [c ]- 1 ;
skiptable [c ]= nl - 1 ;
goto lab30 ;
}
if ( curcmd == 78 )
{
c = 256 ;
curcmd = 80 ;
}
else {
backinput () ;
c = getcode () ;
}
if ( ( curcmd == 80 ) || ( curcmd == 79 ) )
{
if ( curcmd == 80 )
if ( c == 256 )
bchlabel = nl ;
else settag ( c , 1 , nl ) ;
else if ( skiptable [c ]< ligtablesize )
{
ll = skiptable [c ];
skiptable [c ]= ligtablesize ;
do {
lll = ligkern [ll ].b0 ;
if ( nl - ll > 128 )
{
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 1082 ) ;
}
{
helpptr = 1 ;
helpline [0 ]= 1083 ;
}
error () ;
ll = ll ;
do {
lll = ligkern [ll ].b0 ;
ligkern [ll ].b0 = 128 ;
ll = ll - lll ;
} while ( ! ( lll == 0 ) ) ;
}
goto lab22 ;
}
ligkern [ll ].b0 = nl - ll - 1 ;
ll = ll - lll ;
} while ( ! ( lll == 0 ) ) ;
}
goto lab22 ;
}
if ( curcmd == 75 )
{
ligkern [nl ].b1 = c ;
ligkern [nl ].b0 = 0 ;
if ( curmod < 128 )
{
ligkern [nl ].b2 = curmod ;
ligkern [nl ].b3 = getcode () ;
}
else {
getxnext () ;
scanexpression () ;
if ( curtype != 16 )
{
disperr ( 0 , 1084 ) ;
{
helpptr = 2 ;
helpline [1 ]= 1085 ;
helpline [0 ]= 308 ;
}
putgetflusherror ( 0 ) ;
}
kern [nk ]= curexp ;
k = 0 ;
while ( kern [k ]!= curexp ) incr ( k ) ;
if ( k == nk )
{
if ( nk == maxkerns )
overflow ( 1081 , maxkerns ) ;
incr ( nk ) ;
}
ligkern [nl ].b2 = 128 + ( k / 256 ) ;
ligkern [nl ].b3 = ( k % 256 ) ;
}
lkstarted = true ;
}
else {
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 1070 ) ;
}
{
helpptr = 1 ;
helpline [0 ]= 1071 ;
}
backerror () ;
ligkern [nl ].b1 = 0 ;
ligkern [nl ].b2 = 0 ;
ligkern [nl ].b3 = 0 ;
ligkern [nl ].b0 = 129 ;
}
if ( nl == ligtablesize )
overflow ( 1072 , ligtablesize ) ;
incr ( nl ) ;
if ( curcmd == 81 )
goto lab22 ;
if ( ligkern [nl - 1 ].b0 < 128 )
ligkern [nl - 1 ].b0 = 128 ;
lab30: ;
}
break ;
case 2 :
{
if ( ne == 256 )
overflow ( 1053 , 256 ) ;
c = getcode () ;
settag ( c , 3 , ne ) ;
if ( curcmd != 80 )
{
missingerr ( 58 ) ;
{
helpptr = 1 ;
helpline [0 ]= 1086 ;
}
backerror () ;
}
exten [ne ].b0 = getcode () ;
if ( curcmd != 81 )
{
missingerr ( 44 ) ;
{
helpptr = 1 ;
helpline [0 ]= 1086 ;
}
backerror () ;
}
exten [ne ].b1 = getcode () ;
if ( curcmd != 81 )
{
missingerr ( 44 ) ;
{
helpptr = 1 ;
helpline [0 ]= 1086 ;
}
backerror () ;
}
exten [ne ].b2 = getcode () ;
if ( curcmd != 81 )
{
missingerr ( 44 ) ;
{
helpptr = 1 ;
helpline [0 ]= 1086 ;
}
backerror () ;
}
exten [ne ].b3 = getcode () ;
incr ( ne ) ;
}
break ;
case 3 :
case 4 :
{
c = curmod ;
getxnext () ;
scanexpression () ;
if ( ( curtype != 16 ) || ( curexp < 32768L ) )
{
disperr ( 0 , 1066 ) ;
{
helpptr = 2 ;
helpline [1 ]= 1067 ;
helpline [0 ]= 1068 ;
}
putgeterror () ;
}
else {
j = roundunscaled ( curexp ) ;
if ( curcmd != 80 )
{
missingerr ( 58 ) ;
{
helpptr = 1 ;
helpline [0 ]= 1069 ;
}
backerror () ;
}
if ( c == 3 )
do {
if ( j > headersize )
overflow ( 1054 , headersize ) ;
headerbyte [j ]= getcode () ;
incr ( j ) ;
} while ( ! ( curcmd != 81 ) ) ;
else do {
if ( j > maxfontdimen )
overflow ( 1055 , maxfontdimen ) ;
while ( j > np ) {
incr ( np ) ;
param [np ]= 0 ;
}
getxnext () ;
scanexpression () ;
if ( curtype != 16 )
{
disperr ( 0 , 1087 ) ;
{
helpptr = 1 ;
helpline [0 ]= 308 ;
}
putgetflusherror ( 0 ) ;
}
param [j ]= curexp ;
incr ( j ) ;
} while ( ! ( curcmd != 81 ) ) ;
}
}
break ;
}
}
|
