;Alto->8086 small-c compiler rev 2.0
C_CODE SEGMENT

$INCLUDE(8086LIB.D)

$INCLUDE(alloc.DEC)

ASSUME CS:C_CODE, DS:C_DATA

; #include	"alloc.h"

; extern int end;	/* See endml.asm; end of static storage */

; extern Zero();

; extern Usc();

; extern CallSwat();

; extern UMax();

; extern ReturnLoc();

; extern MyFrame();

; struct ZN *GetAll() {
_GetAll:
PUSH BP
MOV BP,SP

;   char *z;

;   int len;

;   struct ZN *zn;
ADD SP,0FFFAX

;   z = (char *) (((int) &end+1)&(-2));
LEA BX,_end
INC BX
AND BX,0FFFEX

;	_z _ BX
MOV [BP-2],BX

;   len = zoneTop - ((int) z);

;	BX _ _z
MOV BX,[BP-2]
MOV CX,0CFFEX
SUB CX,BX

;	_len _ CX
MOV [BP-4],CX

;   if (Usc(len, 0x7FFF) > 0) {
MOV BX,07FFFX

;	CX _ _len
MOV CX,[BP-4]
CALL _Usc
CMP BX,0
JLE X1

; 	zn = InitializeZone(z, 0x3FF0);
MOV BX,03FF0X

;	CX _ _z
MOV CX,[BP-2]
CALL _InitializeZone

;	_zn _ BX
POP DX
PUSH BX

; 	AddToZone(zn, z+0x7FF0, (len-0x7FF0)>>1);

;	BX _ _zn
POP BX
PUSH BX
PUSH BX

;	BX _ _z
MOV BX,[BP-2]
ADD BX,07FF0X

;	CX _ _len
MOV CX,[BP-4]
ADD CX,08010X
SHR CX
XCHG BX,CX
CALL _AddToZone
POP DX

;         };

;   else zn = InitializeZone(z, len>>1);
JR X2
X1:

;	BX _ _len
MOV BX,[BP-4]
SHR BX

;	CX _ _z
MOV CX,[BP-2]
CALL _InitializeZone

;	_zn _ BX
POP DX
PUSH BX
X2:

;   return(zn);

;	BX _ _zn
POP BX
PUSH BX
MOV SP,BP
POP BP
RET;

;   };

; struct ZN *InitializeZone(z, len)
_InitializeZone:

;   struct ZN *z;		/* first available address */

;   int len;		/* length in words */
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   struct SB *firstfree;

;   struct ZN *tempznp;
ADD SP,0FFFCX

;   z->anchor.length = 0;

;	BX _ _z
MOV BX,[BP-2]
MOV WORD PTR [BX],0

;   z->anchor.pSbPrevious = z->anchor.pSbNext = &z->anchor;

;	BX _ _z
MOV BX,[BP-2]

;	CX _ _z
MOV CX,[BP-2]
XCHG BX,CX

;	AX _ _z
MOV AX,[BP-2]
MOV [BX+4],AX
MOV BX,CX
MOV [BX+6],AX

;   tempznp = z+1;  /* first address after header */

;	BX _ _z
MOV BX,[BP-2]
ADD BX,0EX

;	_tempznp _ BX
POP DX
PUSH BX

;   firstfree = (struct SB *) tempznp;

;	BX _ _tempznp
POP BX
PUSH BX

;	_firstfree _ BX
MOV [BP-6],BX

;   z->rover = firstfree;

;	BX _ _z
MOV BX,[BP-2]

;	CX _ _firstfree
MOV CX,[BP-6]
MOV [BX+8],CX

;   z->minAdr = (int *) firstfree;

;	BX _ _z
MOV BX,[BP-2]

;	CX _ _firstfree
MOV CX,[BP-6]
MOV [BX+10],CX

;   z->maxAdr = (int *) firstfree;

;	BX _ _z
MOV BX,[BP-2]

;	CX _ _firstfree
MOV CX,[BP-6]
MOV [BX+12],CX

