#define EXTERN extern
#include "mpd.h"
halfword curtok ( )
{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 backinput ( )
{halfword p ;
p = curtok () ;
while ( ( curinput .indexfield > 15 ) && ( curinput .locfield == 0 ) )
endtokenlist () ;
begintokenlist ( p , 19 ) ;
}
void backerror ( )
{OKtointerrupt = false ;
backinput () ;
OKtointerrupt = true ;
error () ;
}
void inserror ( )
{OKtointerrupt = false ;
backinput () ;
curinput .indexfield = 20 ;
OKtointerrupt = true ;
error () ;
}
void beginfilereading ( )
{if ( inopen == 15 )
overflow ( 628 , 15 ) ;
if ( first == bufsize )
overflow ( 256 , bufsize ) ;
incr ( inopen ) ;
{
if ( inputptr > maxinstack )
{
maxinstack = inputptr ;
if ( inputptr == stacksize )
overflow ( 627 , stacksize ) ;
}
inputstack [ inputptr ] = curinput ;
incr ( inputptr ) ;
}
curinput .indexfield = inopen ;
mpxname [ curinput .indexfield ] = 1 ;
curinput .startfield = first ;
curinput .namefield = 0 ;
}
void endfilereading ( )
{if ( inopen > curinput .indexfield )
if ( ( mpxname [ inopen ] == 1 ) || ( curinput .namefield <= 2 ) )
confusion ( 629 ) ;
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 ( 629 ) ;
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 beginmpxreading ( )
{register boolean Result; if ( inopen != curinput .indexfield + 1 )
Result = false ;
else {
if ( mpxname [ inopen ] <= 1 )
confusion ( 630 ) ;
if ( first == bufsize )
overflow ( 256 , bufsize ) ;
{
if ( inputptr > maxinstack )
{
maxinstack = inputptr ;
if ( inputptr == stacksize )
overflow ( 627 , 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 endmpxreading ( )
{if ( inopen != curinput .indexfield )
confusion ( 630 ) ;
if ( curinput .locfield < curinput .limitfield )
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 631 ) ;
}
{
helpptr = 4 ;
helpline [ 3 ] = 632 ;
helpline [ 2 ] = 633 ;
helpline [ 1 ] = 634 ;
helpline [ 0 ] = 635 ;
}
error () ;
}
first = curinput .startfield ;
{
decr ( inputptr ) ;
curinput = inputstack [ inputptr ] ;
}
}
void clearforerrorprompt ( )
{while ( ( curinput .indexfield <= 15 ) && ( curinput .namefield == 0 ) && (
inputptr > 0 ) && ( curinput .locfield == curinput .limitfield ) )
endfilereading () ;
println () ;
flush ( termin ) ;
}
boolean checkoutervalidity ( )
{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 ( 263 ) ;
print ( 641 ) ;
}
printint ( warninginfo ) ;
{
helpptr = 2 ;
helpline [ 1 ] = 642 ;
helpline [ 0 ] = 643 ;
}
cursym = 2368 ;
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 ( 263 ) ;
print ( 644 ) ;
}
else {
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 645 ) ;
}
}
print ( 646 ) ;
{
helpptr = 4 ;
helpline [ 3 ] = 647 ;
helpline [ 2 ] = 648 ;
helpline [ 1 ] = 649 ;
helpline [ 0 ] = 650 ;
}
switch ( scannerstatus )
{case 2 :
{
print ( 651 ) ;
helpline [ 3 ] = 652 ;
cursym = 2363 ;
}
break ;
case 3 :
{
print ( 653 ) ;
helpline [ 3 ] = 654 ;
if ( warninginfo == 0 )
cursym = 2367 ;
else {
cursym = 2359 ;
eqtb [ 2359 ] .v.RH = warninginfo ;
}
}
break ;
case 4 :
case 5 :
{
print ( 655 ) ;
if ( scannerstatus == 5 )
print ( hash [ warninginfo ] .v.RH ) ;
else printvariablename ( warninginfo ) ;
cursym = 2365 ;
}
break ;
case 6 :
{
print ( 656 ) ;
print ( hash [ warninginfo ] .v.RH ) ;
print ( 657 ) ;
helpline [ 3 ] = 658 ;
cursym = 2364 ;
}
break ;
}
inserror () ;
}
else {
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 636 ) ;
}
printint ( warninginfo ) ;
{
helpptr = 3 ;
helpline [ 2 ] = 637 ;
helpline [ 1 ] = 638 ;
helpline [ 0 ] = 639 ;
}
if ( cursym == 0 )
helpline [ 2 ] = 640 ;
cursym = 2366 ;
inserror () ;
}
deletionsallowed = true ;
Result = false ;
}
return(Result) ;
}
void getnext ( )
{/* 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 ( 263 ) ;
print ( 677 ) ;
}
{
helpptr = 4 ;
helpline [ 3 ] = 678 ;
helpline [ 2 ] = 633 ;
helpline [ 1 ] = 679 ;
helpline [ 0 ] = 680 ;
}
deletionsallowed = false ;
error () ;
deletionsallowed = true ;
cursym = 2369 ;
goto lab50 ;
}
else {
printchar ( 41 ) ;
decr ( openparens ) ;
flush ( termout ) ;
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 < 6 )
openlogfile () ;
if ( interaction > 1 )
{
if ( curinput .limitfield == curinput .startfield )
printnl ( 675 ) ;
println () ;
first = curinput .startfield ;
{
;
print ( 42 ) ;
terminput () ;
}
curinput .limitfield = last ;
buffer [ curinput .limitfield ] = 37 ;
first = curinput .limitfield + 1 ;
curinput .locfield = curinput .startfield ;
}
else fatalerror ( 676 ) ;
}
{
if ( interrupt != 0 )
pauseforinstructions () ;
}
goto lab25 ;
}
break ;
case 4 :
if ( scannerstatus == 7 )
goto lab25 ;
else {
if ( buffer [ curinput .locfield ] == 34 )
curmod = 285 ;
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 ( 263 ) ;
print ( 666 ) ;
}
{
helpptr = 3 ;
helpline [ 2 ] = 667 ;
helpline [ 1 ] = 668 ;
helpline [ 0 ] = 669 ;
}
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 ( 263 ) ;
print ( 663 ) ;
}
{
helpptr = 2 ;
helpline [ 1 ] = 664 ;
helpline [ 0 ] = 665 ;
}
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 )
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 673 ) ;
}
printscaled ( curmod ) ;
printchar ( 41 ) ;
{
helpptr = 3 ;
helpline [ 2 ] = 674 ;
helpline [ 1 ] = 605 ;
helpline [ 0 ] = 606 ;
}
error () ;
}
}
else if ( scannerstatus != 7 )
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 670 ) ;
}
{
helpptr = 2 ;
helpline [ 1 ] = 671 ;
helpline [ 0 ] = 672 ;
}
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 >= 2372 )
if ( cursym >= 2522 )
{
if ( cursym >= 2672 )
cursym = cursym - 150 ;
begintokenlist ( paramstack [ curinput .limitfield + cursym - ( 2522 ) ]
, 18 ) ;
goto lab20 ;
}
else {
curcmd = 40 ;
curmod = paramstack [ curinput .limitfield + cursym - ( 2372 ) ] ;
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 firmuptheline ( )
{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 ( 681 ) ;
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 tnext ( )
{/* 65 50 */ char oldstatus ;
integer oldinfo ;
while ( curcmd <= 3 ) {
if ( curcmd == 3 )
if ( ! ( curinput .indexfield <= 15 ) || ( mpxname [ curinput .indexfield
] == 1 ) )
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 691 ) ;
}
{
helpptr = 2 ;
helpline [ 1 ] = 692 ;
helpline [ 0 ] = 693 ;
}
error () ;
}
else {
endmpxreading () ;
goto lab65 ;
}
else if ( curcmd == 1 )
if ( ( curinput .indexfield > 15 ) || ( curinput .namefield <= 2 ) )
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 687 ) ;
}
{
helpptr = 3 ;
helpline [ 2 ] = 688 ;
helpline [ 1 ] = 689 ;
helpline [ 0 ] = 690 ;
}
error () ;
}
else if ( ( mpxname [ curinput .indexfield ] > 1 ) )
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 684 ) ;
}
{
helpptr = 4 ;
helpline [ 3 ] = 632 ;
helpline [ 2 ] = 633 ;
helpline [ 1 ] = 685 ;
helpline [ 0 ] = 686 ;
}
error () ;
}
else if ( ( curmod != 1 ) && ( mpxname [ curinput .indexfield ] != 0 ) )
{
if ( ! beginmpxreading () )
startmpxinput () ;
}
else goto lab65 ;
else {
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 694 ) ;
}
{
helpptr = 1 ;
helpline [ 0 ] = 695 ;
}
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 zscantoks ( terminator , substlist , tailend , suffixcount )
commandcode terminator ;
halfword substlist ;
halfword tailend ;
smallnumber suffixcount ;
{/* 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 = 2521 + 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 getsymbol ( )
{/* 20 */ lab20: {
getnext () ;
if ( curcmd <= 3 )
tnext () ;
}
if ( ( cursym == 0 ) || ( cursym > 2357 ) )
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 707 ) ;
}
{
helpptr = 3 ;
helpline [ 2 ] = 708 ;
helpline [ 1 ] = 709 ;
helpline [ 0 ] = 710 ;
}
if ( cursym > 0 )
helpline [ 2 ] = 711 ;
else if ( curcmd == 41 )
{
if ( strref [ curmod ] < 127 )
if ( strref [ curmod ] > 1 )
decr ( strref [ curmod ] ) ;
else flushstring ( curmod ) ;
}
cursym = 2357 ;
inserror () ;
goto lab20 ;
}
}
void getclearsymbol ( )
{getsymbol () ;
clearsymbol ( cursym , false ) ;
}
void checkequals ( )
{if ( curcmd != 53 )
if ( curcmd != 76 )
{
missingerr ( 61 ) ;
{
helpptr = 5 ;
helpline [ 4 ] = 712 ;
helpline [ 3 ] = 713 ;
helpline [ 2 ] = 714 ;
helpline [ 1 ] = 715 ;
helpline [ 0 ] = 716 ;
}
backerror () ;
}
}
void makeopdef ( )
{commandcode m ;
halfword p, q, r ;
m = curmod ;
getsymbol () ;
q = getnode ( 2 ) ;
mem [ q ] .hhfield .lhfield = cursym ;
mem [ q + 1 ] .cint = 2372 ;
getclearsymbol () ;
warninginfo = cursym ;
getsymbol () ;
p = getnode ( 2 ) ;
mem [ p ] .hhfield .lhfield = cursym ;
mem [ p + 1 ] .cint = 2373 ;
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 zcheckdelimiter ( ldelim , rdelim )
halfword ldelim ;
halfword rdelim ;
{/* 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 ( 263 ) ;
print ( 972 ) ;
}
print ( hash [ rdelim ] .v.RH ) ;
print ( 973 ) ;
{
helpptr = 3 ;
helpline [ 2 ] = 974 ;
helpline [ 1 ] = 975 ;
helpline [ 0 ] = 976 ;
}
error () ;
}
lab10: ;
}
halfword scandeclaredvariable ( )
{/* 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 scandef ( )
{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 ( 263 ) ;
print ( 723 ) ;
}
{
helpptr = 2 ;
helpline [ 1 ] = 724 ;
helpline [ 0 ] = 725 ;
}
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 >= 2372 ) )
base = curmod ;
else {
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 726 ) ;
}
{
helpptr = 1 ;
helpline [ 0 ] = 727 ;
}
backerror () ;
base = 2372 ;
}
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 ( 728 , 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 < 2372 )
{
c = curmod ;
mem [ p + 1 ] .cint = 2372 + k ;
}
else {
mem [ p + 1 ] .cint = curmod + k ;
if ( curmod == 2372 )
c = 4 ;
else if ( curmod == 2522 )
c = 6 ;
else c = 7 ;
}
if ( k == 150 )
overflow ( 728 , 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 ( 728 , 150 ) ;
mem [ p + 1 ] .cint = 2372 + 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 zprintmacroname ( a , n )
halfword a ;
halfword n ;
{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 zprintarg ( q , n , b )
halfword q ;
integer n ;
halfword b ;
{if ( mem [ q ] .hhfield .v.RH == 1 )
printnl ( 510 ) ;
else if ( ( b < 2672 ) && ( b != 7 ) )
printnl ( 511 ) ;
else printnl ( 512 ) ;
printint ( n ) ;
print ( 744 ) ;
if ( mem [ q ] .hhfield .v.RH == 1 )
printexp ( q , 1 ) ;
else showtokenlist ( q , 0 , 1000 , 0 ) ;
}
void zscantextarg ( ldelim , rdelim )
halfword ldelim ;
halfword rdelim ;
{/* 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 zmacrocall ( defref , arglist , macroname )
halfword defref ;
halfword arglist ;
halfword macroname ;
{/* 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 ( 706 ) ;
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 >= 2372 ) {
if ( curcmd != 81 )
{
getxnext () ;
if ( curcmd != 33 )
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 750 ) ;
}
printmacroname ( arglist , macroname ) ;
{
helpptr = 3 ;
helpline [ 2 ] = 751 ;
helpline [ 1 ] = 752 ;
helpline [ 0 ] = 753 ;
}
if ( mem [ r ] .hhfield .lhfield >= 2522 )
{
curexp = 0 ;
curtype = 20 ;
}
else {
curexp = 0 ;
curtype = 16 ;
}
backerror () ;
curcmd = 64 ;
goto lab40 ;
}
ldelim = cursym ;
rdelim = curmod ;
}
if ( mem [ r ] .hhfield .lhfield >= 2672 )
scantextarg ( ldelim , rdelim ) ;
else {
getxnext () ;
if ( mem [ r ] .hhfield .lhfield >= 2522 )
scansuffix () ;
else scanexpression () ;
}
if ( curcmd != 81 )
if ( ( curcmd != 64 ) || ( curmod != ldelim ) )
if ( mem [ mem [ r ] .hhfield .v.RH ] .hhfield .lhfield >= 2372 )
{
missingerr ( 44 ) ;
{
helpptr = 3 ;
helpline [ 2 ] = 754 ;
helpline [ 1 ] = 755 ;
helpline [ 0 ] = 749 ;
}
backerror () ;
curcmd = 81 ;
}
else {
missingerr ( hash [ rdelim ] .v.RH ) ;
{
helpptr = 2 ;
helpline [ 1 ] = 756 ;
helpline [ 0 ] = 749 ;
}
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 ( 263 ) ;
print ( 745 ) ;
}
printmacroname ( arglist , macroname ) ;
printchar ( 59 ) ;
printnl ( 746 ) ;
print ( hash [ rdelim ] .v.RH ) ;
print ( 300 ) ;
{
helpptr = 3 ;
helpline [ 2 ] = 747 ;
helpline [ 1 ] = 748 ;
helpline [ 0 ] = 749 ;
}
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 ( 757 ) ;
printmacroname ( arglist , macroname ) ;
{
helpptr = 1 ;
helpline [ 0 ] = 758 ;
}
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 ] = 756 ;
helpline [ 0 ] = 749 ;
}
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 ( 728 , 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 expand ( )
{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 = 2362 ;
inserror () ;
}
else {
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 765 ) ;
}
printcmdmod ( 5 , curmod ) ;
{
helpptr = 1 ;
helpline [ 0 ] = 766 ;
}
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 ( 263 ) ;
print ( 729 ) ;
}
{
helpptr = 2 ;
helpline [ 1 ] = 730 ;
helpline [ 0 ] = 731 ;
}
error () ;
}
else beginiteration () ;
break ;
case 8 :
{
while ( ( curinput .indexfield > 15 ) && ( curinput .locfield == 0 ) )
endtokenlist () ;
if ( loopptr == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 733 ) ;
}
{
helpptr = 2 ;
helpline [ 1 ] = 734 ;
helpline [ 0 ] = 735 ;
}
error () ;
}
else resumeiteration () ;
}
break ;
case 9 :
{
getboolean () ;
if ( internal [ 6 ] > 65536L )
showcmdmod ( 35 , curexp ) ;
if ( curexp == 30 )
if ( loopptr == 0 )
{
{
if ( interaction == 3 )
;
printnl ( 263 ) ;
print ( 736 ) ;
}
{
helpptr = 1 ;
helpline [ 0 ] = 737 ;
}
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 ( 740 ) ;
stopiteration () ;
}
else if ( curcmd != 82 )
{
missingerr ( 59 ) ;
{
helpptr = 2 ;
helpline [ 1 ] = 738 ;
helpline [ 0 ] = 739 ;
}
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 , 741 ) ;
{
helpptr = 2 ;
helpline [ 1 ] = 742 ;
helpline [ 0 ] = 743 ;
}
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 getxnext ( )
{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 zstackargument ( p )
halfword p ;
{if ( paramptr == maxparamstack )
{
incr ( maxparamstack ) ;
if ( maxparamstack > 150 )
overflow ( 728 , 150 ) ;
}
paramstack [ paramptr ] = p ;
incr ( paramptr ) ;
}
void passtext ( )
{/* 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 zchangeiflimit ( l , p )
smallnumber l ;
halfword p ;
{/* 10 */ halfword q ;
if ( p == condptr )
iflimit = l ;
else {
q = condptr ;
while ( true ) {
if ( q == 0 )
confusion ( 759 ) ;
if ( mem [ q ] .hhfield .v.RH == p )
{
mem [ q ] .hhfield .b0 = l ;
goto lab10 ;
}
q = mem [ q ] .hhfield .v.RH ;
}
}
lab10: ;
}
void checkcolon ( )
{if ( curcmd != 80 )
{
missingerr ( 58 ) ;
{
helpptr = 2 ;
helpline [ 1 ] = 762 ;
helpline [ 0 ] = 739 ;
}
backerror () ;
}
}
void conditional ( )
{/* 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 ( 763 ) ;
else print ( 764 ) ;
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 zbadfor ( s )
strnumber s ;
{disperr ( 0 , 767 ) ;
print ( s ) ;
print ( 307 ) ;
{
helpptr = 4 ;
helpline [ 3 ] = 768 ;
helpline [ 2 ] = 769 ;
helpline [ 1 ] = 770 ;
helpline [ 0 ] = 309 ;
}
putgetflusherror ( 0 ) ;
}
void beginiteration ( )
{/* 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 , 783 ) ;
{
helpptr = 1 ;
helpline [ 0 ] = 784 ;
}
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 ] = 771 ;
helpline [ 1 ] = 714 ;
helpline [ 0 ] = 772 ;
}
backerror () ;
}
mem [ s + 1 ] .hhfield .lhfield = 0 ;
q = s + 1 ;
mem [ q ] .hhfield .v.RH = 0 ;
do {
getxnext () ;
if ( m != 2372 )
scansuffix () ;
else {
if ( curcmd >= 80 )
if ( curcmd <= 81 )
goto lab22 ;
scanexpression () ;
if ( curcmd == 72 )
if ( q == s + 1 )
{
if ( curtype != 16 )
badfor ( 778 ) ;
pp = getnode ( 4 ) ;
mem [ pp + 1 ] .cint = curexp ;
getxnext () ;
scanexpression () ;
if ( curtype != 16 )
badfor ( 779 ) ;
mem [ pp + 2 ] .cint = curexp ;
if ( curcmd != 73 )
{
missingerr ( 500 ) ;
{
helpptr = 2 ;
helpline [ 1 ] = 780 ;
helpline [ 0 ] = 781 ;
}
backerror () ;
}
getxnext () ;
scanexpression () ;
if ( curtype != 16 )
badfor ( 782 ) ;
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 ] = 773 ;
helpline [ 1 ] = 774 ;
helpline [ 0 ] = 775 ;
}
backerror () ;
}
q = getavail () ;
mem [ q ] .hhfield .lhfield = 2358 ;
scannerstatus = 6 ;
warninginfo = n ;
mem [ s ] .hhfield .lhfield = scantoks ( 7 , p , q , 0 ) ;
scannerstatus = 0 ;
mem [ s ] .hhfield .v.RH = loopptr ;
loopptr = s ;
resumeiteration () ;
}