hrp%cerf.CRAY.COM@UC.MSC.UMN.EDU (Hal Peterson) (10/12/88)
GCC version 1.29
(input file appended, after my .signature.)
command: gcc -g -O -msoft-float -c core.c
configuration: md -> m68k.md
tm.h -> tm-sun3.h
Running on a Sun-3/280 running SunOS 3.5.
cc1 dies with a signal 11 (sigsegv).
--
Hal Peterson / Cray Research / 1440 Northland Dr. / Mendota Hts, MN 55120
hrp%hall.cray.com@uc.msc.umn.edu bungia!cray!hrp (612) 681-3145
============================================================
extern struct _iobuf {
int _cnt;
unsigned char *_ptr;
unsigned char *_base;
int _bufsiz;
short _flag;
char _file;
} _iob[];
extern struct _iobuf *fopen();
extern struct _iobuf *fdopen();
extern struct _iobuf *freopen();
extern struct _iobuf *popen();
extern struct _iobuf *tmpfile();
extern long ftell();
extern char *fgets();
extern char *gets();
extern char *ctermid();
extern char *cuserid();
extern char *tempnam();
extern char *tmpnam();
typedef char schar;
typedef long integer;
typedef char boolean;
typedef float glueratio;
typedef double real;
extern char *strcpy(), *strcat();
typedef struct _iobuf *alphafile, *bytefile, *wordfile, *file_ptr;
typedef char *ccharpointer;
char zinputln();
typedef unsigned char ASCIIcode ;
typedef unsigned char eightbits ;
typedef integer poolpointer ;
typedef integer strnumber ;
typedef integer scaled ;
typedef integer nonnegativeinteger ;
typedef schar smallnumber ;
typedef unsigned char quarterword ;
typedef unsigned short halfword ;
typedef schar twochoices ;
typedef schar fourchoices ;
typedef union {
struct {
halfword RH, LH;
} v;
struct {
halfword junk_space;
quarterword B0, B1;
} u;
} twohalves;
typedef struct {
struct {
quarterword B0;
quarterword B1;
} u;
quarterword b2;
quarterword b3;
} fourquarters;
typedef union {
integer cint;
glueratio gr;
twohalves hh;
fourquarters qqqq;
} memoryword;
typedef schar glueord ;
typedef struct {
short modefield ;
halfword headfield, tailfield ;
integer pgfield, auxfield, mlfield ;
} liststaterecord ;
typedef schar groupcode ;
typedef struct {
quarterword statefield, indexfield ;
halfword startfield, locfield, limitfield, namefield ;
} instaterecord ;
typedef integer internalfontnumber ;
typedef integer dviindex ;
typedef integer triepointer ;
typedef short hyphpointer ;
extern integer bad ;
extern ASCIIcode xord[128] ;
extern char xchr[256] ;
extern char nameoffile[1024 + 1], realnameoffile[1024 + 1] ;
extern integer namelength ;
extern ASCIIcode buffer[500 + 1] ;
extern integer first ;
extern integer last ;
extern integer maxbufstack ;
extern ASCIIcode strpool[32000L + 1] ;
extern poolpointer strstart[3000 + 1] ;
extern poolpointer poolptr ;
extern strnumber strptr ;
extern poolpointer initpoolptr ;
extern strnumber initstrptr ;
extern alphafile logfile ;
extern schar selector ;
extern schar dig[23] ;
extern integer tally ;
extern integer termoffset ;
extern integer fileoffset ;
extern ASCIIcode trickbuf[64 + 1] ;
extern integer trickcount ;
extern integer firstcount ;
extern schar interaction ;
extern boolean deletionsallowed ;
extern schar history ;
extern schar errorcount ;
extern strnumber helpline[6] ;
extern schar helpptr ;
extern boolean useerrhelp ;
extern integer interrupt ;
extern boolean OKtointerrupt ;
extern boolean aritherror ;
extern scaled remainder ;
extern halfword tempptr ;
extern memoryword
zzzaa[2999L - 0 + 1] ;
extern halfword lomemmax ;
extern halfword himemmin ;
extern integer varused, dynused ;
extern halfword avail ;
extern halfword memend ;
extern halfword rover ;
extern integer fontinshortdisplay ;
extern integer depththreshold ;
extern integer breadthmax ;
extern liststaterecord nest[40 + 1] ;
extern integer nestptr ;
extern integer maxneststack ;
extern liststaterecord curlist ;
extern short shownmode ;
extern schar oldsetting ;
extern memoryword zeqtb[5977] ;
extern quarterword
zzzad[710] ;
extern twohalves
zzzae[3267] ;
extern halfword hashused ;
extern boolean nonewcontrolsequence ;
extern integer cscount ;
extern memoryword savestack[600 + 1] ;
extern integer saveptr ;
extern integer maxsavestack ;
extern quarterword curlevel ;
extern groupcode curgroup ;
extern integer curboundary ;
extern integer magset ;
extern eightbits curcmd ;
extern halfword curchr ;
extern halfword curcs ;
extern halfword curtok ;
extern instaterecord inputstack[200 + 1] ;
extern integer inputptr ;
extern integer maxinstack ;
extern instaterecord curinput ;
extern integer inopen ;
extern alphafile inputfile[6 + 1] ;
extern integer line ;
extern integer linestack[6 + 1] ;
extern schar scannerstatus ;
extern halfword warningindex ;
extern halfword defref ;
extern halfword paramstack[60 + 1] ;
extern integer paramptr ;
extern integer maxparamstack ;
extern integer alignstate ;
extern integer baseptr ;
extern halfword parloc ;
extern halfword partoken ;
extern boolean forceeof ;
extern halfword curmark[5] ;
extern schar longstate ;
extern halfword pstack[9] ;
extern integer curval ;
extern schar curvallevel ;
extern smallnumber radix ;
extern glueord curorder ;
extern alphafile readfile[16] ;
extern schar readopen[17] ;
extern halfword condptr ;
extern schar iflimit ;
extern smallnumber curif ;
extern integer ifline ;
extern integer skipline ;
extern strnumber curname ;
extern strnumber curarea ;
extern strnumber curext ;
extern poolpointer areadelimiter ;
extern poolpointer extdelimiter ;
extern ccharpointer TEXformatdefault ;
extern boolean nameinprogress ;
extern strnumber jobname ;
extern bytefile dvifile ;
extern strnumber outputfilename ;
extern strnumber logname ;
extern bytefile tfmfile ;
extern memoryword fontinfo[20000L + 1] ;
extern integer fmemptr ;
extern internalfontnumber fontptr ;
extern fourquarters fontcheck[75 + 1] ;
extern scaled fontsize[75 + 1] ;
extern scaled fontdsize[75 + 1] ;
extern halfword fontparams[75 + 1] ;
extern strnumber fontname[75 + 1] ;
extern strnumber fontarea[75 + 1] ;
extern eightbits fontbc[75 + 1] ;
extern eightbits fontec[75 + 1] ;
extern halfword fontglue[75 + 1] ;
extern boolean fontused[75 + 1] ;
extern integer hyphenchar[75 + 1] ;
extern integer skewchar[75 + 1] ;
extern integer charbase[75 + 1] ;
extern integer widthbase[75 + 1] ;
extern integer heightbase[75 + 1] ;
extern integer depthbase[75 + 1] ;
extern integer italicbase[75 + 1] ;
extern integer ligkernbase[75 + 1] ;
extern integer kernbase[75 + 1] ;
extern integer extenbase[75 + 1] ;
extern integer parambase[75 + 1] ;
extern fourquarters nullcharacter ;
extern integer totalpages ;
extern scaled maxv ;
extern scaled maxh ;
extern integer maxpush ;
extern integer lastbop ;
extern integer deadcycles ;
extern boolean doingleaders ;
extern quarterword c, f ;
extern scaled ruleht, ruledp, rulewd ;
extern halfword g ;
extern integer lq, lr ;
extern eightbits dvibuf[16384 + 1] ;
extern dviindex halfbuf ;
extern dviindex dvilimit ;
extern dviindex dviptr ;
extern integer dvioffset ;
extern integer dvigone ;
extern halfword downptr, rightptr ;
extern scaled dvih, dviv ;
extern scaled curh, curv ;
extern internalfontnumber dvif ;
extern integer curs ;
extern scaled totalstretch[4], totalshrink[4] ;
extern halfword adjusttail ;
extern integer packbeginline ;
extern twohalves emptyfield ;
extern fourquarters nulldelimiter ;
extern halfword curmlist ;
extern smallnumber curstyle ;
extern smallnumber cursize ;
extern scaled curmu ;
extern boolean mlistpenalties ;
extern internalfontnumber curf ;
extern quarterword curc ;
extern fourquarters curi ;
extern integer magicoffset ;
extern halfword curalign ;
extern halfword curspan ;
extern halfword curloop ;
extern halfword alignptr ;
extern halfword curhead, curtail ;
extern halfword justbox ;
extern halfword passive ;
extern halfword printednode ;
extern halfword passnumber ;
extern scaled activewidth[7] ;
extern scaled curactivewidth[7] ;
extern scaled background[7] ;
extern scaled breakwidth[7] ;
extern boolean noshrinkerroryet ;
extern halfword curp ;
extern boolean secondpass ;
extern integer threshold ;
extern scaled minimaldemerits[4] ;
extern scaled minimumdemerits ;
extern halfword bestplace[4] ;
extern halfword bestplline[4] ;
extern scaled discwidth ;
extern halfword easyline ;
extern halfword lastspecialline ;
extern scaled firstwidth ;
extern scaled secondwidth ;
extern scaled firstindent ;
extern scaled secondindent ;
extern halfword bestbet ;
extern integer fewestdemerits ;
extern halfword bestline ;
extern integer actuallooseness ;
extern integer linediff ;
extern halfword hc[66] ;
extern smallnumber hn ;
extern halfword ha, hb ;
extern internalfontnumber hf ;
extern ASCIIcode hu[64] ;
extern integer hyfchar ;
extern schar hyf[65] ;
extern smallnumber hyphenpassed ;
extern twohalves trie[8000 + 1] ;
extern smallnumber hyfdistance[256] ;
extern smallnumber hyfnum[256] ;
extern quarterword hyfnext[256] ;
extern strnumber hyphword[308] ;
extern halfword hyphlist[308] ;
extern hyphpointer hyphcount ;
extern quarterword trieopptr ;
extern triepointer triemax ;
extern scaled bestheightplusdepth ;
extern halfword pagetail ;
extern schar pagecontents ;
extern scaled pagemaxdepth ;
extern halfword bestpagebreak ;
extern integer leastpagecost ;
extern scaled bestsize ;
extern scaled pagesofar[8] ;
extern halfword lastglue ;
extern integer lastpenalty ;
extern scaled lastkern ;
extern integer insertpenalties ;
extern boolean outputactive ;
extern halfword curbox ;
extern halfword aftertoken ;
extern boolean longhelpseen ;
extern strnumber formatident ;
extern wordfile fmtfile ;
extern integer readyalready ;
extern alphafile writefile[16] ;
extern boolean writeopen[18] ;
extern halfword writeloc ;
extern poolpointer editnamestart ;
extern integer editnamelength, editline, tfmtemp ;
boolean initterminal();
strnumber makestring();
boolean zstreqbuf();
boolean zstreqstr();
boolean getstringsstarted();
integer zhalf();
scaled zrounddecimals();
scaled znxplusy();
scaled zxovern();
scaled zxnoverd();
halfword zbadness();
halfword getavail();
halfword zgetnode();
halfword newnullbox();
halfword newrule();
halfword znewligature();
halfword newdisc();
halfword znewmath();
halfword znewspec();
halfword znewparamglue();
halfword znewglue();
halfword znewskipparam();
halfword znewkern();
halfword znewpenalty();
halfword zcopynodelist();
halfword zidlookup();
boolean zscankeyword();
halfword scanrulespec();
halfword strtoks();
halfword thetoks();
halfword zscantoks();
boolean zmorename();
strnumber makenamestring();
internalfontnumber zreadfontinfo();
halfword znewcharacter();
halfword zhpack();
halfword zvpackage();
halfword newnoad();
halfword znewstyle();
halfword newchoice();
halfword zfractionrule();
halfword zoverbar();
halfword zcharbox();
scaled zheightplusdepth();
halfword zvardelimiter();
halfword zrebox();
halfword zmathglue();
halfword zcleanbox();
scaled zmakeop();
smallnumber zmakeleftright();
boolean fincol();
halfword zfiniteshrink();
smallnumber zreconstitute();
quarterword znewtrieop();
triepointer ztrienode();
triepointer zcompresstrie();
halfword zprunepagetop();
halfword zvertbreak();
halfword zvsplit();
boolean privileged();
boolean itsallover();
halfword zfinmlist();
boolean openfmtfile();
boolean loadfmtfile();
zcharwarning ( f , c )
internalfontnumber f ;
eightbits c ;
{register memoryword *eqtb=zeqtb;
if ( eqtb [ 5302 ] .cint > 0 )
{
begindiagnostic () ;
zprintnl((strnumber)( 678 )) ;
zprintASCII((integer)( c )) ;
zprint((integer)( 679 )) ;
zprint((integer)( fontname [ f ] )) ;
zprintchar((ASCIIcode)( 33 )) ;
zenddiagnostic((boolean)( 0 )) ;
}
}
halfword znewcharacter ( f , c )
internalfontnumber f ;
eightbits c ;
{ register halfword Result; register memoryword *mem=(zzzaa - (int)(0 )) ;
halfword p ;
if ( fontbc [ f ] <= c )
if ( fontec [ f ] >= c )
if ( ( fontinfo [ charbase [ f ] + c ] .qqqq .u.B0 > 0 ) )
{
p = getavail () ;
mem [ p ] .hh.u.B0 = f ;
mem [ p ] .hh.u.B1 = c ;
Result = p ;
return(Result) ;
}
zcharwarning((internalfontnumber)( f ),(eightbits)( c )) ;
Result = 0 ;
return(Result) ;
}
dviswap () {
if ( dvilimit == 16384 )
{
(void) write(((dvifile)->_file) , (char *) &dvibuf[ 0 ], (int)( halfbuf - 1 - 0 +1)) ;
dvilimit = halfbuf ;
dvioffset = dvioffset + 16384 ;
dviptr = 0 ;
}
else {
(void) write(((dvifile)->_file) , (char *) &dvibuf[ halfbuf ], (int)( 16384 - 1 - halfbuf +1)) ;
dvilimit = 16384 ;
}
dvigone = dvigone + halfbuf ;
}
zdvifour ( x )
integer x ;
{
if ( x >= 0 )
{
dvibuf [ dviptr ] = x / 16777216L ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
else {
x = x + 1073741824L ;
x = x + 1073741824L ;
{
dvibuf [ dviptr ] = ( x / 16777216L ) + 128 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
}
x = x % 16777216L ;
{
dvibuf [ dviptr ] = x / 65536L ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
x = x % 65536L ;
{
dvibuf [ dviptr ] = x / 256 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
{
dvibuf [ dviptr ] = x % 256 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
}
zdvipop ( l )
integer l ;
{
if ( ( l == dvioffset + dviptr ) && ( dviptr > 0 ) )
--( dviptr ) ;
else {
dvibuf [ dviptr ] = 142 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
}
zdvifontdef ( f )
internalfontnumber f ;
{
poolpointer k ;
{
dvibuf [ dviptr ] = 243 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
{
dvibuf [ dviptr ] = f - 1 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
{
dvibuf [ dviptr ] = fontcheck [ f ] .u.B0 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
{
dvibuf [ dviptr ] = fontcheck [ f ] .u.B1 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
{
dvibuf [ dviptr ] = fontcheck [ f ] .b2 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
{
dvibuf [ dviptr ] = fontcheck [ f ] .b3 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
zdvifour((integer)( fontsize [ f ] )) ;
zdvifour((integer)( fontdsize [ f ] )) ;
{
dvibuf [ dviptr ] = ( strstart [ fontarea [ f ] + 1 ] - strstart [
fontarea [ f ] ] ) ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
{
dvibuf [ dviptr ] = ( strstart [ fontname [ f ] + 1 ] - strstart [
fontname [ f ] ] ) ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
{register integer for_end; k = strstart [ fontarea [ f ] ] ; for_end =
strstart [ fontarea [ f ] + 1 ] - 1 ; if ( k <= for_end) do
{
dvibuf [ dviptr ] = strpool [ k ] ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
while ( k++ < for_end ) ; }
{register integer for_end; k = strstart [ fontname [ f ] ] ; for_end =
strstart [ fontname [ f ] + 1 ] - 1 ; if ( k <= for_end) do
{
dvibuf [ dviptr ] = strpool [ k ] ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
while ( k++ < for_end ) ; }
}
zmovement ( w , o )
scaled w ;
eightbits o ;
{ register memoryword *mem=(zzzaa - (int)(0 )) ;
smallnumber mstate ;
halfword p, q ;
integer k ;
q = zgetnode((integer)( 3 )) ;
mem [ q + 1 ] .cint = w ;
mem [ q + 2 ] .cint = dvioffset + dviptr ;
if ( o == 157 )
{
mem [ q ] .hh .v.RH = downptr ;
downptr = q ;
}
else {
mem [ q ] .hh .v.RH = rightptr ;
rightptr = q ;
}
p = mem [ q ] .hh .v.RH ;
mstate = 0 ;
while ( p != 0 ) {
if ( mem [ p + 1 ] .cint == w )
switch ( mstate + mem [ p ] .hh .v.LH )
{case 3 :
case 4 :
case 15 :
case 16 :
if ( mem [ p + 2 ] .cint < dvigone )
goto lab45 ;
else {
k = mem [ p + 2 ] .cint - dvioffset ;
if ( k < 0 )
k = k + 16384 ;
dvibuf [ k ] = dvibuf [ k ] + 5 ;
mem [ p ] .hh .v.LH = 1 ;
goto lab40 ;
}
break ;
case 5 :
case 9 :
case 11 :
if ( mem [ p + 2 ] .cint < dvigone )
goto lab45 ;
else {
k = mem [ p + 2 ] .cint - dvioffset ;
if ( k < 0 )
k = k + 16384 ;
dvibuf [ k ] = dvibuf [ k ] + 10 ;
mem [ p ] .hh .v.LH = 2 ;
goto lab40 ;
}
break ;
case 1 :
case 2 :
case 8 :
case 13 :
goto lab40 ;
break ;
default:
;
break ;
}
else switch ( mstate + mem [ p ] .hh .v.LH )
{case 1 :
mstate = 6 ;
break ;
case 2 :
mstate = 12 ;
break ;
case 8 :
case 13 :
goto lab45 ;
break ;
default:
;
break ;
}
p = mem [ p ] .hh .v.RH ;
}
lab45: ;
mem [ q ] .hh .v.LH = 3 ;
if ( (( w >=0)?( w ):(-( w ))) >= 8388608L )
{
{
dvibuf [ dviptr ] = o + 3 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
zdvifour((integer)( w )) ;
return ;
}
if ( (( w >=0)?( w ):(-( w ))) >= 32768L )
{
{
dvibuf [ dviptr ] = o + 2 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
if ( w < 0 )
w = w + 16777216L ;
{
dvibuf [ dviptr ] = w / 65536L ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
w = w % 65536L ;
goto lab2 ;
}
if ( (( w >=0)?( w ):(-( w ))) >= 128 )
{
{
dvibuf [ dviptr ] = o + 1 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
if ( w < 0 )
w = w + 65536L ;
goto lab2 ;
}
{
dvibuf [ dviptr ] = o ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
if ( w < 0 )
w = w + 256 ;
goto lab1 ;
lab2: {
dvibuf [ dviptr ] = w / 256 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
lab1: {
dvibuf [ dviptr ] = w % 256 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
return ;
lab40: mem [ q ] .hh .v.LH = mem [ p ] .hh .v.LH ;
if ( mem [ q ] .hh .v.LH == 1 )
{
{
dvibuf [ dviptr ] = o + 4 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
while ( mem [ q ] .hh .v.RH != p ) {
q = mem [ q ] .hh .v.RH ;
switch ( mem [ q ] .hh .v.LH )
{case 3 :
mem [ q ] .hh .v.LH = 5 ;
break ;
case 4 :
mem [ q ] .hh .v.LH = 6 ;
break ;
default:
;
break ;
}
}
}
else {
{
dvibuf [ dviptr ] = o + 9 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
while ( mem [ q ] .hh .v.RH != p ) {
q = mem [ q ] .hh .v.RH ;
switch ( mem [ q ] .hh .v.LH )
{case 3 :
mem [ q ] .hh .v.LH = 4 ;
break ;
case 5 :
mem [ q ] .hh .v.LH = 6 ;
break ;
default:
;
break ;
}
}
}
}
zprunemovements ( l )
integer l ;
{ register memoryword *mem=(zzzaa - (int)(0 )) ;
halfword p ;
while ( downptr != 0 ) {
if ( mem [ downptr + 2 ] .cint < l )
goto lab30 ;
p = downptr ;
downptr = mem [ p ] .hh .v.RH ;
zfreenode((halfword)( p ),(halfword)( 3 )) ;
}
lab30: while ( rightptr != 0 ) {
if ( mem [ rightptr + 2 ] .cint < l )
return ;
p = rightptr ;
rightptr = mem [ p ] .hh .v.RH ;
zfreenode((halfword)( p ),(halfword)( 3 )) ;
}
}
zspecialout ( p )
halfword p ;
{register memoryword *mem=(zzzaa - (int)(0 )) ;
schar oldsetting ;
poolpointer k ;
if ( curh != dvih )
{
zmovement((scaled)( curh - dvih ),(eightbits)( 143 )) ;
dvih = curh ;
}
if ( curv != dviv )
{
zmovement((scaled)( curv - dviv ),(eightbits)( 157 )) ;
dviv = curv ;
}
oldsetting = selector ;
selector = 21 ;
zshowtokenlist((integer)( mem [ mem [ p + 1 ] .hh .v.RH ] .hh .v.RH ),(integer)( 0 ),(integer)( 32000L -
poolptr )) ;
selector = oldsetting ;
{
if ( poolptr + 1 > 32000L )
zoverflow((strnumber)( 128 ),(integer)( 32000L - initpoolptr )) ;
}
if ( ( poolptr - strstart [ strptr ] ) < 256 )
{
{
dvibuf [ dviptr ] = 239 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
{
dvibuf [ dviptr ] = ( poolptr - strstart [ strptr ] ) ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
}
else {
{
dvibuf [ dviptr ] = 242 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
zdvifour((integer)( ( poolptr - strstart [ strptr ] ) )) ;
}
{register integer for_end; k = strstart [ strptr ] ; for_end = poolptr - 1
; if ( k <= for_end) do
{
dvibuf [ dviptr ] = strpool [ k ] ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
while ( k++ < for_end ) ; }
poolptr = strstart [ strptr ] ;
}
zwriteout ( p )
halfword p ;
{register memoryword *mem=(zzzaa - (int)(0 )) ;
schar oldsetting ;
integer oldmode ;
smallnumber j ;
halfword q, r ;
q = getavail () ;
mem [ q ] .hh .v.LH = 637 ;
r = getavail () ;
mem [ q ] .hh .v.RH = r ;
mem [ r ] .hh .v.LH = 7362 ;
zbegintokenlist((halfword)( q ),(quarterword)( 4 )) ;
zbegintokenlist((halfword)( mem [ p + 1 ] .hh .v.RH ),(quarterword)( 15 )) ;
q = getavail () ;
mem [ q ] .hh .v.LH = 379 ;
zbegintokenlist((halfword)( q ),(quarterword)( 4 )) ;
oldmode = curlist .modefield ;
curlist .modefield = 0 ;
curcs = writeloc ;
q = zscantoks((boolean)( 0 ),(boolean)( 1 )) ;
gettoken () ;
if ( curtok != 7362 )
{
{
if ( interaction == 3 )
wakeupterminal () ;
zprintnl((strnumber)( 133 )) ;
zprint((integer)( 1139 )) ;
}
{
helpptr = 2 ;
helpline [ 1 ] = 1140 ;
helpline [ 0 ] = 860 ;
}
error () ;
do {
gettoken () ;
} while ( ! ( curtok == 7362 ) ) ;
}
curlist .modefield = oldmode ;
endtokenlist () ;
oldsetting = selector ;
j = mem [ p + 1 ] .hh .v.LH ;
if ( writeopen [ j ] )
selector = j ;
else {
if ( ( j == 17 ) && ( selector == 19 ) )
selector = 18 ;
zprintnl((strnumber)( 206 )) ;
}
zshowtokenlist((integer)( mem [ defref ] .hh .v.RH ),(integer)( 0 ),(integer)( 10000000L )) ;
println () ;
zflushlist((halfword)( defref )) ;
selector = oldsetting ;
}
zoutwhat ( p )
halfword p ;
{register memoryword *mem=(zzzaa - (int)(0 )) ;
smallnumber j ;
switch ( mem [ p ] .hh.u.B1 )
{case 0 :
case 1 :
case 2 :
if ( ! doingleaders )
{
j = mem [ p + 1 ] .hh .v.LH ;
if ( mem [ p ] .hh.u.B1 == 1 )
zwriteout((halfword)( p )) ;
else {
if ( writeopen [ j ] )
if ( writefile [ j ] ) (void) fclose( writefile [ j ] ) ;
if ( mem [ p ] .hh.u.B1 == 2 )
writeopen [ j ] = 0 ;
else if ( j < 16 )
{
curname = mem [ p + 1 ] .hh .v.RH ;
curarea = mem [ p + 2 ] .hh .v.LH ;
curext = mem [ p + 2 ] .hh .v.RH ;
if ( curext == 206 )
curext = 644 ;
zpackfilename((strnumber)( curname ),(strnumber)( curarea ),(strnumber)( curext )) ;
while ( ! Openout(&( writefile [ j ] )) ) zpromptfilename((strnumber)( 1142 ),(strnumber)( 644
)) ;
writeopen [ j ] = 1 ;
}
}
}
break ;
case 3 :
zspecialout((halfword)( p )) ;
break ;
default:
zconfusion((strnumber)( 1141 )) ;
break ;
}
}
hlistout () {
register memoryword *mem=(zzzaa - (int)(0 )) ;
scaled baseline ;
scaled leftedge ;
scaled saveh, savev ;
halfword thisbox ;
glueord gorder ;
schar gsign ;
halfword p ;
integer saveloc ;
halfword leaderbox ;
scaled leaderwd ;
scaled lx ;
boolean outerdoingleaders ;
scaled edge ;
thisbox = tempptr ;
gorder = mem [ thisbox + 5 ] .hh.u.B1 ;
gsign = mem [ thisbox + 5 ] .hh.u.B0 ;
p = mem [ thisbox + 5 ] .hh .v.RH ;
++( curs ) ;
if ( curs > 0 )
{
dvibuf [ dviptr ] = 141 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
if ( curs > maxpush )
maxpush = curs ;
saveloc = dvioffset + dviptr ;
baseline = curv ;
leftedge = curh ;
while ( p != 0 ) lab21: if ( ( p >= himemmin ) )
{
if ( curh != dvih )
{
zmovement((scaled)( curh - dvih ),(eightbits)( 143 )) ;
dvih = curh ;
}
if ( curv != dviv )
{
zmovement((scaled)( curv - dviv ),(eightbits)( 157 )) ;
dviv = curv ;
}
do {
f = mem [ p ] .hh.u.B0 ;
c = mem [ p ] .hh.u.B1 ;
if ( f != dvif )
{
if ( ! fontused [ f ] )
{
zdvifontdef((internalfontnumber)( f )) ;
fontused [ f ] = 1 ;
}
if ( f <= 64 )
{
dvibuf [ dviptr ] = f + 170 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
else {
{
dvibuf [ dviptr ] = 235 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
{
dvibuf [ dviptr ] = f - 1 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
}
dvif = f ;
}
if ( c >= 128 )
{
dvibuf [ dviptr ] = 128 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
{
dvibuf [ dviptr ] = c ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
curh = curh + fontinfo [ widthbase [ f ] + fontinfo [ charbase [ f ] + c
] .qqqq .u.B0 ] .cint ;
p = mem [ p ] .hh .v.RH ;
} while ( ! ( ! ( p >= himemmin ) ) ) ;
dvih = curh ;
}
else {
switch ( mem [ p ] .hh.u.B0 )
{case 0 :
case 1 :
if ( mem [ p + 5 ] .hh .v.RH == 0 )
curh = curh + mem [ p + 1 ] .cint ;
else {
saveh = dvih ;
savev = dviv ;
curv = baseline + mem [ p + 4 ] .cint ;
tempptr = p ;
edge = curh ;
if ( mem [ p ] .hh.u.B0 == 1 )
vlistout () ;
else hlistout () ;
dvih = saveh ;
dviv = savev ;
curh = edge + mem [ p + 1 ] .cint ;
curv = baseline ;
}
break ;
case 2 :
{
ruleht = mem [ p + 3 ] .cint ;
ruledp = mem [ p + 2 ] .cint ;
rulewd = mem [ p + 1 ] .cint ;
goto lab14 ;
}
break ;
case 8 :
zoutwhat((halfword)( p )) ;
break ;
case 10 :
{
g = mem [ p + 1 ] .hh .v.LH ;
rulewd = mem [ g + 1 ] .cint ;
if ( gsign != 0 )
{
if ( gsign == 1 )
{
if ( mem [ g ] .hh.u.B0 == gorder )
rulewd = rulewd + ((integer) ( mem [ thisbox + 6 ] .gr * mem [ g + 2 ]
.cint + 0.5)) ;
}
else {
if ( mem [ g ] .hh.u.B1 == gorder )
rulewd = rulewd - ((integer) ( mem [ thisbox + 6 ] .gr * mem [ g + 3 ]
.cint + 0.5)) ;
}
}
if ( mem [ p ] .hh.u.B1 >= 100 )
{
leaderbox = mem [ p + 1 ] .hh .v.RH ;
if ( mem [ leaderbox ] .hh.u.B0 == 2 )
{
ruleht = mem [ leaderbox + 3 ] .cint ;
ruledp = mem [ leaderbox + 2 ] .cint ;
goto lab14 ;
}
leaderwd = mem [ leaderbox + 1 ] .cint ;
if ( ( leaderwd > 0 ) && ( rulewd > 0 ) )
{
rulewd = rulewd + 10 ;
edge = curh + rulewd ;
lx = 0 ;
if ( mem [ p ] .hh.u.B1 == 100 )
{
saveh = curh ;
curh = leftedge + leaderwd * ( ( curh - leftedge ) / leaderwd )
;
if ( curh < saveh )
curh = curh + leaderwd ;
}
else {
lq = rulewd / leaderwd ;
lr = rulewd % leaderwd ;
if ( mem [ p ] .hh.u.B1 == 101 )
curh = curh + ( lr / 2 ) ;
else {
lx = ( 2 * lr + lq + 1 ) / ( 2 * lq + 2 ) ;
curh = curh + ( ( lr - ( lq - 1 ) * lx ) / 2 ) ;
}
}
while ( curh + leaderwd <= edge ) {
curv = baseline + mem [ leaderbox + 4 ] .cint ;
if ( curv != dviv )
{
zmovement((scaled)( curv - dviv ),(eightbits)( 157 )) ;
dviv = curv ;
}
savev = dviv ;
if ( curh != dvih )
{
zmovement((scaled)( curh - dvih ),(eightbits)( 143 )) ;
dvih = curh ;
}
saveh = dvih ;
tempptr = leaderbox ;
outerdoingleaders = doingleaders ;
doingleaders = 1 ;
if ( mem [ leaderbox ] .hh.u.B0 == 1 )
vlistout () ;
else hlistout () ;
doingleaders = outerdoingleaders ;
dviv = savev ;
dvih = saveh ;
curv = savev ;
curh = saveh + leaderwd + lx ;
}
curh = edge - 10 ;
goto lab15 ;
}
}
goto lab13 ;
}
break ;
case 11 :
case 9 :
curh = curh + mem [ p + 1 ] .cint ;
break ;
case 6 :
{
mem [ 2999L - 12 ] = mem [ p + 1 ] ;
mem [ 2999L - 12 ] .hh .v.RH = mem [ p ] .hh .v.RH ;
p = 2999L - 12 ;
goto lab21 ;
}
break ;
default:
;
break ;
}
goto lab15 ;
lab14: if ( ( ruleht == -1073741824L ) )
ruleht = mem [ thisbox + 3 ] .cint ;
if ( ( ruledp == -1073741824L ) )
ruledp = mem [ thisbox + 2 ] .cint ;
ruleht = ruleht + ruledp ;
if ( ( ruleht > 0 ) && ( rulewd > 0 ) )
{
if ( curh != dvih )
{
zmovement((scaled)( curh - dvih ),(eightbits)( 143 )) ;
dvih = curh ;
}
curv = baseline + ruledp ;
if ( curv != dviv )
{
zmovement((scaled)( curv - dviv ),(eightbits)( 157 )) ;
dviv = curv ;
}
{
dvibuf [ dviptr ] = 132 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
zdvifour((integer)( ruleht )) ;
zdvifour((integer)( rulewd )) ;
curv = baseline ;
dvih = dvih + rulewd ;
}
lab13: curh = curh + rulewd ;
lab15: p = mem [ p ] .hh .v.RH ;
}
zprunemovements((integer)( saveloc )) ;
if ( curs > 0 )
zdvipop((integer)( saveloc )) ;
--( curs ) ;
}
vlistout () {
register memoryword *mem=(zzzaa - (int)(0 )) ;
scaled leftedge ;
scaled topedge ;
scaled saveh, savev ;
halfword thisbox ;
glueord gorder ;
schar gsign ;
halfword p ;
integer saveloc ;
halfword leaderbox ;
scaled leaderht ;
scaled lx ;
boolean outerdoingleaders ;
scaled edge ;
thisbox = tempptr ;
gorder = mem [ thisbox + 5 ] .hh.u.B1 ;
gsign = mem [ thisbox + 5 ] .hh.u.B0 ;
p = mem [ thisbox + 5 ] .hh .v.RH ;
++( curs ) ;
if ( curs > 0 )
{
dvibuf [ dviptr ] = 141 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
if ( curs > maxpush )
maxpush = curs ;
saveloc = dvioffset + dviptr ;
leftedge = curh ;
curv = curv - mem [ thisbox + 3 ] .cint ;
topedge = curv ;
while ( p != 0 ) {
if ( ( p >= himemmin ) )
zconfusion((strnumber)( 681 )) ;
else {
switch ( mem [ p ] .hh.u.B0 )
{case 0 :
case 1 :
if ( mem [ p + 5 ] .hh .v.RH == 0 )
curv = curv + mem [ p + 3 ] .cint + mem [ p + 2 ] .cint ;
else {
curv = curv + mem [ p + 3 ] .cint ;
if ( curv != dviv )
{
zmovement((scaled)( curv - dviv ),(eightbits)( 157 )) ;
dviv = curv ;
}
saveh = dvih ;
savev = dviv ;
curh = leftedge + mem [ p + 4 ] .cint ;
tempptr = p ;
if ( mem [ p ] .hh.u.B0 == 1 )
vlistout () ;
else hlistout () ;
dvih = saveh ;
dviv = savev ;
curv = savev + mem [ p + 2 ] .cint ;
curh = leftedge ;
}
break ;
case 2 :
{
ruleht = mem [ p + 3 ] .cint ;
ruledp = mem [ p + 2 ] .cint ;
rulewd = mem [ p + 1 ] .cint ;
goto lab14 ;
}
break ;
case 8 :
zoutwhat((halfword)( p )) ;
break ;
case 10 :
{
g = mem [ p + 1 ] .hh .v.LH ;
ruleht = mem [ g + 1 ] .cint ;
if ( gsign != 0 )
{
if ( gsign == 1 )
{
if ( mem [ g ] .hh.u.B0 == gorder )
ruleht = ruleht + ((integer) ( mem [ thisbox + 6 ] .gr * mem [ g + 2
] .cint + 0.5)) ;
}
else {
if ( mem [ g ] .hh.u.B1 == gorder )
ruleht = ruleht - ((integer) ( mem [ thisbox + 6 ] .gr * mem [ g + 3
] .cint + 0.5)) ;
}
}
if ( mem [ p ] .hh.u.B1 >= 100 )
{
leaderbox = mem [ p + 1 ] .hh .v.RH ;
if ( mem [ leaderbox ] .hh.u.B0 == 2 )
{
rulewd = mem [ leaderbox + 1 ] .cint ;
ruledp = 0 ;
goto lab14 ;
}
leaderht = mem [ leaderbox + 3 ] .cint + mem [ leaderbox + 2 ]
.cint ;
if ( ( leaderht > 0 ) && ( ruleht > 0 ) )
{
ruleht = ruleht + 10 ;
edge = curv + ruleht ;
lx = 0 ;
if ( mem [ p ] .hh.u.B1 == 100 )
{
savev = curv ;
curv = topedge + leaderht * ( ( curv - topedge ) / leaderht )
;
if ( curv < savev )
curv = curv + leaderht ;
}
else {
lq = ruleht / leaderht ;
lr = ruleht % leaderht ;
if ( mem [ p ] .hh.u.B1 == 101 )
curv = curv + ( lr / 2 ) ;
else {
lx = ( 2 * lr + lq + 1 ) / ( 2 * lq + 2 ) ;
curv = curv + ( ( lr - ( lq - 1 ) * lx ) / 2 ) ;
}
}
while ( curv + leaderht <= edge ) {
curh = leftedge + mem [ leaderbox + 4 ] .cint ;
if ( curh != dvih )
{
zmovement((scaled)( curh - dvih ),(eightbits)( 143 )) ;
dvih = curh ;
}
saveh = dvih ;
curv = curv + mem [ leaderbox + 3 ] .cint ;
if ( curv != dviv )
{
zmovement((scaled)( curv - dviv ),(eightbits)( 157 )) ;
dviv = curv ;
}
savev = dviv ;
tempptr = leaderbox ;
outerdoingleaders = doingleaders ;
doingleaders = 1 ;
if ( mem [ leaderbox ] .hh.u.B0 == 1 )
vlistout () ;
else hlistout () ;
doingleaders = outerdoingleaders ;
dviv = savev ;
dvih = saveh ;
curh = saveh ;
curv = savev - mem [ leaderbox + 3 ] .cint + leaderht + lx ;
}
curv = edge - 10 ;
goto lab15 ;
}
}
goto lab13 ;
}
break ;
case 11 :
curv = curv + mem [ p + 1 ] .cint ;
break ;
default:
;
break ;
}
goto lab15 ;
lab14: if ( ( rulewd == -1073741824L ) )
rulewd = mem [ thisbox + 1 ] .cint ;
ruleht = ruleht + ruledp ;
curv = curv + ruleht ;
if ( ( ruleht > 0 ) && ( rulewd > 0 ) )
{
if ( curh != dvih )
{
zmovement((scaled)( curh - dvih ),(eightbits)( 143 )) ;
dvih = curh ;
}
if ( curv != dviv )
{
zmovement((scaled)( curv - dviv ),(eightbits)( 157 )) ;
dviv = curv ;
}
{
dvibuf [ dviptr ] = 137 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
zdvifour((integer)( ruleht )) ;
zdvifour((integer)( rulewd )) ;
}
goto lab15 ;
lab13: curv = curv + ruleht ;
}
lab15: p = mem [ p ] .hh .v.RH ;
}
zprunemovements((integer)( saveloc )) ;
if ( curs > 0 )
zdvipop((integer)( saveloc )) ;
--( curs ) ;
}
zshipout ( p )
halfword p ;
{ register memoryword *mem=(zzzaa - (int)(0 )) , *eqtb=zeqtb;
integer pageloc ;
schar j, k ;
poolpointer s ;
schar oldsetting ;
if ( eqtb [ 5301 ] .cint > 0 )
{
zprintnl((strnumber)( 206 )) ;
println () ;
zprint((integer)( 682 )) ;
}
if ( termoffset > 72 - 9 )
println () ;
else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) )
zprintchar((ASCIIcode)( 32 )) ;
zprintchar((ASCIIcode)( 91 )) ;
j = 9 ;
while ( ( eqtb [ 5317 + j ] .cint == 0 ) && ( j > 0 ) ) --( j ) ;
{register integer for_end; k = 0 ; for_end = j ; if ( k <= for_end) do
{
zprintint((integer)( eqtb [ 5317 + k ] .cint )) ;
if ( k < j )
zprintchar((ASCIIcode)( 46 )) ;
}
while ( k++ < for_end ) ; }
(void) fflush( (&_iob[1]) ) ;
if ( eqtb [ 5301 ] .cint > 0 )
{
zprintchar((ASCIIcode)( 93 )) ;
begindiagnostic () ;
zshowbox((halfword)( p )) ;
zenddiagnostic((boolean)( 1 )) ;
}
if ( ( mem [ p + 3 ] .cint > 1073741823L ) || ( mem [ p + 2 ] .cint >
1073741823L ) || ( mem [ p + 3 ] .cint + mem [ p + 2 ] .cint + eqtb [ 5720 ]
.cint > 1073741823L ) || ( mem [ p + 1 ] .cint + eqtb [ 5719 ] .cint >
1073741823L ) )
{
{
if ( interaction == 3 )
wakeupterminal () ;
zprintnl((strnumber)( 133 )) ;
zprint((integer)( 686 )) ;
}
{
helpptr = 2 ;
helpline [ 1 ] = 687 ;
helpline [ 0 ] = 688 ;
}
error () ;
if ( eqtb [ 5301 ] .cint <= 0 )
{
begindiagnostic () ;
zprintnl((strnumber)( 689 )) ;
zshowbox((halfword)( p )) ;
zenddiagnostic((boolean)( 1 )) ;
}
goto lab30 ;
}
if ( mem [ p + 3 ] .cint + mem [ p + 2 ] .cint + eqtb [ 5720 ] .cint > maxv
)
maxv = mem [ p + 3 ] .cint + mem [ p + 2 ] .cint + eqtb [ 5720 ] .cint ;
if ( mem [ p + 1 ] .cint + eqtb [ 5719 ] .cint > maxh )
maxh = mem [ p + 1 ] .cint + eqtb [ 5719 ] .cint ;
dvih = 0 ;
dviv = 0 ;
curh = eqtb [ 5719 ] .cint ;
dvif = 0 ;
if ( outputfilename == 0 )
{
if ( jobname == 0 )
openlogfile () ;
zpackjobname((strnumber)( 647 )) ;
while ( ! Openout(&( dvifile )) ) zpromptfilename((strnumber)( 648 ),(strnumber)( 647 )) ;
outputfilename = makenamestring() ;
}
if ( totalpages == 0 )
{
{
dvibuf [ dviptr ] = 247 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
{
dvibuf [ dviptr ] = 2 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
zdvifour((integer)( 25400000L )) ;
zdvifour((integer)( 473628672L )) ;
preparemag () ;
zdvifour((integer)( eqtb [ 5284 ] .cint )) ;
oldsetting = selector ;
selector = 21 ;
zprint((integer)( 680 )) ;
zprintint((integer)( eqtb [ 5290 ] .cint )) ;
zprintchar((ASCIIcode)( 46 )) ;
zprinttwo((integer)( eqtb [ 5289 ] .cint )) ;
zprintchar((ASCIIcode)( 46 )) ;
zprinttwo((integer)( eqtb [ 5288 ] .cint )) ;
zprintchar((ASCIIcode)( 58 )) ;
zprinttwo((integer)( eqtb [ 5287 ] .cint / 60 )) ;
zprinttwo((integer)( eqtb [ 5287 ] .cint % 60 )) ;
selector = oldsetting ;
{
dvibuf [ dviptr ] = ( poolptr - strstart [ strptr ] ) ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
{register integer for_end; s = strstart [ strptr ] ; for_end = poolptr -
1 ; if ( s <= for_end) do
{
dvibuf [ dviptr ] = strpool [ s ] ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
while ( s++ < for_end ) ; }
poolptr = strstart [ strptr ] ;
}
pageloc = dvioffset + dviptr ;
{
dvibuf [ dviptr ] = 139 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
{register integer for_end; k = 0 ; for_end = 9 ; if ( k <= for_end) do
zdvifour((integer)( eqtb [ 5317 + k ] .cint )) ;
while ( k++ < for_end ) ; }
zdvifour((integer)( lastbop )) ;
lastbop = pageloc ;
curv = mem [ p + 3 ] .cint + eqtb [ 5720 ] .cint ;
tempptr = p ;
if ( mem [ p ] .hh.u.B0 == 1 )
vlistout () ;
else hlistout () ;
{
dvibuf [ dviptr ] = 140 ;
++( dviptr ) ;
if ( dviptr == dvilimit )
dviswap () ;
}
++( totalpages ) ;
curs = -1 ;
lab30: ;
if ( eqtb [ 5301 ] .cint <= 0 )
zprintchar((ASCIIcode)( 93 )) ;
deadcycles = 0 ;
(void) fflush( (&_iob[1]) ) ;
;
if ( eqtb [ 5298 ] .cint > 1 )
{
zprintnl((strnumber)( 683 )) ;
zprintint((integer)( varused )) ;
zprintchar((ASCIIcode)( 38 )) ;
zprintint((integer)( dynused )) ;
zprintchar((ASCIIcode)( 59 )) ;
}
zflushnodelist((halfword)( p )) ;
;
if ( eqtb [ 5298 ] .cint > 1 )
{
zprint((integer)( 684 )) ;
zprintint((integer)( varused )) ;
zprintchar((ASCIIcode)( 38 )) ;
zprintint((integer)( dynused )) ;
zprint((integer)( 685 )) ;
zprintint((integer)( himemmin - lomemmax - 1 )) ;
println () ;
}
}
scanspec () {
if ( zscankeyword((strnumber)( 695 )) )
savestack [ saveptr + 0 ] .cint = 0 ;
else if ( zscankeyword((strnumber)( 696 )) )
savestack [ saveptr + 0 ] .cint = 1 ;
else {
savestack [ saveptr + 0 ] .cint = 1 ;
savestack [ saveptr + 1 ] .cint = 0 ;
goto lab40 ;
}
zscandimen((boolean)( 0 ),(boolean)( 0 ),(boolean)( 0 )) ;
savestack [ saveptr + 1 ] .cint = curval ;
lab40: saveptr = saveptr + 2 ;
scanleftbrace () ;
}
halfword zhpack ( p , w , m )
halfword p ;
scaled w ;
smallnumber m ;
{ register halfword Result; register memoryword *mem=(zzzaa - (int)(0 )) , *eqtb=zeqtb;
halfword r ;
halfword q ;
scaled h, d, x ;
scaled s ;
halfword g ;
glueord o ;
internalfontnumber f ;
fourquarters i ;
eightbits hd ;
integer b ;
r = zgetnode((integer)( 7 )) ;
mem [ r ] .hh.u.B0 = 0 ;
mem [ r ] .hh.u.B1 = 0 ;
mem [ r + 4 ] .cint = 0 ;
q = r + 5 ;
mem [ q ] .hh .v.RH = p ;
h = 0 ;
d = 0 ;
x = 0 ;
totalstretch [ 0 ] = 0 ;
totalshrink [ 0 ] = 0 ;
totalstretch [ 1 ] = 0 ;
totalshrink [ 1 ] = 0 ;
totalstretch [ 2 ] = 0 ;
totalshrink [ 2 ] = 0 ;
totalstretch [ 3 ] = 0 ;
totalshrink [ 3 ] = 0 ;
while ( p != 0 ) {
lab21: while ( ( p >= himemmin ) ) {
f = mem [ p ] .hh.u.B0 ;
i = fontinfo [ charbase [ f ] + mem [ p ] .hh.u.B1 ] .qqqq ;
hd = i .u.B1 ;
x = x + fontinfo [ widthbase [ f ] + i .u.B0 ] .cint ;
s = fontinfo [ heightbase [ f ] + ( hd ) / 16 ] .cint ;
if ( s > h )
h = s ;
s = fontinfo [ depthbase [ f ] + ( hd ) % 16 ] .cint ;
if ( s > d )
d = s ;
p = mem [ p ] .hh .v.RH ;
}
if ( p != 0 )
{
switch ( mem [ p ] .hh.u.B0 )
{case 0 :
case 1 :
case 2 :
case 13 :
{
x = x + mem [ p + 1 ] .cint ;
if ( mem [ p ] .hh.u.B0 >= 2 )
s = 0 ;
else s = mem [ p + 4 ] .cint ;
if ( mem [ p + 3 ] .cint - s > h )
h = mem [ p + 3 ] .cint - s ;
if ( mem [ p + 2 ] .cint + s > d )
d = mem [ p + 2 ] .cint + s ;
}
break ;
case 3 :
case 4 :
case 5 :
if ( adjusttail != 0 )
{
while ( mem [ q ] .hh .v.RH != p ) q = mem [ q ] .hh .v.RH ;
if ( mem [ p ] .hh.u.B0 == 5 )
{
mem [ adjusttail ] .hh .v.RH = mem [ p + 1 ] .cint ;
while ( mem [ adjusttail ] .hh .v.RH != 0 ) adjusttail = mem [
adjusttail ] .hh .v.RH ;
p = mem [ p ] .hh .v.RH ;
zfreenode((halfword)( mem [ q ] .hh .v.RH ),(halfword)( 2 )) ;
}
else {
mem [ adjusttail ] .hh .v.RH = p ;
adjusttail = p ;
p = mem [ p ] .hh .v.RH ;
}
mem [ q ] .hh .v.RH = p ;
p = q ;
}
break ;
case 8 :
;
break ;
case 10 :
{
g = mem [ p + 1 ] .hh .v.LH ;
x = x + mem [ g + 1 ] .cint ;
o = mem [ g ] .hh.u.B0 ;
totalstretch [ o ] = totalstretch [ o ] + mem [ g + 2 ] .cint ;
o = mem [ g ] .hh.u.B1 ;
totalshrink [ o ] = totalshrink [ o ] + mem [ g + 3 ] .cint ;
if ( mem [ p ] .hh.u.B1 >= 100 )
{
g = mem [ p + 1 ] .hh .v.RH ;
if ( mem [ g + 3 ] .cint > h )
h = mem [ g + 3 ] .cint ;
if ( mem [ g + 2 ] .cint > d )
d = mem [ g + 2 ] .cint ;
}
}
break ;
case 11 :
case 9 :
x = x + mem [ p + 1 ] .cint ;
break ;
case 6 :
{
mem [ 2999L - 12 ] = mem [ p + 1 ] ;
mem [ 2999L - 12 ] .hh .v.RH = mem [ p ] .hh .v.RH ;
p = 2999L - 12 ;
goto lab21 ;
}
break ;
default:
;
break ;
}
p = mem [ p ] .hh .v.RH ;
}
}
if ( adjusttail != 0 )
mem [ adjusttail ] .hh .v.RH = 0 ;
mem [ r + 3 ] .cint = h ;
mem [ r + 2 ] .cint = d ;
if ( m == 1 )
w = x + w ;
mem [ r + 1 ] .cint = w ;
x = w - x ;
if ( x == 0 )
{
mem [ r + 5 ] .hh.u.B0 = 0 ;
mem [ r + 5 ] .hh.u.B1 = 0 ;
mem [ r + 6 ] .gr = 0.0 ;
goto lab10 ;
}
else if ( x > 0 )
{
if ( totalstretch [ 3 ] != 0 )
o = 3 ;
else if ( totalstretch [ 2 ] != 0 )
o = 2 ;
else if ( totalstretch [ 1 ] != 0 )
o = 1 ;
else o = 0 ;
mem [ r + 5 ] .hh.u.B1 = o ;
mem [ r + 5 ] .hh.u.B0 = 1 ;
if ( totalstretch [ o ] != 0 )
mem [ r + 6 ] .gr = x / ((double) totalstretch [ o ] ) ;
else {
mem [ r + 5 ] .hh.u.B0 = 0 ;
mem [ r + 6 ] .gr = 0.0 ;
}
if ( ( eqtb [ 5293 ] .cint < 10000 ) && ( o == 0 ) && ( mem [ r + 5 ] .hh
.v.RH != 0 ) )
{
b = zbadness((scaled)( x ),(scaled)( totalstretch [ 0 ] )) ;
if ( b > eqtb [ 5293 ] .cint )
{
println () ;
if ( b > 100 )
zprintnl((strnumber)( 697 )) ;
else zprintnl((strnumber)( 698 )) ;
zprint((integer)( 699 )) ;
zprintint((integer)( b )) ;
goto lab50 ;
}
}
goto lab10 ;
}
else {
if ( totalshrink [ 3 ] != 0 )
o = 3 ;
else if ( totalshrink [ 2 ] != 0 )
o = 2 ;
else if ( totalshrink [ 1 ] != 0 )
o = 1 ;
else o = 0 ;
mem [ r + 5 ] .hh.u.B1 = o ;
mem [ r + 5 ] .hh.u.B0 = 2 ;
if ( totalshrink [ o ] != 0 )
mem [ r + 6 ] .gr = ( - (integer) x ) / ((double) totalshrink [ o ] ) ;
else {
mem [ r + 5 ] .hh.u.B0 = 0 ;
mem [ r + 6 ] .gr = 0.0 ;
}
if ( ( totalshrink [ o ] < - (integer) x ) && ( o == 0 ) && ( mem [ r + 5
] .hh .v.RH != 0 ) )
{
mem [ r + 6 ] .gr = 1.0 ;
if ( ( - (integer) x - totalshrink [ 0 ] > eqtb [ 5709 ] .cint ) || (
eqtb [ 5293 ] .cint < 100 ) )
{
if ( ( eqtb [ 5717 ] .cint > 0 ) && ( - (integer) x - totalshrink [ 0
] > eqtb [ 5709 ] .cint ) )
{
while ( mem [ q ] .hh .v.RH != 0 ) q = mem [ q ] .hh .v.RH ;
mem [ q ] .hh .v.RH = newrule () ;
mem [ mem [ q ] .hh .v.RH + 1 ] .cint = eqtb [ 5717 ] .cint ;
}
println () ;
zprintnl((strnumber)( 705 )) ;
zprintscaled((scaled)( - (integer) x - totalshrink [ 0 ] )) ;
zprint((integer)( 706 )) ;
goto lab50 ;
}
}
else if ( ( eqtb [ 5293 ] .cint < 100 ) && ( o == 0 ) && ( mem [ r + 5 ]
.hh .v.RH != 0 ) )
{
b = zbadness((scaled)( - (integer) x ),(scaled)( totalshrink [ 0 ] )) ;
if ( b > eqtb [ 5293 ] .cint )
{
println () ;
zprintnl((strnumber)( 707 )) ;
zprintint((integer)( b )) ;
goto lab50 ;
}
}
goto lab10 ;
}
lab50: if ( outputactive )
zprint((integer)( 700 )) ;
else {
if ( packbeginline != 0 )
{
if ( packbeginline > 0 )
zprint((integer)( 701 )) ;
else zprint((integer)( 702 )) ;
zprintint((integer)( (( packbeginline >=0)?( packbeginline ):(-( packbeginline ))) )) ;
zprint((integer)( 703 )) ;
}
else zprint((integer)( 704 )) ;
zprintint((integer)( line )) ;
}
println () ;
fontinshortdisplay = 0 ;
zshortdisplay((integer)( mem [ r + 5 ] .hh .v.RH )) ;
println () ;
begindiagnostic () ;
zshowbox((halfword)( r )) ;
zenddiagnostic((boolean)( 1 )) ;
lab10: Result = r ;
return(Result) ;
}
halfword zvpackage ( p , h , m , l )
halfword p ;
scaled h ;
smallnumber m ;
scaled l ;
{ register halfword Result; register memoryword *mem=(zzzaa - (int)(0 )) , *eqtb=zeqtb;
halfword r ;
scaled w, d, x ;
scaled s ;
halfword g ;
glueord o ;
integer b ;
r = zgetnode((integer)( 7 )) ;
mem [ r ] .hh.u.B0 = 1 ;
mem [ r ] .hh.u.B1 = 0 ;
mem [ r + 4 ] .cint = 0 ;
mem [ r + 5 ] .hh .v.RH = p ;
w = 0 ;
d = 0 ;
x = 0 ;
totalstretch [ 0 ] = 0 ;
totalshrink [ 0 ] = 0 ;
totalstretch [ 1 ] = 0 ;
totalshrink [ 1 ] = 0 ;
totalstretch [ 2 ] = 0 ;
totalshrink [ 2 ] = 0 ;
totalstretch [ 3 ] = 0 ;
totalshrink [ 3 ] = 0 ;
while ( p != 0 ) {
if ( ( p >= himemmin ) )
zconfusion((strnumber)( 708 )) ;
else switch ( mem [ p ] .hh.u.B0 )
{case 0 :
case 1 :
case 2 :
case 13 :
{
x = x + d + mem [ p + 3 ] .cint ;
d = mem [ p + 2 ] .cint ;
if ( mem [ p ] .hh.u.B0 >= 2 )
s = 0 ;
else s = mem [ p + 4 ] .cint ;
if ( mem [ p + 1 ] .cint + s > w )
w = mem [ p + 1 ] .cint + s ;
}
break ;
case 8 :
;
break ;
case 10 :
{
x = x + d ;
d = 0 ;
g = mem [ p + 1 ] .hh .v.LH ;
x = x + mem [ g + 1 ] .cint ;
o = mem [ g ] .hh.u.B0 ;
totalstretch [ o ] = totalstretch [ o ] + mem [ g + 2 ] .cint ;
o = mem [ g ] .hh.u.B1 ;
totalshrink [ o ] = totalshrink [ o ] + mem [ g + 3 ] .cint ;
if ( mem [ p ] .hh.u.B1 >= 100 )
{
g = mem [ p + 1 ] .hh .v.RH ;
if ( mem [ g + 1 ] .cint > w )
w = mem [ g + 1 ] .cint ;
}
}
break ;
case 11 :
{
x = x + d + mem [ p + 1 ] .cint ;
d = 0 ;
}
break ;
default:
;
break ;
}
p = mem [ p ] .hh .v.RH ;
}
mem [ r + 1 ] .cint = w ;
if ( d > l )
{
x = x + d - l ;
mem [ r + 2 ] .cint = l ;
}
else mem [ r + 2 ] .cint = d ;
if ( m == 1 )
h = x + h ;
mem [ r + 3 ] .cint = h ;
x = h - x ;
if ( x == 0 )
{
mem [ r + 5 ] .hh.u.B0 = 0 ;
mem [ r + 5 ] .hh.u.B1 = 0 ;
mem [ r + 6 ] .gr = 0.0 ;
goto lab10 ;
}
else if ( x > 0 )
{
if ( totalstretch [ 3 ] != 0 )
o = 3 ;
else if ( totalstretch [ 2 ] != 0 )
o = 2 ;
else if ( totalstretch [ 1 ] != 0 )
o = 1 ;
else o = 0 ;
mem [ r + 5 ] .hh.u.B1 = o ;
mem [ r + 5 ] .hh.u.B0 = 1 ;
if ( totalstretch [ o ] != 0 )
mem [ r + 6 ] .gr = x / ((double) totalstretch [ o ] ) ;
else {
mem [ r + 5 ] .hh.u.B0 = 0 ;
mem [ r + 6 ] .gr = 0.0 ;
}
if ( ( eqtb [ 5294 ] .cint < 10000 ) && ( o == 0 ) && ( mem [ r + 5 ] .hh
.v.RH != 0 ) )
{
b = zbadness((scaled)( x ),(scaled)( totalstretch [ 0 ] )) ;
if ( b > eqtb [ 5294 ] .cint )
{
println () ;
if ( b > 100 )
zprintnl((strnumber)( 697 )) ;
else zprintnl((strnumber)( 698 )) ;
zprint((integer)( 709 )) ;
zprintint((integer)( b )) ;
goto lab50 ;
}
}
goto lab10 ;
}
else {
if ( totalshrink [ 3 ] != 0 )
o = 3 ;
else if ( totalshrink [ 2 ] != 0 )
o = 2 ;
else if ( totalshrink [ 1 ] != 0 )
o = 1 ;
else o = 0 ;
mem [ r + 5 ] .hh.u.B1 = o ;
mem [ r + 5 ] .hh.u.B0 = 2 ;
if ( totalshrink [ o ] != 0 )
mem [ r + 6 ] .gr = ( - (integer) x ) / ((double) totalshrink [ o ] ) ;
else {
mem [ r + 5 ] .hh.u.B0 = 0 ;
mem [ r + 6 ] .gr = 0.0 ;
}
if ( ( totalshrink [ o ] < - (integer) x ) && ( o == 0 ) && ( mem [ r + 5
] .hh .v.RH != 0 ) )
{
mem [ r + 6 ] .gr = 1.0 ;
if ( ( - (integer) x - totalshrink [ 0 ] > eqtb [ 5710 ] .cint ) || (
eqtb [ 5294 ] .cint < 100 ) )
{
println () ;
zprintnl((strnumber)( 710 )) ;
zprintscaled((scaled)( - (integer) x - totalshrink [ 0 ] )) ;
zprint((integer)( 711 )) ;
goto lab50 ;
}
}
else if ( ( eqtb [ 5294 ] .cint < 100 ) && ( o == 0 ) && ( mem [ r + 5 ]
.hh .v.RH != 0 ) )
{
b = zbadness((scaled)( - (integer) x ),(scaled)( totalshrink [ 0 ] )) ;
if ( b > eqtb [ 5294 ] .cint )
{
println () ;
zprintnl((strnumber)( 712 )) ;
zprintint((integer)( b )) ;
goto lab50 ;
}
}
goto lab10 ;
}
lab50: if ( outputactive )
zprint((integer)( 700 )) ;
else {
if ( packbeginline != 0 )
{
zprint((integer)( 702 )) ;
zprintint((integer)( (( packbeginline >=0)?( packbeginline ):(-( packbeginline ))) )) ;
zprint((integer)( 703 )) ;
}
else zprint((integer)( 704 )) ;
zprintint((integer)( line )) ;
println () ;
}
begindiagnostic () ;
zshowbox((halfword)( r )) ;
zenddiagnostic((boolean)( 1 )) ;
lab10: Result = r ;
return(Result) ;
}
zappendtovlist ( b )
halfword b ;
{register memoryword *mem=(zzzaa - (int)(0 )) , *eqtb=zeqtb;
scaled d ;
halfword p ;
if ( curlist .auxfield > -65536000L )
{
d = mem [ eqtb [ 3527 ] .hh .v.RH + 1 ] .cint - curlist .auxfield - mem [
b + 3 ] .cint ;
if ( d < eqtb [ 5703 ] .cint )
p = znewparamglue((smallnumber)( 0 )) ;
else {
p = znewskipparam((smallnumber)( 1 )) ;
mem [ tempptr + 1 ] .cint = d ;
}
mem [ curlist .tailfield ] .hh .v.RH = p ;
curlist .tailfield = p ;
}
mem [ curlist .tailfield ] .hh .v.RH = b ;
curlist .tailfield = b ;
curlist .auxfield = mem [ b + 2 ] .cint ;
}
halfword newnoad () {
register halfword Result; register memoryword *mem=(zzzaa - (int)(0 )) ;
halfword p ;
p = zgetnode((integer)( 4 )) ;
mem [ p ] .hh.u.B0 = 16 ;
mem [ p ] .hh.u.B1 = 0 ;
mem [ p + 1 ] .hh = emptyfield ;
mem [ p + 3 ] .hh = emptyfield ;
mem [ p + 2 ] .hh = emptyfield ;
Result = p ;
return(Result) ;
}
halfword znewstyle ( s )
smallnumber s ;
{register halfword Result; register memoryword *mem=(zzzaa - (int)(0 )) ;
halfword p ;
p = zgetnode((integer)( 3 )) ;
mem [ p ] .hh.u.B0 = 14 ;
mem [ p ] .hh.u.B1 = s ;
mem [ p + 1 ] .cint = 0 ;
mem [ p + 2 ] .cint = 0 ;
Result = p ;
return(Result) ;
}
halfword newchoice () {
register halfword Result; register memoryword *mem=(zzzaa - (int)(0 )) ;
halfword p ;
p = zgetnode((integer)( 3 )) ;
mem [ p ] .hh.u.B0 = 15 ;
mem [ p ] .hh.u.B1 = 0 ;
mem [ p + 1 ] .hh .v.LH = 0 ;
mem [ p + 1 ] .hh .v.RH = 0 ;
mem [ p + 2 ] .hh .v.LH = 0 ;
mem [ p + 2 ] .hh .v.RH = 0 ;
Result = p ;
return(Result) ;
}
showinfo () {
register memoryword *mem=(zzzaa - (int)(0 )) ;
zshownodelist((integer)( mem [ tempptr ] .hh .v.LH )) ;
}
halfword zfractionrule ( t )
scaled t ;
{register halfword Result; register memoryword *mem=(zzzaa - (int)(0 )) ;
halfword p ;
p = newrule () ;
mem [ p + 3 ] .cint = t ;
mem [ p + 2 ] .cint = 0 ;
Result = p ;
return(Result) ;
}
halfword zoverbar ( b , k , t )
halfword b ;
scaled k , t ;
{register halfword Result; register memoryword *mem=(zzzaa - (int)(0 )) ;
halfword p, q ;
p = znewkern((scaled)( k )) ;
mem [ p ] .hh .v.RH = b ;
q = zfractionrule((scaled)( t )) ;
mem [ q ] .hh .v.RH = p ;
p = znewkern((scaled)( t )) ;
mem [ p ] .hh .v.RH = q ;
Result = zvpackage((halfword)( p ),(scaled)( 0 ),(smallnumber)( 1 ),(scaled)( 1073741823L )) ;
return(Result) ;
}
halfword zcharbox ( f , c )
internalfontnumber f ;
quarterword c ;
{register halfword Result; register memoryword *mem=(zzzaa - (int)(0 )) ;
fourquarters q ;
eightbits hd ;
halfword b, p ;
q = fontinfo [ charbase [ f ] + c ] .qqqq ;
hd = q .u.B1 ;
b = newnullbox () ;
mem [ b + 1 ] .cint = fontinfo [ widthbase [ f ] + q .u.B0 ] .cint + fontinfo
[ italicbase [ f ] + ( q .b2 ) / 4 ] .cint ;
mem [ b + 3 ] .cint = fontinfo [ heightbase [ f ] + ( hd ) / 16 ] .cint ;
mem [ b + 2 ] .cint = fontinfo [ depthbase [ f ] + ( hd ) % 16 ] .cint ;
p = getavail () ;
mem [ p ] .hh.u.B1 = c ;
mem [ p ] .hh.u.B0 = f ;
mem [ b + 5 ] .hh .v.RH = p ;
Result = b ;
return(Result) ;
}
zstackintobox ( b , f , c )
halfword b ;
internalfontnumber f ;
quarterword c ;
{register memoryword *mem=(zzzaa - (int)(0 )) ;
halfword p ;
p = zcharbox((internalfontnumber)( f ),(quarterword)( c )) ;
mem [ p ] .hh .v.RH = mem [ b + 5 ] .hh .v.RH ;
mem [ b + 5 ] .hh .v.RH = p ;
mem [ b + 3 ] .cint = mem [ p + 3 ] .cint ;
}
scaled zheightplusdepth ( f , c )
internalfontnumber f ;
quarterword c ;
{register scaled Result;
fourquarters q ;
eightbits hd ;
q = fontinfo [ charbase [ f ] + c ] .qqqq ;
hd = q .u.B1 ;
Result = fontinfo [ heightbase [ f ] + ( hd ) / 16 ] .cint + fontinfo [
depthbase [ f ] + ( hd ) % 16 ] .cint ;
return(Result) ;
}
halfword zvardelimiter ( d , s , v )
halfword d ;
smallnumber s ;
scaled v ;
{ register halfword Result; register memoryword *mem=(zzzaa - (int)(0 )) , *eqtb=zeqtb;
halfword b ;
internalfontnumber f, g ;
quarterword c, x, y ;
integer m, n ;
scaled u ;
scaled w ;
fourquarters q ;
eightbits hd ;
fourquarters r ;
smallnumber z ;
boolean largeattempt ;
f = 0 ;
w = 0 ;
largeattempt = 0 ;
z = mem [ d ] .qqqq .u.B0 ;
x = mem [ d ] .qqqq .u.B1 ;
while ( 1 ) {
if ( ( z != 0 ) || ( x != 0 ) )
{
z = z + s + 16 ;
do {
z = z - 16 ;
g = eqtb [ 4579 + z ] .hh .v.RH ;
if ( g != 0 )
{
y = x ;
lab22: if ( ( y >= fontbc [ g ] ) && ( y <= fontec [ g ] ) )
{
q = fontinfo [ charbase [ g ] + y ] .qqqq ;
if ( ( q .u.B0 > 0 ) )
{
if ( ( ( q .b2 ) % 4 ) == 3 )
{
f = g ;
c = y ;
goto lab40 ;
}
hd = q .u.B1 ;
u = fontinfo [ heightbase [ g ] + ( hd ) / 16 ] .cint + fontinfo
[ depthbase [ g ] + ( hd ) % 16 ] .cint ;
if ( u > w )
{
f = g ;
c = y ;
w = u ;
if ( u >= v )
goto lab40 ;
}
if ( ( ( q .b2 ) % 4 ) == 2 )
{
y = q .b3 ;
goto lab22 ;
}
}
}
}
} while ( ! ( z < 16 ) ) ;
}
if ( largeattempt )
goto lab40 ;
largeattempt = 1 ;
z = mem [ d ] .qqqq .b2 ;
x = mem [ d ] .qqqq .b3 ;
}
lab40: if ( f != 0 )
if ( ( ( q .b2 ) % 4 ) == 3 )
{
b = newnullbox () ;
mem [ b ] .hh.u.B0 = 1 ;
r = fontinfo [ extenbase [ f ] + q .b3 ] .qqqq ;
c = r .b3 ;
u = zheightplusdepth((internalfontnumber)( f ),(quarterword)( c )) ;
w = 0 ;
q = fontinfo [ charbase [ f ] + c ] .qqqq ;
mem [ b + 1 ] .cint = fontinfo [ widthbase [ f ] + q .u.B0 ] .cint +
fontinfo [ italicbase [ f ] + ( q .b2 ) / 4 ] .cint ;
c = r .b2 ;
if ( c != 0 )
w = w + zheightplusdepth((internalfontnumber)( f ),(quarterword)( c )) ;
c = r .u.B1 ;
if ( c != 0 )
w = w + zheightplusdepth((internalfontnumber)( f ),(quarterword)( c )) ;
c = r .u.B0 ;
if ( c != 0 )
w = w + zheightplusdepth((internalfontnumber)( f ),(quarterword)( c )) ;
n = 0 ;
if ( u > 0 )
while ( w < v ) {
w = w + u ;
++( n ) ;
if ( r .u.B1 != 0 )
w = w + u ;
}
c = r .b2 ;
if ( c != 0 )
zstackintobox((halfword)( b ),(internalfontnumber)( f ),(quarterword)( c )) ;
c = r .b3 ;
{register integer for_end; m = 1 ; for_end = n ; if ( m <= for_end) do
zstackintobox((halfword)( b ),(internalfontnumber)( f ),(quarterword)( c )) ;
while ( m++ < for_end ) ; }
c = r .u.B1 ;
if ( c != 0 )
{
zstackintobox((halfword)( b ),(internalfontnumber)( f ),(quarterword)( c )) ;
c = r .b3 ;
{register integer for_end; m = 1 ; for_end = n ; if ( m <= for_end) do
zstackintobox((halfword)( b ),(internalfontnumber)( f ),(quarterword)( c )) ;
while ( m++ < for_end ) ; }
}
c = r .u.B0 ;
if ( c != 0 )
zstackintobox((halfword)( b ),(internalfontnumber)( f ),(quarterword)( c )) ;
mem [ b + 2 ] .cint = w - mem [ b + 3 ] .cint ;
}
else b = zcharbox((internalfontnumber)( f ),(quarterword)( c )) ;
else {
b = newnullbox () ;
mem [ b + 1 ] .cint = eqtb [ 5712 ] .cint ;
}
mem [ b + 4 ] .cint = zhalf((integer)( mem [ b + 3 ] .cint - mem [ b + 2 ] .cint )) -
fontinfo [ 22 + parambase [ eqtb [ 4581 + s ] .hh .v.RH ] ] .cint ;
Result = b ;
return(Result) ;
}
halfword zrebox ( b , w )
halfword b ;
scaled w ;
{register halfword Result; register memoryword *mem=(zzzaa - (int)(0 )) ;
halfword p ;
internalfontnumber f ;
scaled v ;
if ( ( mem [ b + 1 ] .cint != w ) && ( mem [ b + 5 ] .hh .v.RH != 0 ) )
{
if ( mem [ b ] .hh.u.B0 == 1 )
b = zhpack((halfword)( b ),(scaled)( 0 ),(smallnumber)( 1 )) ;
p = mem [ b + 5 ] .hh .v.RH ;
if ( ( ( p >= himemmin ) ) && ( mem [ p ] .hh .v.RH == 0 ) )
{
f = mem [ p ] .hh.u.B0 ;
v = fontinfo [ widthbase [ f ] + fontinfo [ charbase [ f ] + mem [ p ]
.hh.u.B1 ] .qqqq .u.B0 ] .cint ;
if ( v != mem [ b + 1 ] .cint )
mem [ p ] .hh .v.RH = znewkern((scaled)( mem [ b + 1 ] .cint - v )) ;
}
zfreenode((halfword)( b ),(halfword)( 7 )) ;
b = znewglue((halfword)( 12 )) ;
mem [ b ] .hh .v.RH = p ;
while ( mem [ p ] .hh .v.RH != 0 ) p = mem [ p ] .hh .v.RH ;
mem [ p ] .hh .v.RH = znewglue((halfword)( 12 )) ;
Result = zhpack((halfword)( b ),(scaled)( w ),(smallnumber)( 0 )) ;
}
else {
mem [ b + 1 ] .cint = w ;
Result = b ;
}
return(Result) ;
}
halfword zmathglue ( g , m )
halfword g ;
scaled m ;
{register halfword Result; register memoryword *mem=(zzzaa - (int)(0 )) ;
halfword p ;
integer n ;
scaled f ;
n = zxovern((scaled)( m ),(integer)( 65536L )) ;
f = remainder ;
p = zgetnode((integer)( 4 )) ;
mem [ p + 1 ] .cint = znxplusy((integer)( n ),(scaled)( mem [ g + 1 ] .cint ),(scaled)( zxnoverd((scaled)( mem [ g
+ 1 ] .cint ),(integer)( f ),(integer)( 65536L )) )) ;
mem [ p ] .hh.u.B0 = mem [ g ] .hh.u.B0 ;
if ( mem [ p ] .hh.u.B0 == 0 )
mem [ p + 2 ] .cint = znxplusy((integer)( n ),(scaled)( mem [ g + 2 ] .cint ),(scaled)( zxnoverd((scaled)( mem [ g
+ 2 ] .cint ),(integer)( f ),(integer)( 65536L )) )) ;
else mem [ p + 2 ] .cint = mem [ g + 2 ] .cint ;
mem [ p ] .hh.u.B1 = mem [ g ] .hh.u.B1 ;
if ( mem [ p ] .hh.u.B1 == 0 )
mem [ p + 3 ] .cint = znxplusy((integer)( n ),(scaled)( mem [ g + 3 ] .cint ),(scaled)( zxnoverd((scaled)( mem [ g
+ 3 ] .cint ),(integer)( f ),(integer)( 65536L )) )) ;
else mem [ p + 3 ] .cint = mem [ g + 3 ] .cint ;
Result = p ;
return(Result) ;
}