;   AddToZone(z, firstfree, len-(lZn>>1));

;	BX _ _z
MOV BX,[BP-2]
PUSH BX

;	BX _ _len
MOV BX,[BP-4]
ADD BX,0FFF9X

;	CX _ _firstfree
MOV CX,[BP-6]
CALL _AddToZone
POP DX

;   return(z);

;	BX _ _z
MOV BX,[BP-2]
MOV SP,BP
POP BP
RET;

;   };

; AddToZone(z, s, len)
_AddToZone:

;   struct ZN *z;		/* zone itself */

;   struct SB *s;		/* first available address */

;   int len;		/* available length */
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int lSbFree, *sbLast;

;   char *cp;
ADD SP,0FFFAX

;   len = len << 1;

;	BX _ _len
MOV BX,[BP-4]
SAL BX

;	_len _ BX
MOV [BP-4],BX

;   lSbFree = len-lSbOverhead;

;	BX _ _len
MOV BX,[BP-4]
ADD BX,0FFFCX

;	_lSbFree _ BX
MOV [BP-6],BX

;   if ((lSbFree < minLSbFree) || (Usc(len, 077774) > 0)) CallSwat(ecAllocate+ 1);

;	BX _ _lSbFree
MOV BX,[BP-6]
CMP BX,8
JL X5
MOV BX,07FFCX

;	CX _ _len
MOV CX,[BP-4]
CALL _Usc
CMP BX,0
JLE X4
X5:
MOV AL,1
JR X6
X4:
XOR AL,AL
X6:
OR AL,AL
JZ X3
MOV BX,01001X
CALL _CallSwat
X3:

;   cp = (char *) s;

;	BX _ _s
MOV BX,[BP-2]

;	_cp _ BX
POP DX
PUSH BX

;   cp = cp+lSbFree;

;	BX _ _lSbFree
MOV BX,[BP-6]

;	CX _ _cp
POP CX
ADD BX,CX

;	_cp _ BX
PUSH BX

;   sbLast = (int *) cp; /* address of the -1 */

;	BX _ _cp
POP BX
PUSH BX

;	_sbLast _ BX
MOV [BP-8],BX

;   *sbLast = -1;	/* last word of free space */

;	BX _ _sbLast
MOV BX,[BP-8]
MOV WORD PTR [BX],0FFFFX

;   {

;   int *min, *max, ti, tib;
ADD SP,0FFF8X

;   min = z->minAdr;

;	BX _ _z
MOV BX,[BP+4]
MOV CX,[BX+10]

;	_min _ CX
MOV [BP-12],CX

;   if (Usc(s, min) < 0) {

;	BX _ _min
MOV BX,[BP-12]

;	CX _ _s
MOV CX,[BP-2]
CALL _Usc
CMP BX,0
JGE X7

;     if (Usc(sbLast, min) >= 0) CallSwat(ecAllocate+2);

;	BX _ _min
MOV BX,[BP-12]

;	CX _ _sbLast
MOV CX,[BP-8]
CALL _Usc
CMP BX,0
JL X8
MOV BX,01002X
CALL _CallSwat
X8:

;     ti = (int) sbLast;

;	BX _ _sbLast
MOV BX,[BP-8]

;	_ti _ BX
MOV [BP-16],BX

;     tib = (int) min;

;	BX _ _min
MOV BX,[BP-12]

;	_tib _ BX
POP DX
PUSH BX

;     ti = ti - tib;

;	BX _ _tib
POP BX
PUSH BX

;	CX _ _ti
MOV CX,[BP-16]
SUB CX,BX

;	_ti _ CX
MOV [BP-16],CX

;     *sbLast = ti;

;	BX _ _sbLast
MOV BX,[BP-8]

;	CX _ _ti
MOV CX,[BP-16]
MOV [BX],CX

;     z->minAdr = (int *) s;

;	BX _ _z
MOV BX,[BP+4]

;	CX _ _s
MOV CX,[BP-2]
MOV [BX+10],CX

;     };

;   else {
JR X9
X7:

;     max = z->maxAdr;

;	BX _ _z
MOV BX,[BP+4]
MOV CX,[BX+12]

;	_max _ CX
MOV [BP-14],CX

;     if (Usc(s, max) < 0) CallSwat(ecAllocate+3);

;	BX _ _max
MOV BX,[BP-14]

;	CX _ _s
MOV CX,[BP-2]
CALL _Usc
CMP BX,0
JGE X10
MOV BX,01003X
CALL _CallSwat
X10:

;     ti = (int) max;

;	BX _ _max
MOV BX,[BP-14]

;	_ti _ BX
MOV [BP-16],BX

;     tib = (int) s;

;	BX _ _s
MOV BX,[BP-2]

;	_tib _ BX
POP DX
PUSH BX

;     ti = ti - tib;

;	BX _ _tib
POP BX
PUSH BX

;	CX _ _ti
MOV CX,[BP-16]
SUB CX,BX

;	_ti _ CX
MOV [BP-16],CX

;     *max = ti;

;	BX _ _max
MOV BX,[BP-14]

;	CX _ _ti
MOV CX,[BP-16]
MOV [BX],CX

;     z->maxAdr = (int *) sbLast;

;	BX _ _z
MOV BX,[BP+4]

;	CX _ _sbLast
MOV CX,[BP-8]
MOV [BX+12],CX

;     };
X9:

;   };
ADD SP,8

