#define EXTERN extern
#include "mpd.h"
#ifdef INIMP
boolean
#ifdef HAVE_PROTOTYPES
getstringsstarted ( void )
#else
getstringsstarted ( )
#endif
{
/* 30 10 */ register boolean Result; unsigned char k, l ;
ASCIIcode m, n ;
strnumber g ;
integer a ;
boolean c ;
poolptr = 0 ;
strptr = 0 ;
maxpoolptr = 0 ;
maxstrptr = 0 ;
strstart [0 ]= 0 ;
nextstr [0 ]= 1 ;
stroverflowed = false ;
;
#ifdef STAT
poolinuse = 0 ;
strsinuse = 0 ;
maxplused = 0 ;
maxstrsused = 0 ;
pactcount = 0 ;
pactchars = 0 ;
pactstrs = 0 ;
#endif /* STAT */
strsusedup = 0 ;
{register integer for_end; k = 0 ;for_end = 255 ; if ( k <= for_end) do
{
{
strpool [poolptr ]= k ;
incr ( poolptr ) ;
}
g = makestring () ;
strref [g ]= 127 ;
}
while ( k++ < for_end ) ;}
namelength = strlen ( poolname ) ;
nameoffile = xmalloc ( 1 + namelength + 1 ) ;
strcpy ( (char*) nameoffile + 1 , poolname ) ;
if ( aopenin ( poolfile , kpsemppoolformat ) )
{
c = false ;
do {
{
if ( eof ( poolfile ) )
{
;
fprintf( stdout , "%s\n", "! mp.pool has no check sum." ) ;
aclose ( poolfile ) ;
Result = false ;
goto lab10 ;
}
read ( poolfile , m ) ;
read ( poolfile , n ) ;
if ( m == '*' )
{
a = 0 ;
k = 1 ;
while ( true ) {
if ( ( xord [n ]< 48 ) || ( xord [n ]> 57 ) )
{
;
fprintf( stdout , "%s\n", "! mp.pool check sum doesn't have nine digits." ) ;
aclose ( poolfile ) ;
Result = false ;
goto lab10 ;
}
a = 10 * a + xord [n ]- 48 ;
if ( k == 9 )
goto lab30 ;
incr ( k ) ;
read ( poolfile , n ) ;
}
lab30: if ( a != 136687108L )
{
;
fprintf( stdout , "%s\n", "! mp.pool doesn't match; tangle me again (or fix the path)." ) ;
aclose ( poolfile ) ;
Result = false ;
goto lab10 ;
}
c = true ;
}
else {
if ( ( xord [m ]< 48 ) || ( xord [m ]> 57 ) || ( xord [n ]< 48
) || ( xord [n ]> 57 ) )
{
;
fprintf( stdout , "%s\n", "! mp.pool line doesn't begin with two digits." ) ;
aclose ( poolfile ) ;
Result = false ;
goto lab10 ;
}
l = xord [m ]* 10 + xord [n ]- 48 * 11 ;
if ( poolptr + l + stringvacancies > poolsize )
{
;
fprintf( stdout , "%s\n", "! You have to increase POOLSIZE." ) ;
aclose ( poolfile ) ;
Result = false ;
goto lab10 ;
}
if ( strptr + stringsvacant >= maxstrings )
{
;
fprintf( stdout , "%s\n", "! You have to increase MAXSTRINGS." ) ;
aclose ( poolfile ) ;
Result = false ;
goto lab10 ;
}
{register integer for_end; k = 1 ;for_end = l ; if ( k <= for_end)
do
{
if ( eoln ( poolfile ) )
m = ' ' ;
else read ( poolfile , m ) ;
{
strpool [poolptr ]= xord [m ];
incr ( poolptr ) ;
}
}
while ( k++ < for_end ) ;}
readln ( poolfile ) ;
g = makestring () ;
strref [g ]= 127 ;
}
}
} while ( ! ( c ) ) ;
aclose ( poolfile ) ;
Result = true ;
}
else {
;
fprintf( stdout , "%s\n", "! I can't read mp.pool; bad path?" ) ;
aclose ( poolfile ) ;
Result = false ;
goto lab10 ;
}
lastfixedstr = strptr - 1 ;
fixedstruse = strptr ;
lab10: ;
return Result ;
}
#endif /* INIMP */
#ifdef INIMP
void
#ifdef HAVE_PROTOTYPES
sortavail ( void )
#else
sortavail ( )
#endif
{
halfword p, q, r ;
halfword oldrover ;
p = getnode ( 1073741824L ) ;
p = mem [rover + 1 ].hhfield .v.RH ;
mem [rover + 1 ].hhfield .v.RH = 268435455L ;
oldrover = rover ;
while ( p != oldrover ) if ( p < rover )
{
q = p ;
p = mem [q + 1 ].hhfield .v.RH ;
mem [q + 1 ].hhfield .v.RH = rover ;
rover = q ;
}
else {
q = rover ;
while ( mem [q + 1 ].hhfield .v.RH < p ) q = mem [q + 1 ].hhfield
.v.RH ;
r = mem [p + 1 ].hhfield .v.RH ;
mem [p + 1 ].hhfield .v.RH = mem [q + 1 ].hhfield .v.RH ;
mem [q + 1 ].hhfield .v.RH = p ;
p = r ;
}
p = rover ;
while ( mem [p + 1 ].hhfield .v.RH != 268435455L ) {
mem [mem [p + 1 ].hhfield .v.RH + 1 ].hhfield .lhfield = p ;
p = mem [p + 1 ].hhfield .v.RH ;
}
mem [p + 1 ].hhfield .v.RH = rover ;
mem [rover + 1 ].hhfield .lhfield = p ;
}
#endif /* INIMP */
#ifdef INIMP
void
#ifdef HAVE_PROTOTYPES
zprimitive ( strnumber s , halfword c , halfword o )
#else
zprimitive ( s , c , o )
strnumber s ;
halfword c ;
halfword o ;
#endif
{
poolpointer k ;
smallnumber j ;
smallnumber l ;
k = strstart [s ];
l = strstart [nextstr [s ]]- k ;
{register integer for_end; j = 0 ;for_end = l - 1 ; if ( j <= for_end) do
buffer [j ]= strpool [k + j ];
while ( j++ < for_end ) ;}
cursym = idlookup ( 0 , l ) ;
if ( s >= 256 )
{
flushstring ( hash [cursym ].v.RH ) ;
hash [cursym ].v.RH = s ;
}
eqtb [cursym ].lhfield = c ;
eqtb [cursym ].v.RH = o ;
}
#endif /* INIMP */
void
#ifdef HAVE_PROTOTYPES
startinput ( void )
#else
startinput ( )
#endif
{
/* 30 */ integer j ;
while ( ( curinput .indexfield > 15 ) && ( curinput .locfield == 0 ) )
endtokenlist () ;
if ( ( curinput .indexfield > 15 ) )
{
{
if ( interaction == 3 )
;
printnl ( 262 ) ;
print ( 799 ) ;
}
{
helpptr = 3 ;
helpline [2 ]= 800 ;
helpline [1 ]= 801 ;
helpline [0 ]= 802 ;
}
error () ;
}
if ( ( curinput .indexfield <= 15 ) )
scanfilename () ;
else {
curname = 284 ;
curext = 284 ;
curarea = 284 ;
}
while ( true ) {
beginfilereading () ;
if ( tryextension ( 798 ) )
goto lab30 ;
else if ( tryextension ( 797 ) )
goto lab30 ;
else ;
endfilereading () ;
promptfilename ( 785 , 284 ) ;
}
lab30: curinput .namefield = amakenamestring ( inputfile [curinput
.indexfield ]) ;
if ( inamestack [curinput .indexfield ]== curname )
{
if ( strref [curname ]< 127 )
incr ( strref [curname ]) ;
}
if ( iareastack [curinput .indexfield ]== curarea )
{
if ( strref [curarea ]< 127 )
incr ( strref [curarea ]) ;
}
if ( jobname == 0 )
{
j = 1 ;
beginname () ;
while ( ( j <= namelength ) && ( morename ( (char*) nameoffile [j ]) ) ) incr (
j ) ;
endname () ;
jobname = curname ;
strref [jobname ]= 127 ;
;
#ifdef INIMP
if ( iniversion && dumpoption )
{
{
if ( poolptr + memdefaultlength > maxpoolptr )
if ( poolptr + memdefaultlength > poolsize )
docompaction ( memdefaultlength ) ;
else maxpoolptr = poolptr + memdefaultlength ;
}
{register integer for_end; j = 1 ;for_end = memdefaultlength - 4
; if ( j <= for_end) do
{
strpool [poolptr ]= xord [MPmemdefault [j ]];
incr ( poolptr ) ;
}
while ( j++ < for_end ) ;}
jobname = makestring () ;
strref [jobname ]= 127 ;
}
#endif /* INIMP */
openlogfile () ;
}
if ( termoffset + ( strstart [nextstr [curinput .namefield ]]- strstart
[curinput .namefield ]) > maxprintline - 2 )
println () ;
else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) )
printchar ( 32 ) ;
printchar ( 40 ) ;
incr ( openparens ) ;
print ( curinput .namefield ) ;
fflush ( stdout ) ;
{
linestack [curinput .indexfield ]= 1 ;
if ( inputln ( inputfile [curinput .indexfield ], false ) )
;
firmuptheline () ;
buffer [curinput .limitfield ]= 37 ;
first = curinput .limitfield + 1 ;
curinput .locfield = curinput .startfield ;
}
}
#ifdef INIMP
void
#ifdef HAVE_PROTOTYPES
storememfile ( void )
#else
storememfile ( )
#endif
{
/* 30 */ integer k ;
halfword p, q ;
integer x ;
fourquarters w ;
strnumber s ;
selector = 4 ;
print ( 1178 ) ;
print ( jobname ) ;
printchar ( 32 ) ;
printint ( roundunscaled ( internal [13 ]) ) ;
printchar ( 46 ) ;
printint ( roundunscaled ( internal [14 ]) ) ;
printchar ( 46 ) ;
printint ( roundunscaled ( internal [15 ]) ) ;
printchar ( 41 ) ;
if ( interaction == 0 )
selector = 9 ;
else selector = 10 ;
{
if ( poolptr + 1 > maxpoolptr )
if ( poolptr + 1 > poolsize )
docompaction ( 1 ) ;
else maxpoolptr = poolptr + 1 ;
}
memident = makestring () ;
strref [memident ]= 127 ;
packjobname ( 784 ) ;
while ( ! wopenout ( memfile ) ) promptfilename ( 1179 , 784 ) ;
printnl ( 1180 ) ;
s = wmakenamestring ( memfile ) ;
print ( s ) ;
flushstring ( s ) ;
printnl ( memident ) ;
dumpint ( 136687108L ) ;
dumpint ( 0 ) ;
dumpint ( memtop ) ;
dumpint ( 9500 ) ;
dumpint ( 7919 ) ;
dumpint ( 15 ) ;
docompaction ( poolsize ) ;
dumpint ( poolptr ) ;
dumpint ( maxstrptr ) ;
dumpint ( strptr ) ;
k = 0 ;
while ( ( nextstr [k ]== k + 1 ) && ( k <= maxstrptr ) ) incr ( k ) ;
dumpint ( k ) ;
while ( k <= maxstrptr ) {
dumpint ( nextstr [k ]) ;
incr ( k ) ;
}
k = 0 ;
while ( true ) {
dumpint ( strstart [k ]) ;
if ( k == strptr )
goto lab30 ;
else k = nextstr [k ];
}
lab30: k = 0 ;
while ( k + 4 < poolptr ) {
w .b0 = strpool [k ];
w .b1 = strpool [k + 1 ];
w .b2 = strpool [k + 2 ];
w .b3 = strpool [k + 3 ];
dumpqqqq ( w ) ;
k = k + 4 ;
}
k = poolptr - 4 ;
w .b0 = strpool [k ];
w .b1 = strpool [k + 1 ];
w .b2 = strpool [k + 2 ];
w .b3 = strpool [k + 3 ];
dumpqqqq ( w ) ;
println () ;
print ( 1174 ) ;
printint ( maxstrptr ) ;
print ( 1175 ) ;
printint ( poolptr ) ;
sortavail () ;
varused = 0 ;
dumpint ( lomemmax ) ;
dumpint ( rover ) ;
p = 0 ;
q = rover ;
x = 0 ;
do {
{ register integer for_end; k = p ;for_end = q + 1 ; if ( k <=
for_end) do
dumpwd ( mem [k ]) ;
while ( k++ < for_end ) ;}
x = x + q + 2 - p ;
varused = varused + q - p ;
p = q + mem [q ].hhfield .lhfield ;
q = mem [q + 1 ].hhfield .v.RH ;
} while ( ! ( q == rover ) ) ;
varused = varused + lomemmax - p ;
dynused = memend + 1 - himemmin ;
{register integer for_end; k = p ;for_end = lomemmax ; if ( k <= for_end)
do
dumpwd ( mem [k ]) ;
while ( k++ < for_end ) ;}
x = x + lomemmax + 1 - p ;
dumpint ( himemmin ) ;
dumpint ( avail ) ;
{register integer for_end; k = himemmin ;for_end = memend ; if ( k <=
for_end) do
dumpwd ( mem [k ]) ;
while ( k++ < for_end ) ;}
x = x + memend + 1 - himemmin ;
p = avail ;
while ( p != 0 ) {
decr ( dynused ) ;
p = mem [p ].hhfield .v.RH ;
}
dumpint ( varused ) ;
dumpint ( dynused ) ;
println () ;
printint ( x ) ;
print ( 1176 ) ;
printint ( varused ) ;
printchar ( 38 ) ;
printint ( dynused ) ;
dumpint ( hashused ) ;
stcount = 9756 - hashused ;
{register integer for_end; p = 1 ;for_end = hashused ; if ( p <= for_end)
do
if ( hash [p ].v.RH != 0 )
{
dumpint ( p ) ;
dumphh ( hash [p ]) ;
dumphh ( eqtb [p ]) ;
incr ( stcount ) ;
}
while ( p++ < for_end ) ;}
{register integer for_end; p = hashused + 1 ;for_end = 9771 ; if ( p <=
for_end) do
{
dumphh ( hash [p ]) ;
dumphh ( eqtb [p ]) ;
}
while ( p++ < for_end ) ;}
dumpint ( stcount ) ;
println () ;
printint ( stcount ) ;
print ( 1177 ) ;
dumpint ( intptr ) ;
{register integer for_end; k = 1 ;for_end = intptr ; if ( k <= for_end) do
{
dumpint ( internal [k ]) ;
dumpint ( intname [k ]) ;
}
while ( k++ < for_end ) ;}
dumpint ( startsym ) ;
dumpint ( interaction ) ;
dumpint ( memident ) ;
dumpint ( bgloc ) ;
dumpint ( egloc ) ;
dumpint ( serialno ) ;
dumpint ( 69073L ) ;
internal [10 ]= 0 ;
wclose ( memfile ) ;
}
#endif /* INIMP */
boolean
#ifdef HAVE_PROTOTYPES
loadmemfile ( void )
#else
loadmemfile ( )
#endif
{
/* 30 6666 10 */ register boolean Result; integer k ;
halfword p, q ;
integer x ;
strnumber s ;
fourquarters w ;
undumpint ( x ) ;
if ( x != 136687108L )
goto lab6666 ;
undumpint ( x ) ;
if ( x != 0 )
goto lab6666 ;
;
#ifdef INIMP
if ( iniversion )
{
libcfree ( mem ) ;
libcfree ( strref ) ;
libcfree ( nextstr ) ;
libcfree ( strstart ) ;
libcfree ( strpool ) ;
}
#endif /* INIMP */
undumpint ( memtop ) ;
if ( memmax < memtop )
memmax = memtop ;
if ( 1100 > memtop )
goto lab6666 ;
xmallocarray ( mem , memmax - 0 ) ;
undumpint ( x ) ;
if ( x != 9500 )
goto lab6666 ;
undumpint ( x ) ;
if ( x != 7919 )
goto lab6666 ;
undumpint ( x ) ;
if ( x != 15 )
goto lab6666 ;
{
undumpint ( x ) ;
if ( x < 0 )
goto lab6666 ;
if ( x > suppoolsize - poolfree )
{
;
fprintf( stdout , "%s%s\n", "---! Must increase the " , "string pool size" ) ;
goto lab6666 ;
}
else poolptr = x ;
}
if ( poolsize < poolptr + poolfree )
poolsize = poolptr + poolfree ;
{
undumpint ( x ) ;
if ( x < 0 )
goto lab6666 ;
if ( x > supmaxstrings )
{
;
fprintf( stdout , "%s%s\n", "---! Must increase the " , "max strings" ) ;
goto lab6666 ;
}
else maxstrptr = x ;
}
xmallocarray ( strref , maxstrings ) ;
xmallocarray ( nextstr , maxstrings ) ;
xmallocarray ( strstart , maxstrings ) ;
xmallocarray ( strpool , poolsize ) ;
{
undumpint ( x ) ;
if ( ( x < 0 ) || ( x > maxstrptr ) )
goto lab6666 ;
else strptr = x ;
}
{
undumpint ( x ) ;
if ( ( x < 0 ) || ( x > maxstrptr + 1 ) )
goto lab6666 ;
else s = x ;
}
{register integer for_end; k = 0 ;for_end = s - 1 ; if ( k <= for_end) do
nextstr [k ]= k + 1 ;
while ( k++ < for_end ) ;}
{register integer for_end; k = s ;for_end = maxstrptr ; if ( k <= for_end)
do
{
undumpint ( x ) ;
if ( ( x < s + 1 ) || ( x > maxstrptr + 1 ) )
goto lab6666 ;
else nextstr [k ]= x ;
}
while ( k++ < for_end ) ;}
fixedstruse = 0 ;
k = 0 ;
while ( true ) {
{
undumpint ( x ) ;
if ( ( x < 0 ) || ( x > poolptr ) )
goto lab6666 ;
else strstart [k ]= x ;
}
if ( k == strptr )
goto lab30 ;
strref [k ]= 127 ;
incr ( fixedstruse ) ;
lastfixedstr = k ;
k = nextstr [k ];
}
lab30: k = 0 ;
while ( k + 4 < poolptr ) {
undumpqqqq ( w ) ;
strpool [k ]= w .b0 ;
strpool [k + 1 ]= w .b1 ;
strpool [k + 2 ]= w .b2 ;
strpool [k + 3 ]= w .b3 ;
k = k + 4 ;
}
k = poolptr - 4 ;
undumpqqqq ( w ) ;
strpool [k ]= w .b0 ;
strpool [k + 1 ]= w .b1 ;
strpool [k + 2 ]= w .b2 ;
strpool [k + 3 ]= w .b3 ;
initstruse = fixedstruse ;
initpoolptr = poolptr ;
maxpoolptr = poolptr ;
strsusedup = fixedstruse ;
;
#ifdef STAT
poolinuse = strstart [strptr ];
strsinuse = fixedstruse ;
maxplused = poolinuse ;
maxstrsused = strsinuse ;
pactcount = 0 ;
pactchars = 0 ;
pactstrs = 0 ;
#endif /* STAT */
{
undumpint ( x ) ;
if ( ( x < 1023 ) || ( x > memtop - 4 ) )
goto lab6666 ;
else lomemmax = x ;
}
{
undumpint ( x ) ;
if ( ( x < 24 ) || ( x > lomemmax ) )
goto lab6666 ;
else rover = x ;
}
p = 0 ;
q = rover ;
do {
{ register integer for_end; k = p ;for_end = q + 1 ; if ( k <=
for_end) do
undumpwd ( mem [k ]) ;
while ( k++ < for_end ) ;}
p = q + mem [q ].hhfield .lhfield ;
if ( ( p > lomemmax ) || ( ( q >= mem [q + 1 ].hhfield .v.RH ) && ( mem
[q + 1 ].hhfield .v.RH != rover ) ) )
goto lab6666 ;
q = mem [q + 1 ].hhfield .v.RH ;
} while ( ! ( q == rover ) ) ;
{register integer for_end; k = p ;for_end = lomemmax ; if ( k <= for_end)
do
undumpwd ( mem [k ]) ;
while ( k++ < for_end ) ;}
{
undumpint ( x ) ;
if ( ( x < lomemmax + 1 ) || ( x > memtop - 3 ) )
goto lab6666 ;
else himemmin = x ;
}
{
undumpint ( x ) ;
if ( ( x < 0 ) || ( x > memtop ) )
goto lab6666 ;
else avail = x ;
}
memend = memtop ;
{register integer for_end; k = himemmin ;for_end = memend ; if ( k <=
for_end) do
undumpwd ( mem [k ]) ;
while ( k++ < for_end ) ;}
undumpint ( varused ) ;
undumpint ( dynused ) ;
{
undumpint ( x ) ;
if ( ( x < 1 ) || ( x > 9757 ) )
goto lab6666 ;
else hashused = x ;
}
p = 0 ;
do {
{
undumpint ( x ) ;
if ( ( x < p + 1 ) || ( x > hashused ) )
goto lab6666 ;
else p = x ;
}
undumphh ( hash [p ]) ;
undumphh ( eqtb [p ]) ;
} while ( ! ( p == hashused ) ) ;
{register integer for_end; p = hashused + 1 ;for_end = 9771 ; if ( p <=
for_end) do
{
undumphh ( hash [p ]) ;
undumphh ( eqtb [p ]) ;
}
while ( p++ < for_end ) ;}
undumpint ( stcount ) ;
{
undumpint ( x ) ;
if ( ( x < 33 ) || ( x > maxinternal ) )
goto lab6666 ;
else intptr = x ;
}
{register integer for_end; k = 1 ;for_end = intptr ; if ( k <= for_end) do
{
undumpint ( internal [k ]) ;
{
undumpint ( x ) ;
if ( ( x < 0 ) || ( x > strptr ) )
goto lab6666 ;
else intname [k ]= x ;
}
}
while ( k++ < for_end ) ;}
{
undumpint ( x ) ;
if ( ( x < 0 ) || ( x > 9757 ) )
goto lab6666 ;
else startsym = x ;
}
{
undumpint ( x ) ;
if ( ( x < 0 ) || ( x > 3 ) )
goto lab6666 ;
else interaction = x ;
}
if ( interactionoption != 4 )
interaction = interactionoption ;
{
undumpint ( x ) ;
if ( ( x < 0 ) || ( x > strptr ) )
goto lab6666 ;
else memident = x ;
}
{
undumpint ( x ) ;
if ( ( x < 1 ) || ( x > 9771 ) )
goto lab6666 ;
else bgloc = x ;
}
{
undumpint ( x ) ;
if ( ( x < 1 ) || ( x > 9771 ) )
goto lab6666 ;
else egloc = x ;
}
undumpint ( serialno ) ;
undumpint ( x ) ;
if ( ( x != 69073L ) || feof ( memfile ) )
goto lab6666 ;
Result = true ;
goto lab10 ;
lab6666: ;
fprintf( stdout , "%s\n", "(Fatal mem file error; I'm stymied)" ) ;
Result = false ;
lab10: ;
return Result ;
}
void
#ifdef HAVE_PROTOTYPES
finalcleanup ( void )
#else
finalcleanup ( )
#endif
{
/* 10 */ smallnumber c ;
c = curmod ;
if ( jobname == 0 )
openlogfile () ;
while ( inputptr > 0 ) if ( ( curinput .indexfield > 15 ) )
endtokenlist () ;
else endfilereading () ;
while ( loopptr != 0 ) stopiteration () ;
while ( openparens > 0 ) {
print ( 1182 ) ;
decr ( openparens ) ;
}
while ( condptr != 0 ) {
printnl ( 1183 ) ;
printcmdmod ( 5 , curif ) ;
if ( ifline != 0 )
{
print ( 1184 ) ;
printint ( ifline ) ;
}
print ( 1185 ) ;
ifline = mem [condptr + 1 ].cint ;
curif = mem [condptr ].hhfield .b1 ;
condptr = mem [condptr ].hhfield .v.RH ;
}
if ( history != 0 )
if ( ( ( history == 1 ) || ( interaction < 3 ) ) )
if ( selector == 10 )
{
selector = 8 ;
printnl ( 1186 ) ;
selector = 10 ;
}
if ( c == 1 )
{
;
#ifdef INIMP
if ( iniversion )
{
storememfile () ;
goto lab10 ;
}
#endif /* INIMP */
printnl ( 1187 ) ;
goto lab10 ;
}
lab10: ;
}
#ifdef INIMP
void
#ifdef HAVE_PROTOTYPES
initprim ( void )
#else
initprim ( )
#endif
{
primitive ( 430 , 42 , 1 ) ;
primitive ( 431 , 42 , 2 ) ;
primitive ( 432 , 42 , 3 ) ;
primitive ( 433 , 42 , 4 ) ;
primitive ( 434 , 42 , 5 ) ;
primitive ( 435 , 42 , 6 ) ;
primitive ( 436 , 42 , 7 ) ;
primitive ( 437 , 42 , 8 ) ;
primitive ( 438 , 42 , 9 ) ;
primitive ( 439 , 42 , 10 ) ;
primitive ( 440 , 42 , 11 ) ;
primitive ( 441 , 42 , 12 ) ;
primitive ( 442 , 42 , 13 ) ;
primitive ( 443 , 42 , 14 ) ;
primitive ( 444 , 42 , 15 ) ;
primitive ( 445 , 42 , 16 ) ;
primitive ( 446 , 42 , 17 ) ;
primitive ( 447 , 42 , 18 ) ;
primitive ( 448 , 42 , 19 ) ;
primitive ( 449 , 42 , 20 ) ;
primitive ( 450 , 42 , 21 ) ;
primitive ( 451 , 42 , 22 ) ;
primitive ( 452 , 42 , 23 ) ;
primitive ( 453 , 42 , 24 ) ;
primitive ( 454 , 42 , 25 ) ;
primitive ( 455 , 42 , 26 ) ;
primitive ( 456 , 42 , 27 ) ;
primitive ( 457 , 42 , 28 ) ;
primitive ( 458 , 42 , 29 ) ;
primitive ( 459 , 42 , 30 ) ;
primitive ( 460 , 42 , 31 ) ;
primitive ( 461 , 42 , 32 ) ;
primitive ( 462 , 42 , 33 ) ;
primitive ( 321 , 49 , 0 ) ;
primitive ( 91 , 65 , 0 ) ;
eqtb [9760 ]= eqtb [cursym ];
primitive ( 93 , 66 , 0 ) ;
primitive ( 125 , 67 , 0 ) ;
primitive ( 123 , 48 , 0 ) ;
primitive ( 58 , 80 , 0 ) ;
eqtb [9762 ]= eqtb [cursym ];
primitive ( 474 , 79 , 0 ) ;
primitive ( 475 , 78 , 0 ) ;
primitive ( 476 , 76 , 0 ) ;
primitive ( 44 , 81 , 0 ) ;
primitive ( 59 , 82 , 0 ) ;
eqtb [9763 ]= eqtb [cursym ];
primitive ( 92 , 10 , 0 ) ;
primitive ( 477 , 20 , 0 ) ;
primitive ( 478 , 61 , 0 ) ;
primitive ( 479 , 34 , 0 ) ;
bgloc = cursym ;
primitive ( 480 , 59 , 0 ) ;
primitive ( 481 , 62 , 0 ) ;
primitive ( 482 , 29 , 0 ) ;
primitive ( 468 , 83 , 0 ) ;
eqtb [9767 ]= eqtb [cursym ];
egloc = cursym ;
primitive ( 483 , 28 , 0 ) ;
primitive ( 484 , 9 , 0 ) ;
primitive ( 485 , 12 , 0 ) ;
primitive ( 486 , 15 , 0 ) ;
primitive ( 487 , 16 , 0 ) ;
primitive ( 488 , 17 , 0 ) ;
primitive ( 489 , 70 , 0 ) ;
primitive ( 490 , 26 , 0 ) ;
primitive ( 491 , 14 , 0 ) ;
primitive ( 492 , 11 , 0 ) ;
primitive ( 493 , 19 , 0 ) ;
primitive ( 494 , 77 , 0 ) ;
primitive ( 495 , 30 , 0 ) ;
primitive ( 496 , 72 , 0 ) ;
primitive ( 497 , 37 , 0 ) ;
primitive ( 498 , 60 , 0 ) ;
primitive ( 499 , 71 , 0 ) ;
primitive ( 500 , 73 , 0 ) ;
primitive ( 501 , 74 , 0 ) ;
primitive ( 502 , 31 , 0 ) ;
primitive ( 681 , 1 , 0 ) ;
primitive ( 682 , 1 , 1 ) ;
primitive ( 465 , 2 , 0 ) ;
eqtb [9768 ]= eqtb [cursym ];
primitive ( 466 , 3 , 0 ) ;
eqtb [9769 ]= eqtb [cursym ];
primitive ( 695 , 18 , 1 ) ;
primitive ( 696 , 18 , 2 ) ;
primitive ( 697 , 18 , 55 ) ;
primitive ( 698 , 18 , 46 ) ;
primitive ( 699 , 18 , 51 ) ;
primitive ( 469 , 18 , 0 ) ;
eqtb [9765 ]= eqtb [cursym ];
primitive ( 700 , 7 , 9772 ) ;
primitive ( 701 , 7 , 9922 ) ;
primitive ( 702 , 7 , 1 ) ;
primitive ( 470 , 7 , 0 ) ;
eqtb [9764 ]= eqtb [cursym ];
primitive ( 703 , 63 , 0 ) ;
primitive ( 704 , 63 , 1 ) ;
primitive ( 64 , 63 , 2 ) ;
primitive ( 705 , 63 , 3 ) ;
primitive ( 716 , 58 , 9772 ) ;
primitive ( 717 , 58 , 9922 ) ;
primitive ( 718 , 58 , 10072 ) ;
primitive ( 719 , 58 , 1 ) ;
primitive ( 720 , 58 , 2 ) ;
primitive ( 721 , 58 , 3 ) ;
primitive ( 731 , 6 , 0 ) ;
primitive ( 628 , 6 , 1 ) ;
primitive ( 758 , 4 , 1 ) ;
primitive ( 467 , 5 , 2 ) ;
eqtb [9766 ]= eqtb [cursym ];
primitive ( 759 , 5 , 3 ) ;
primitive ( 760 , 5 , 4 ) ;
primitive ( 347 , 35 , 30 ) ;
primitive ( 348 , 35 , 31 ) ;
primitive ( 349 , 35 , 32 ) ;
primitive ( 350 , 35 , 33 ) ;
primitive ( 351 , 35 , 34 ) ;
primitive ( 352 , 35 , 35 ) ;
primitive ( 353 , 35 , 36 ) ;
primitive ( 354 , 35 , 37 ) ;
primitive ( 355 , 36 , 38 ) ;
primitive ( 356 , 36 , 39 ) ;
primitive ( 357 , 36 , 40 ) ;
primitive ( 358 , 36 , 41 ) ;
primitive ( 359 , 36 , 42 ) ;
primitive ( 360 , 36 , 43 ) ;
primitive ( 361 , 36 , 44 ) ;
primitive ( 362 , 36 , 45 ) ;
primitive ( 363 , 36 , 46 ) ;
primitive ( 364 , 36 , 47 ) ;
primitive ( 365 , 36 , 48 ) ;
primitive ( 366 , 36 , 49 ) ;
primitive ( 367 , 36 , 50 ) ;
primitive ( 368 , 36 , 51 ) ;
primitive ( 369 , 36 , 52 ) ;
primitive ( 370 , 36 , 53 ) ;
primitive ( 371 , 36 , 54 ) ;
primitive ( 372 , 36 , 55 ) ;
primitive ( 373 , 36 , 56 ) ;
primitive ( 374 , 36 , 57 ) ;
primitive ( 375 , 36 , 58 ) ;
primitive ( 376 , 36 , 59 ) ;
primitive ( 377 , 36 , 60 ) ;
primitive ( 378 , 36 , 61 ) ;
primitive ( 379 , 36 , 62 ) ;
primitive ( 380 , 36 , 63 ) ;
primitive ( 381 , 36 , 64 ) ;
primitive ( 382 , 36 , 65 ) ;
primitive ( 383 , 36 , 66 ) ;
primitive ( 384 , 36 , 67 ) ;
primitive ( 385 , 36 , 68 ) ;
primitive ( 386 , 36 , 69 ) ;
primitive ( 387 , 36 , 70 ) ;
primitive ( 388 , 36 , 71 ) ;
primitive ( 389 , 36 , 72 ) ;
primitive ( 390 , 36 , 73 ) ;
primitive ( 391 , 36 , 74 ) ;
primitive ( 392 , 36 , 75 ) ;
primitive ( 393 , 36 , 76 ) ;
primitive ( 394 , 36 , 77 ) ;
primitive ( 395 , 36 , 78 ) ;
primitive ( 396 , 36 , 79 ) ;
primitive ( 397 , 36 , 80 ) ;
primitive ( 398 , 36 , 81 ) ;
primitive ( 399 , 36 , 82 ) ;
primitive ( 400 , 38 , 83 ) ;
primitive ( 402 , 36 , 85 ) ;
primitive ( 401 , 36 , 84 ) ;
primitive ( 403 , 36 , 86 ) ;
primitive ( 404 , 36 , 87 ) ;
primitive ( 405 , 36 , 88 ) ;
primitive ( 43 , 45 , 89 ) ;
primitive ( 45 , 45 , 90 ) ;
primitive ( 42 , 57 , 91 ) ;
primitive ( 47 , 56 , 92 ) ;
eqtb [9761 ]= eqtb [cursym ];
primitive ( 406 , 47 , 93 ) ;
primitive ( 310 , 47 , 94 ) ;
primitive ( 407 , 47 , 95 ) ;
primitive ( 408 , 54 , 96 ) ;
primitive ( 60 , 52 , 97 ) ;
primitive ( 409 , 52 , 98 ) ;
primitive ( 62 , 52 , 99 ) ;
primitive ( 410 , 52 , 100 ) ;
primitive ( 61 , 53 , 101 ) ;
primitive ( 411 , 52 , 102 ) ;
primitive ( 422 , 39 , 115 ) ;
primitive ( 423 , 39 , 116 ) ;
primitive ( 424 , 39 , 117 ) ;
primitive ( 425 , 39 , 118 ) ;
primitive ( 426 , 39 , 119 ) ;
primitive ( 427 , 39 , 120 ) ;
primitive ( 428 , 39 , 121 ) ;
primitive ( 429 , 39 , 122 ) ;
primitive ( 38 , 50 , 103 ) ;
primitive ( 412 , 57 , 104 ) ;
primitive ( 413 , 57 , 105 ) ;
primitive ( 414 , 57 , 106 ) ;
primitive ( 415 , 57 , 107 ) ;
primitive ( 416 , 57 , 108 ) ;
primitive ( 417 , 57 , 109 ) ;
primitive ( 418 , 57 , 110 ) ;
primitive ( 419 , 57 , 111 ) ;
primitive ( 420 , 57 , 112 ) ;
primitive ( 421 , 47 , 113 ) ;
primitive ( 340 , 32 , 15 ) ;
primitive ( 259 , 32 , 4 ) ;
primitive ( 325 , 32 , 2 ) ;
primitive ( 330 , 32 , 8 ) ;
primitive ( 328 , 32 , 6 ) ;
primitive ( 332 , 32 , 10 ) ;
primitive ( 334 , 32 , 12 ) ;
primitive ( 335 , 32 , 13 ) ;
primitive ( 336 , 32 , 14 ) ;
primitive ( 960 , 84 , 0 ) ;
primitive ( 961 , 84 , 1 ) ;
primitive ( 272 , 25 , 0 ) ;
primitive ( 273 , 25 , 1 ) ;
primitive ( 274 , 25 , 2 ) ;
primitive ( 967 , 25 , 3 ) ;
primitive ( 968 , 23 , 0 ) ;
primitive ( 969 , 23 , 1 ) ;
primitive ( 983 , 24 , 0 ) ;
primitive ( 984 , 24 , 1 ) ;
primitive ( 985 , 24 , 2 ) ;
primitive ( 986 , 24 , 3 ) ;
primitive ( 987 , 24 , 4 ) ;
primitive ( 1006 , 69 , 0 ) ;
primitive ( 1007 , 69 , 1 ) ;
primitive ( 1008 , 69 , 2 ) ;
primitive ( 1009 , 68 , 6 ) ;
primitive ( 1010 , 68 , 10 ) ;
primitive ( 1011 , 68 , 13 ) ;
primitive ( 1020 , 21 , 4 ) ;
primitive ( 1021 , 21 , 5 ) ;
primitive ( 1034 , 27 , 0 ) ;
primitive ( 1035 , 27 , 1 ) ;
primitive ( 1036 , 27 , 2 ) ;
primitive ( 1051 , 22 , 0 ) ;
primitive ( 1052 , 22 , 1 ) ;
primitive ( 1053 , 22 , 2 ) ;
primitive ( 1054 , 22 , 3 ) ;
primitive ( 1055 , 22 , 4 ) ;
primitive ( 1073 , 75 , 0 ) ;
primitive ( 1074 , 75 , 1 ) ;
primitive ( 1075 , 75 , 5 ) ;
primitive ( 1076 , 75 , 2 ) ;
primitive ( 1077 , 75 , 6 ) ;
primitive ( 1078 , 75 , 3 ) ;
primitive ( 1079 , 75 , 7 ) ;
primitive ( 1080 , 75 , 11 ) ;
primitive ( 1081 , 75 , 128 ) ;
}
void
#ifdef HAVE_PROTOTYPES
inittab ( void )
#else
inittab ( )
#endif
{
integer k ;
rover = 24 ;
mem [rover ].hhfield .v.RH = 268435455L ;
mem [rover ].hhfield .lhfield = 1000 ;
mem [rover + 1 ].hhfield .lhfield = rover ;
mem [rover + 1 ].hhfield .v.RH = rover ;
lomemmax = rover + 1000 ;
mem [lomemmax ].hhfield .v.RH = 0 ;
mem [lomemmax ].hhfield .lhfield = 0 ;
{register integer for_end; k = memtop - 3 ;for_end = memtop ; if ( k <=
for_end) do
mem [k ]= mem [lomemmax ];
while ( k++ < for_end ) ;}
avail = 0 ;
memend = memtop ;
himemmin = memtop - 3 ;
varused = 24 ;
dynused = memtop + 1 - ( memtop - 3 ) ;
mem [14 ].cint = -32768L ;
mem [15 ].cint = 0 ;
mem [17 ].cint = 32768L ;
mem [18 ].cint = 0 ;
mem [20 ].cint = 0 ;
mem [21 ].cint = 65536L ;
mem [13 ].hhfield .v.RH = 16 ;
mem [16 ].hhfield .v.RH = 19 ;
mem [19 ].hhfield .v.RH = 13 ;
mem [13 ].hhfield .lhfield = 19 ;
mem [16 ].hhfield .lhfield = 13 ;
mem [19 ].hhfield .lhfield = 16 ;
intname [1 ]= 430 ;
intname [2 ]= 431 ;
intname [3 ]= 432 ;
intname [4 ]= 433 ;
intname [5 ]= 434 ;
intname [6 ]= 435 ;
intname [7 ]= 436 ;
intname [8 ]= 437 ;
intname [9 ]= 438 ;
intname [10 ]= 439 ;
intname [11 ]= 440 ;
intname [12 ]= 441 ;
intname [13 ]= 442 ;
intname [14 ]= 443 ;
intname [15 ]= 444 ;
intname [16 ]= 445 ;
intname [17 ]= 446 ;
intname [18 ]= 447 ;
intname [19 ]= 448 ;
intname [20 ]= 449 ;
intname [21 ]= 450 ;
intname [22 ]= 451 ;
intname [23 ]= 452 ;
intname [24 ]= 453 ;
intname [25 ]= 454 ;
intname [26 ]= 455 ;
intname [27 ]= 456 ;
intname [28 ]= 457 ;
intname [29 ]= 458 ;
intname [30 ]= 459 ;
intname [31 ]= 460 ;
intname [32 ]= 461 ;
intname [33 ]= 462 ;
hashused = 9757 ;
stcount = 0 ;
hash [9770 ].v.RH = 464 ;
hash [9768 ].v.RH = 465 ;
hash [9769 ].v.RH = 466 ;
hash [9766 ].v.RH = 467 ;
hash [9767 ].v.RH = 468 ;
hash [9765 ].v.RH = 469 ;
hash [9764 ].v.RH = 470 ;
hash [9763 ].v.RH = 59 ;
hash [9762 ].v.RH = 58 ;
hash [9761 ].v.RH = 47 ;
hash [9760 ].v.RH = 91 ;
hash [9759 ].v.RH = 41 ;
hash [9757 ].v.RH = 471 ;
eqtb [9759 ].lhfield = 64 ;
mem [0 ].hhfield .v.RH = 0 ;
mem [1 ].cint = 0 ;
mem [11 ].hhfield .lhfield = 9772 ;
mem [11 ].hhfield .v.RH = 0 ;
serialno = 0 ;
mem [5 ].hhfield .v.RH = 5 ;
mem [6 ].hhfield .lhfield = 5 ;
mem [5 ].hhfield .lhfield = 0 ;
mem [6 ].hhfield .v.RH = 0 ;
mem [22 ].hhfield .b1 = 0 ;
mem [22 ].hhfield .v.RH = 9770 ;
eqtb [9770 ].v.RH = 22 ;
eqtb [9770 ].lhfield = 43 ;
eqtb [9758 ].lhfield = 93 ;
hash [9758 ].v.RH = 775 ;
mem [9 ].hhfield .b1 = 14 ;
mem [12 ].cint = 1073741824L ;
mem [8 ].cint = 0 ;
mem [7 ].hhfield .lhfield = 0 ;
fontdsize [0 ]= 0 ;
fontname [0 ]= 284 ;
fontpsname [0 ]= 284 ;
fontbc [0 ]= 1 ;
fontec [0 ]= 0 ;
charbase [0 ]= 0 ;
widthbase [0 ]= 0 ;
heightbase [0 ]= 0 ;
depthbase [0 ]= 0 ;
nextfmem = 0 ;
lastfnum = 0 ;
lastpsfnum = 0 ;
if ( iniversion )
memident = 1173 ;
}
#endif /* INIMP */
void mainbody() {
bounddefault = 250000L ;
boundname = "main_memory" ;
setupboundvariable ( addressof ( mainmemory ) , boundname , bounddefault ) ;
bounddefault = 100000L ;
boundname = "pool_size" ;
setupboundvariable ( addressof ( poolsize ) , boundname , bounddefault ) ;
bounddefault = 75000L ;
boundname = "string_vacancies" ;
setupboundvariable ( addressof ( stringvacancies ) , boundname ,
bounddefault ) ;
bounddefault = 5000 ;
boundname = "pool_free" ;
setupboundvariable ( addressof ( poolfree ) , boundname , bounddefault ) ;
bounddefault = 15000 ;
boundname = "max_strings" ;
setupboundvariable ( addressof ( maxstrings ) , boundname , bounddefault ) ;
bounddefault = 79 ;
boundname = "error_line" ;
setupboundvariable ( addressof ( errorline ) , boundname , bounddefault ) ;
bounddefault = 50 ;
boundname = "half_error_line" ;
setupboundvariable ( addressof ( halferrorline ) , boundname , bounddefault
) ;
bounddefault = 79 ;
boundname = "max_print_line" ;
setupboundvariable ( addressof ( maxprintline ) , boundname , bounddefault )
;
if ( errorline > 255 )
errorline = 255 ;
{
if ( mainmemory < infmainmemory )
mainmemory = infmainmemory ;
else if ( mainmemory > supmainmemory )
mainmemory = supmainmemory ;
}
memtop = 0 + mainmemory ;
memmax = memtop ;
{
if ( poolsize < infpoolsize )
poolsize = infpoolsize ;
else if ( poolsize > suppoolsize )
poolsize = suppoolsize ;
}
{
if ( stringvacancies < infstringvacancies )
stringvacancies = infstringvacancies ;
else if ( stringvacancies > supstringvacancies )
stringvacancies = supstringvacancies ;
}
{
if ( poolfree < infpoolfree )
poolfree = infpoolfree ;
else if ( poolfree > suppoolfree )
poolfree = suppoolfree ;
}
{
if ( maxstrings < infmaxstrings )
maxstrings = infmaxstrings ;
else if ( maxstrings > supmaxstrings )
maxstrings = supmaxstrings ;
}
#ifdef INIMP
if ( iniversion )
{
xmallocarray ( mem , memtop - 0 ) ;
xmallocarray ( strref , maxstrings ) ;
xmallocarray ( nextstr , maxstrings ) ;
xmallocarray ( strstart , maxstrings ) ;
xmallocarray ( strpool , poolsize ) ;
}
#endif /* INIMP */
history = 3 ;
if ( readyalready == 314159L )
goto lab1 ;
bad = 0 ;
if ( ( halferrorline < 30 ) || ( halferrorline > errorline - 15 ) )
bad = 1 ;
if ( maxprintline < 60 )
bad = 2 ;
if ( emergencylinelength < maxprintline )
bad = 3 ;
if ( 1100 > memtop )
bad = 4 ;
if ( 7919 > 9500 )
bad = 5 ;
if ( headersize % 4 != 0 )
bad = 6 ;
if ( ( ligtablesize < 255 ) || ( ligtablesize > 32510 ) )
bad = 7 ;
#ifdef INIMP
if ( memmax != memtop )
bad = 8 ;
#endif /* INIMP */
if ( memmax < memtop )
bad = 8 ;
if ( ( 0 > 0 ) || ( 255 < 127 ) )
bad = 9 ;
if ( ( 0 > 0 ) || ( 268435455L < 32767 ) )
bad = 10 ;
if ( ( 0 < 0 ) || ( 255 > 268435455L ) )
bad = 11 ;
if ( ( 0 < 0 ) || ( memmax >= 268435455L ) )
bad = 12 ;
if ( maxstrings > 268435455L )
bad = 13 ;
if ( bufsize > 268435455L )
bad = 14 ;
if ( fontmax > 268435455L )
bad = 15 ;
if ( ( 255 < 255 ) || ( 268435455L < 65535L ) )
bad = 16 ;
if ( 9771 + maxinternal > 268435455L )
bad = 17 ;
if ( 10222 > 268435455L )
bad = 18 ;
if ( 20 + 17 * 45 > bistacksize )
bad = 19 ;
if ( memdefaultlength > maxint )
bad = 20 ;
if ( bad > 0 )
{
fprintf( stdout , "%s%s%ld\n", "Ouch---my internal constants have been clobbered!" , "---case " , (long)bad ) ;
goto lab9999 ;
}
initialize () ;
#ifdef INIMP
if ( iniversion )
{
if ( ! getstringsstarted () )
goto lab9999 ;
inittab () ;
initprim () ;
initstruse = strptr ;
initpoolptr = poolptr ;
maxstrptr = strptr ;
maxpoolptr = poolptr ;
fixdateandtime () ;
}
#endif /* INIMP */
readyalready = 314159L ;
lab1: selector = 8 ;
tally = 0 ;
termoffset = 0 ;
fileoffset = 0 ;
psoffset = 0 ;
Fputs( stdout , "This is MetaPost, Version 0.641" ) ;
Fputs( stdout , versionstring ) ;
if ( memident > 0 )
print ( memident ) ;
println () ;
fflush ( stdout ) ;
jobname = 0 ;
logopened = false ;
{
{
inputptr = 0 ;
maxinstack = 0 ;
inopen = 0 ;
openparens = 0 ;
maxbufstack = 0 ;
paramptr = 0 ;
maxparamstack = 0 ;
first = 1 ;
curinput .startfield = 1 ;
curinput .indexfield = 0 ;
linestack [curinput .indexfield ]= 0 ;
curinput .namefield = 0 ;
mpxname [0 ]= 1 ;
forceeof = false ;
if ( ! initterminal () )
goto lab9999 ;
curinput .limitfield = last ;
first = last + 1 ;
}
scannerstatus = 0 ;
if ( ( memident == 0 ) || ( buffer [curinput .locfield ]== 38 ) ||
dumpline )
{
if ( memident != 0 )
initialize () ;
if ( ! openmemfile () )
goto lab9999 ;
if ( ! loadmemfile () )
{
wclose ( memfile ) ;
goto lab9999 ;
}
wclose ( memfile ) ;
while ( ( curinput .locfield < curinput .limitfield ) && ( buffer [
curinput .locfield ]== 32 ) ) incr ( curinput .locfield ) ;
}
buffer [curinput .limitfield ]= 37 ;
fixdateandtime () ;
initrandoms ( ( internal [16 ]/ 65536L ) + internal [15 ]) ;
if ( interaction == 0 )
selector = 7 ;
else selector = 8 ;
if ( curinput .locfield < curinput .limitfield )
if ( buffer [curinput .locfield ]!= 92 )
startinput () ;
}
history = 0 ;
if ( troffmode )
internal [32 ]= 65536L ;
if ( startsym > 0 )
{
cursym = startsym ;
backinput () ;
}
maincontrol () ;
finalcleanup () ;
closefilesandterminate () ;
lab9999: {
fflush ( stdout ) ;
readyalready = 0 ;
if ( ( history != 0 ) && ( history != 1 ) )
uexit ( 1 ) ;
else uexit ( 0 ) ;
}
}
|