;   s->length = -lSbFree;

;	BX _ _lSbFree
MOV BX,[BP-6]
NEG BX
MOV CX,BX

;	BX _ _s
MOV BX,[BP-2]
MOV [BX],CX

;   Free(z, &s->data);

;	BX _ _s
MOV BX,[BP-2]
ADD BX,4

;	CX _ _z
MOV CX,[BP+4]
CALL _Free

;   };
MOV SP,BP
POP BP
RET;

; extern int largest

; extern int totAv;

; #asm

;***  illegal symbol name ***

; #asm



_Allocate:


; int *Alloc(z, numWords)
_Alloc:

;   struct ZN *z;

;   int numWords;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int lSbData, ia, ib, lSb, extra, siz, zeroRqst;

;   struct SB *s, *sbRover, *sbOriginalRover, *sbNext;
ADD SP,0FFEAX

;   largest = totAv = zeroRqst = 0;
MOV WORD PTR [BP-18],0
MOV _totAv,0
MOV _largest,0

;   if (numWords<0 && numWords>=-2000) { numWords = -numWords; zeroRqst=-1; };

;	BX _ _numWords
MOV BX,[BP-4]
CMP BX,0
JGE X12

;	BX _ _numWords
MOV BX,[BP-4]
CMP BX,0F830X
JL X12
MOV AL,1
JR X13
X12:
XOR AL,AL
X13:
OR AL,AL
JZ X11

;	BX _ _numWords
MOV BX,[BP-4]
NEG BX

;	_numWords _ BX
MOV [BP-4],BX
MOV WORD PTR [BP-18],0FFFFX
X11:

;   lSbData = numWords << 1;

;	BX _ _numWords
MOV BX,[BP-4]
SAL BX

;	_lSbData _ BX
MOV [BP-6],BX

;   if (numWords==0) lSbData = 0xFFF0; /* Testing largest avail. */

;	BX _ _numWords
MOV BX,[BP-4]
OR BX,BX
JNZ X14
MOV WORD PTR [BP-6],0FFF0X
X14:

;   lSb = UMax(lSbData + lSbOverhead, minLSbFree)

;	BX _ _lSbData
MOV BX,[BP-6]
ADD BX,4
PUSH BX
MOV BX,8
POP CX
CALL _UMax

;	_lSb _ BX
MOV [BP-12],BX

;   sbOriginalRover = sbRover = z->rover;

;	BX _ _z
MOV BX,[BP-2]
MOV CX,[BX+8]

;	_sbRover _ CX
MOV [BP-22],CX

;	_sbOriginalRover _ CX
MOV [BP-24],CX

;   for (;;)  {
X15:

;   for (;;) {
X17:

;     ia = (int) sbRover;

;	BX _ _sbRover
MOV BX,[BP-22]

;	_ia _ BX
MOV [BP-8],BX

;     ia = ia + sbRover->length; 

;	DI _ _sbRover
MOV DI,[BP-22]
MOV BX,[DI]

;	CX _ _ia
MOV CX,[BP-8]
ADD CX,BX

;	_ia _ CX
MOV [BP-8],CX

;     sbNext = (struct SB *) ia;

;	BX _ _ia
MOV BX,[BP-8]

;	_sbNext _ BX
POP DX
PUSH BX

;     if (sbNext->length <= 0) break;

;	DI _ _sbNext
POP DI
PUSH DI
MOV BX,[DI]
CMP BX,0
JG X19
JR X18
X19:

;     if (sbNext == sbOriginalRover) sbOriginalRover = sbNext->pSbNext;

;	BX _ _sbOriginalRover
MOV BX,[BP-24]

;	CX _ _sbNext
POP CX
PUSH CX
CMP CX,BX
JNZ X20

;	BX _ _sbNext
POP BX
PUSH BX
MOV CX,[BX+4]

;	_sbOriginalRover _ CX
MOV [BP-24],CX
X20:

;     sbNext->pSbNext->pSbPrevious = sbNext->pSbPrevious;

;	BX _ _sbNext
POP BX
PUSH BX
MOV CX,[BX+4]

;	BX _ _sbNext
POP BX
PUSH BX
MOV AX,[BX+6]
MOV BX,CX
MOV [BX+6],AX

;     sbNext->pSbPrevious->pSbNext = sbNext->pSbNext;

;	BX _ _sbNext
POP BX
PUSH BX
MOV CX,[BX+6]

;	BX _ _sbNext
POP BX
PUSH BX
MOV AX,[BX+4]
MOV BX,CX
MOV [BX+4],AX

;     sbRover->length += sbNext->length;

;	BX _ _sbRover
MOV BX,[BP-22]

;	DI _ _sbNext
POP DI
PUSH DI
MOV CX,[DI]
ADD [BX],CX

;     };
JR X17
X18:

;   ia = (int) sbNext;

;	BX _ _sbNext
POP BX
PUSH BX

;	_ia _ BX
MOV [BP-8],BX

;   ia = ia - lSb;

;	BX _ _lSb
MOV BX,[BP-12]

;	CX _ _ia
MOV CX,[BP-8]
SUB CX,BX

;	_ia _ CX
MOV [BP-8],CX

;   s = (struct SB *) ia;

;	BX _ _ia
MOV BX,[BP-8]

;	_s _ BX
MOV [BP-20],BX

;   ib = (int) sbRover;

;	BX _ _sbRover
MOV BX,[BP-22]

;	_ib _ BX
MOV [BP-10],BX

;   extra = ia - ib;

;	BX _ _ib
MOV BX,[BP-10]

;	CX _ _ia
MOV CX,[BP-8]
SUB CX,BX

;	_extra _ CX
MOV [BP-14],CX

;   ia = (int) sbNext;

;	BX _ _sbNext
POP BX
PUSH BX

;	_ia _ BX
MOV [BP-8],BX

;   siz = ia - ib; /* (int *) sbNext - (int *) sbRover */

;	BX _ _ib
MOV BX,[BP-10]

;	CX _ _ia
MOV CX,[BP-8]
SUB CX,BX

;	_siz _ CX
MOV [BP-16],CX

;   largest = UMax(siz, largest);
MOV BX,_largest

;	CX _ _siz
MOV CX,[BP-16]
CALL _UMax
MOV _largest,BX

;   totAv += siz;

;	BX _ _siz
MOV BX,[BP-16]
ADD _totAv,BX

;   if ((extra < 0) || (lSb < 0)) {

;	BX _ _extra
MOV BX,[BP-14]
CMP BX,0
JL X23

;	BX _ _lSb
MOV BX,[BP-12]
CMP BX,0
X23:
X22:
JGE X21

;     sbRover = sbRover->pSbNext;

;	BX _ _sbRover
MOV BX,[BP-22]
MOV CX,[BX+4]

;	_sbRover _ CX
MOV [BP-22],CX

;     if (sbRover == sbOriginalRover) break;

;	BX _ _sbOriginalRover
MOV BX,[BP-24]

;	CX _ _sbRover
MOV CX,[BP-22]
CMP CX,BX
JNZ X24
JR X16
X24:

;     continue;
JMP X15

;     };
X21:

;   if (extra >= minLSbFree) {

;	BX _ _extra
MOV BX,[BP-14]
CMP BX,8
JL X25

;     sbRover->length = extra;

;	BX _ _sbRover
MOV BX,[BP-22]

;	CX _ _extra
MOV CX,[BP-14]
MOV [BX],CX

;     z->rover = sbRover;

;	BX _ _z
MOV BX,[BP-2]

;	CX _ _sbRover
MOV CX,[BP-22]
MOV [BX+8],CX

;     s->length = -lSb;

;	BX _ _lSb
MOV BX,[BP-12]
NEG BX
MOV CX,BX

;	BX _ _s
MOV BX,[BP-20]
MOV [BX],CX

;     };

;   else {
JR X26
X25:

;     sbRover->pSbNext->pSbPrevious = sbRover->pSbPrevious;

;	BX _ _sbRover
MOV BX,[BP-22]
MOV CX,[BX+4]

;	BX _ _sbRover
MOV BX,[BP-22]
MOV AX,[BX+6]
MOV BX,CX
MOV [BX+6],AX

;     sbRover->pSbPrevious->pSbNext = sbRover->pSbNext;

;	BX _ _sbRover
MOV BX,[BP-22]
MOV CX,[BX+6]

;	BX _ _sbRover
MOV BX,[BP-22]
MOV AX,[BX+4]
MOV BX,CX
MOV [BX+4],AX

;     z->rover = sbRover->pSbNext;

;	BX _ _z
MOV BX,[BP-2]

;	CX _ _sbRover
MOV CX,[BP-22]
MOV DI,CX
MOV CX,[DI+4]
MOV [BX+8],CX

;     s = sbRover;

;	BX _ _sbRover
MOV BX,[BP-22]

;	_s _ BX
MOV [BP-20],BX

;     s->length = (-s->length);

;	DI _ _s
MOV DI,[BP-20]
MOV BX,[DI]
NEG BX
MOV CX,BX

;	BX _ _s
MOV BX,[BP-20]
MOV [BX],CX

;     };
X26:

;   s->user = ReturnLoc(MyFrame());   /* survey of callers of Alloc */

;	BX _ _s
MOV BX,[BP-20]
JR $+5
X16:
JMP X27
PUSH BX
CALL _MyFrame
CALL _ReturnLoc
MOV CX,BX
POP BX
MOV [BX+2],CX

;   ia = ((int) s) + offsetSbData;

;	BX _ _s
MOV BX,[BP-20]
ADD BX,4

;	_ia _ BX
MOV [BP-8],BX

;   Zero(ia, numWords);

;	BX _ _numWords
MOV BX,[BP-4]

;	CX _ _ia
MOV CX,[BP-8]
CALL _Zero

;   return (ia);

;	BX _ _ia
MOV BX,[BP-8]
MOV SP,BP
POP BP
RET;

;   }; /* didn't work:  while (sbRover != sbOriginalRover); */
X27:

;   z->rover = sbRover;

;	BX _ _z
MOV BX,[BP-2]

;	CX _ _sbRover
MOV CX,[BP-22]
MOV [BX+8],CX

;   if (numWords!=0) CallSwat(ecAllocate+5);

;	BX _ _numWords
MOV BX,[BP-4]
OR BX,BX
JZ X28
MOV BX,01005X
CALL _CallSwat
X28:

;   return 0;
XOR BX,BX
MOV SP,BP
POP BP
RET;

;   };

; Free(z, s)
_Free:

;   struct ZN *z;

;   int *s;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   struct SB *sbp, *sbAnchor, *sbT;

;   int ia;

;   if (s==0) return; /* God damn it! */
ADD SP,0FFF8X

;	BX _ _s
MOV BX,[BP-4]
OR BX,BX
JNZ X29
MOV SP,BP
POP BP
RET;
X29:

;   ia = (int) s;

;	BX _ _s
MOV BX,[BP-4]

;	_ia _ BX
POP DX
PUSH BX

;   ia = ia-offsetSbData;

;	BX _ _ia
POP BX
ADD BX,0FFFCX

;	_ia _ BX
PUSH BX

;   sbp = (struct SB *) ia;

;	BX _ _ia
POP BX
PUSH BX

;	_sbp _ BX
MOV [BP-6],BX

;   if (sbp->length >= 0) CallSwat(ecAllocate+6);

;	DI _ _sbp
MOV DI,[BP-6]
MOV BX,[DI]
CMP BX,0
JL X30
MOV BX,01006X
CALL _CallSwat
X30:

;   sbAnchor = &z->anchor;

;	BX _ _z
MOV BX,[BP-2]

;	_sbAnchor _ BX
MOV [BP-8],BX

;   CheckZone(z, 0);
XOR BX,BX

;	CX _ _z
MOV CX,[BP-2]
CALL _CheckZone

;   sbp->length = -sbp->length;

;	DI _ _sbp
MOV DI,[BP-6]
MOV BX,[DI]
NEG BX
MOV CX,BX

;	BX _ _sbp
MOV BX,[BP-6]
MOV [BX],CX

;   CheckBounds(z, sbp);

;	BX _ _sbp
MOV BX,[BP-6]

;	CX _ _z
MOV CX,[BP-2]
CALL _CheckBounds

;   CheckFreeNode(z, sbAnchor);

;	BX _ _sbAnchor
MOV BX,[BP-8]

;	CX _ _z
MOV CX,[BP-2]
CALL _CheckFreeNode

;   sbT = sbAnchor->pSbNext;

;	BX _ _sbAnchor
MOV BX,[BP-8]
MOV CX,[BX+4]

;	_sbT _ CX
MOV [BP-10],CX

;   sbp->pSbPrevious = sbAnchor;

;	BX _ _sbp
MOV BX,[BP-6]

;	CX _ _sbAnchor
MOV CX,[BP-8]
MOV [BX+6],CX

;   sbp->pSbNext = sbT;

;	BX _ _sbp
MOV BX,[BP-6]

;	CX _ _sbT
MOV CX,[BP-10]
MOV [BX+4],CX

;   sbAnchor->pSbNext = sbp;

;	BX _ _sbAnchor
MOV BX,[BP-8]

;	CX _ _sbp
MOV CX,[BP-6]
MOV [BX+4],CX

;   sbT->pSbPrevious = sbp;

;	BX _ _sbT
MOV BX,[BP-10]

;	CX _ _sbp
MOV CX,[BP-6]
MOV [BX+6],CX

;   };
MOV SP,BP
POP BP
RET;

; CheckZone(z, p)
_CheckZone:

;   struct ZN *z;

;   int p;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int freecount, addit, ia, cnt;

;   struct SB *s, *sbAnchor;

;   if (*z->maxAdr != -1) CallSwat(ecAllocate+7);
ADD SP,0FFF4X

;	BX _ _z
MOV BX,[BP-2]
MOV CX,[BX+12]
MOV DI,CX
MOV BX,[DI]
CMP BX,0FFFFX
JZ X31
MOV BX,01007X
CALL _CallSwat
X31:

;   freecount = 0;
MOV WORD PTR [BP-6],0

;   ia = (int) z->minAdr;

;	BX _ _z
MOV BX,[BP-2]
MOV CX,[BX+10]

;	_ia _ CX
MOV [BP-10],CX

;   s = (struct SB *) ia;

;	BX _ _ia
MOV BX,[BP-10]

;	_s _ BX
MOV [BP-14],BX

;   for (;;) {
X32:

;     if (Usc(z->maxAdr, s) <= 0) break;

;	BX _ _z
MOV BX,[BP-2]
MOV CX,[BX+12]

;	BX _ _s
MOV BX,[BP-14]
CALL _Usc
CMP BX,0
JG X34
JR X33
X34:

;     addit = s->length;

;	DI _ _s
MOV DI,[BP-14]
MOV BX,[DI]

;	_addit _ BX
MOV [BP-8],BX

;     if (addit >= 0) {

;	BX _ _addit
MOV BX,[BP-8]
CMP BX,0
JL X35

;       CheckFreeNode(z, s);

;	BX _ _s
MOV BX,[BP-14]

;	CX _ _z
MOV CX,[BP-2]
CALL _CheckFreeNode

;       freecount += 1;
INC WORD PTR [BP-6]

;       };

;     else {
JR X36
X35:

;       addit = (-addit);

;	BX _ _addit
MOV BX,[BP-8]
NEG BX

;	_addit _ BX
MOV [BP-8],BX

;       };
X36:

;     ia = ia+addit;

;	BX _ _addit
MOV BX,[BP-8]

;	CX _ _ia
MOV CX,[BP-10]
ADD CX,BX

;	_ia _ CX
MOV [BP-10],CX

;     if (Usc(ia, s) <= 0) CallSwat(ecAllocate+8);

;	BX _ _s
MOV BX,[BP-14]

;	CX _ _ia
MOV CX,[BP-10]
CALL _Usc
CMP BX,0
JG X37
MOV BX,01008X
CALL _CallSwat
X37:

;     s = (struct SB *) ia;

;	BX _ _ia
MOV BX,[BP-10]

;	_s _ BX
MOV [BP-14],BX

;     };
JR X32
X33:

;   if (((int *) s) != z->maxAdr) CallSwat(ecAllocate+9);

;	BX _ _z
MOV BX,[BP-2]
MOV CX,[BX+12]

;	BX _ _s
MOV BX,[BP-14]
CMP BX,CX
JZ X38
MOV BX,01009X
CALL _CallSwat
X38:

;   cnt = -22000;
MOV WORD PTR [BP-12],0AA10X

;   sbAnchor = &z->anchor;

;	BX _ _z
MOV BX,[BP-2]

;	_sbAnchor _ BX
POP DX
PUSH BX

;   s = sbAnchor->pSbNext;

;	BX _ _sbAnchor
POP BX
PUSH BX
MOV CX,[BX+4]

;	_s _ CX
MOV [BP-14],CX

;   for (;;) {
X39:

;     if (s == sbAnchor) break;

;	BX _ _sbAnchor
POP BX
PUSH BX

;	CX _ _s
MOV CX,[BP-14]
CMP CX,BX
JNZ X41
JR X40
X41:

;     CheckFreeNode(z, s);

;	BX _ _s
MOV BX,[BP-14]

;	CX _ _z
MOV CX,[BP-2]
CALL _CheckFreeNode

;     freecount -= 1;
DEC WORD PTR [BP-6]

;     cnt -= 1;
DEC WORD PTR [BP-12]

;     if (cnt == 0) CallSwat(ecAllocate+10);

;	BX _ _cnt
MOV BX,[BP-12]
OR BX,BX
JNZ X42
MOV BX,0100AX
CALL _CallSwat
X42:

;     s = s->pSbNext;

;	BX _ _s
MOV BX,[BP-14]
MOV CX,[BX+4]

;	_s _ CX
MOV [BP-14],CX

;     };
JR X39
X40:

;   if (freecount != 0) CallSwat(ecAllocate+11);

;	BX _ _freecount
MOV BX,[BP-6]
OR BX,BX
JZ X43
MOV BX,0100BX
CALL _CallSwat
X43:

;   };
MOV SP,BP
POP BP
RET;

; CheckFreeNode(z, s)
_CheckFreeNode:

;   struct ZN *z;

;   struct SB *s;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   CheckBounds(z, s);

;	BX _ _s
POP BX
PUSH BX

;	CX _ _z
MOV CX,[BP-2]
CALL _CheckBounds

;   CheckBounds(z, s->pSbNext);

;	BX _ _s
POP BX
PUSH BX
MOV CX,[BX+4]
MOV BX,CX

;	CX _ _z
MOV CX,[BP-2]
CALL _CheckBounds

;   CheckBounds(z, s->pSbPrevious);

;	BX _ _s
POP BX
PUSH BX
MOV CX,[BX+6]
MOV BX,CX

;	CX _ _z
MOV CX,[BP-2]
CALL _CheckBounds

;   if ((s != &z->anchor) && (s->length < minLSbFree)) CallSwat(ecAllocate+12);

;	BX _ _z
MOV BX,[BP-2]

;	CX _ _s
POP CX
PUSH CX
CMP CX,BX
JZ X45

;	DI _ _s
POP DI
PUSH DI
MOV BX,[DI]
CMP BX,8
JGE X45
MOV AL,1
JR X46
X45:
XOR AL,AL
X46:
OR AL,AL
JZ X44
MOV BX,0100CX
CALL _CallSwat
X44:

;   if (s->pSbNext->pSbPrevious != s) CallSwat(ecAllocate+13);

;	BX _ _s
POP BX
PUSH BX
MOV CX,[BX+4]
MOV DI,CX
MOV BX,[DI+6]

;	CX _ _s
POP CX
PUSH CX
CMP BX,CX
JZ X47
MOV BX,0100DX
CALL _CallSwat
X47:

;   };
MOV SP,BP
POP BP
RET;

; CheckBounds(z, s)
_CheckBounds:

;   struct ZN *z;

;   struct SB *s;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int tip;

;   if (s != &z->anchor) {
PUSH DX

;	BX _ _z
MOV BX,[BP-2]

;	CX _ _s
MOV CX,[BP-4]
CMP CX,BX
JZ X48

;     tip = (int) s;

;	BX _ _s
MOV BX,[BP-4]

;	_tip _ BX
POP DX
PUSH BX

;     if ((Usc(tip+s->length, z->maxAdr) > 0) || (Usc(s, z->minAdr) < 0)) CallSwat(ecAllocate+14);

;	DI _ _s
MOV DI,[BP-4]
MOV BX,[DI]

;	CX _ _tip
POP CX
PUSH CX
ADD CX,BX

;	BX _ _z
MOV BX,[BP-2]
MOV AX,[BX+12]
MOV BX,AX
CALL _Usc
CMP BX,0
JG X51

;	BX _ _z
MOV BX,[BP-2]
MOV CX,[BX+10]
MOV BX,CX

;	CX _ _s
MOV CX,[BP-4]
CALL _Usc
CMP BX,0
JGE X50
X51:
MOV AL,1
JR X52
X50:
XOR AL,AL
X52:
OR AL,AL
JZ X49
MOV BX,0100EX
CALL _CallSwat
X49:

;     };
X48:

;   };
MOV SP,BP
POP BP
RET;

; #asm



PUBLIC _Allocate


; Externals Declared Here
PUBLIC _GetAll
PUBLIC _InitializeZone
PUBLIC _AddToZone
PUBLIC _Free
PUBLIC _Alloc
PUBLIC _CheckZone
PUBLIC _CheckBounds
PUBLIC _CheckFreeNode

C_CODE ENDS

; Number of Bytes of Code = 061EX, (1566)