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

$INCLUDE(8086LIB.D)

$INCLUDE(larkeload.DEC)

ASSUME CS:C_CODE, DS:C_DATA

; #include <Ec.h>

; struct Core {

;   int advice, addrlo, addrhi, count;

;   char data[1];

;   };

; extern MoveBlock();

; extern ByteBlt();

; extern Swab();

; extern DoubleEQ();

; extern OpenLevel1Socket();

; extern SendPup();

; extern ReleasePBI();

; extern CheckCheckSum();

; extern SwapSourceAndDest();

; extern int localNet;

; extern int localHost;

; extern int lenPup;

; static struct Port elPort;

; static int elSoc;

; ELoadProc(pbi)
_ELoadProc:

;   struct PBI *pbi;
PUSH BP
MOV BP,SP
PUSH BX

;   {

;   struct Pup *p;

;   char *caddr;

;   char *cdata;

;   int ccount;

;   int ptype;

;   int maxLength;

;   struct Core *core;
ADD SP,0FFF2X

;   p = pbi->pup;

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

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

;   ptype = p->type;

;	BX _ _p
MOV BX,[BP-4]
MOV AL,[BX+3]
XOR AH,AH

;	_ptype _ AX
MOV [BP-12],AX

;   if ((p->dPort.host == 0) && (ptype != ELStateRead)) goto reject;

;	BX _ _p
MOV BX,[BP-4]
MOV AL,[BX+9]
OR AL,AL
JNZ X2

;	BX _ _ptype
MOV BX,[BP-12]
CMP BX,0C6X
JZ X2
MOV AL,1
JR X3
X2:
XOR AL,AL
X3:
OR AL,AL
JZ X1
JMP _reject
X1:

;   core = (struct Core *) &p->data;

;	BX _ _p
MOV BX,[BP-4]
ADD BX,014X

;	_core _ BX
POP DX
PUSH BX

;   caddr = Swab(core->addrlo);

;	BX _ _core
POP BX
PUSH BX
MOV CX,[BX+2]
MOV BX,CX
CALL _Swab

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

;   maxLength = ((lenPup - pupOvWords) - 3) << 1;
MOV BX,_lenPup
ADD BX,0FFF5X
ADD BX,0FFFDX
SAL BX

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

;   ccount = Swab(core->count);

;	BX _ _core
POP BX
PUSH BX
MOV CX,[BX+6]
MOV BX,CX
CALL _Swab

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

;   if (ccount < 0) goto reject;

;	BX _ _ccount
MOV BX,[BP-10]
CMP BX,0
JGE X4
JMP _reject
X4:

;   if (ccount > maxLength) {

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

;	CX _ _ccount
MOV CX,[BP-10]
CMP CX,BX
JLE X5

;     ccount = maxLength;

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

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

;     core->count = Swab(maxLength);

;	BX _ _core
POP BX
PUSH BX
PUSH BX

;	BX _ _maxLength
MOV BX,[BP-14]
CALL _Swab
MOV CX,BX
POP BX
MOV [BX+6],CX

;     };
X5:

;   cdata = &core->data[0];

;	BX _ _core
POP BX
PUSH BX
ADD BX,8

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

;   if (core->addrhi) goto reject;

;	BX _ _core
POP BX
PUSH BX
MOV CX,[BX+4]
OR CX,CX
JZ X6
JMP _reject
X6:

;   if (!CheckCheckSum(p)) goto reject;

;	BX _ _p
MOV BX,[BP-4]
CALL _CheckCheckSum
OR BX,BX
JNZ X7
JMP _reject
X7:

;   switch (ptype) {

;	BX _ _ptype
MOV BX,[BP-12]
JR X8

;     case ELWrite:
X10:

;       ByteBlt(caddr, cdata, ccount);

;	BX _ _caddr
MOV BX,[BP-6]
PUSH BX

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

;	CX _ _cdata
MOV CX,[BP-8]
CALL _ByteBlt
POP DX

;     case ELRead:
X11:

;       if (Ugt(caddr, 0xffcf)) goto reject;
MOV BX,0FFCFX

;	CX _ _caddr
MOV CX,[BP-6]
CALL _Ugt
OR BX,BX
JZ X12
JMP _reject
X12:

;       if (Ugt(ccount, 0xffd0 - ((int) caddr))) goto reject;

;	BX _ _caddr
MOV BX,[BP-6]
MOV CX,0FFD0X
SUB CX,BX
MOV BX,CX

;	CX _ _ccount
MOV CX,[BP-10]
CALL _Ugt
OR BX,BX
JZ X13
JMP _reject
X13:

;       ByteBlt(cdata, caddr, ccount);

;	BX _ _cdata
MOV BX,[BP-8]
PUSH BX

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

;	CX _ _caddr
MOV CX,[BP-6]
CALL _ByteBlt
POP DX

;       SwapSourceAndDest(p);

;	BX _ _p
MOV BX,[BP-4]
CALL _SwapSourceAndDest

;       p->length = Swab((31 + ccount) & 0xfffe);

;	BX _ _ccount
MOV BX,[BP-10]
ADD BX,01FX
AND BX,0FFFEX
CALL _Swab
MOV CX,BX

;	BX _ _p
MOV BX,[BP-4]
MOV [BX],CX

;       Block();
CALL _Block

;       p->type = p->type + 1;

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

;	CX _ _p
MOV CX,[BP-4]
MOV DI,CX
MOV AL,[DI+3]
INC AL
MOV [BX+3],AL

;       SendPup(pbi);

;	BX _ _pbi
MOV BX,[BP-2]
CALL _SendPup

;       return;
JR $+5
X8:
JMP X14
MOV SP,BP
POP BP
RET;

;     case ELSWrite:
X15:

;       SlaveBLT(caddr, cdata, ccount);  /* how tell when it is done ? */

;	BX _ _caddr
MOV BX,[BP-6]
PUSH BX

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

;	CX _ _cdata
MOV CX,[BP-8]
CALL _SlaveBLT
POP DX

;     case ELSRead:
X16:

;       SlaveBLT(cdata, caddr, ccount);

;	BX _ _cdata
MOV BX,[BP-8]
PUSH BX

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

;	CX _ _caddr
MOV CX,[BP-6]
CALL _SlaveBLT
POP DX

;       SwapSourceAndDest(p);

;	BX _ _p
MOV BX,[BP-4]
CALL _SwapSourceAndDest

;       p->length = Swab((31 + ccount) & 0xfffe);

;	BX _ _ccount
MOV BX,[BP-10]
ADD BX,01FX
AND BX,0FFFEX
CALL _Swab
MOV CX,BX

;	BX _ _p
MOV BX,[BP-4]
MOV [BX],CX

;       Block();
CALL _Block

;       p->type = p->type + 1;

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

;	CX _ _p
MOV CX,[BP-4]
MOV DI,CX
MOV AL,[DI+3]
INC AL
MOV [BX+3],AL

;       SendPup(pbi);

;	BX _ _pbi
MOV BX,[BP-2]
CALL _SendPup

;       return;
MOV SP,BP
POP BP
RET;

;     case ELCall:
X17:

;       ClientCallPkt(cdata);

;	BX _ _cdata
MOV BX,[BP-8]
CALL _ClientCallPkt

;       SwapSourceAndDest(p);

;	BX _ _p
MOV BX,[BP-4]
CALL _SwapSourceAndDest

;       p->type = p->type + 1;

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

;	CX _ _p
MOV CX,[BP-4]
MOV DI,CX
MOV AL,[DI+3]
INC AL
MOV [BX+3],AL

;       SendPup(pbi);

;	BX _ _pbi
MOV BX,[BP-2]
CALL _SendPup

;       return;
MOV SP,BP
POP BP
RET;

;     case ELStateRead: 
X18:

;       if ((int) caddr != 1) goto reject;

;	BX _ _caddr
MOV BX,[BP-6]
CMP BX,1
JZ X19
JMP _reject
X19:

;       ByteBlt(cdata, 0xda00, ccount);

;	BX _ _cdata
MOV BX,[BP-8]
PUSH BX

;	BX _ _ccount
MOV BX,[BP-10]
MOV CX,0DA00X
CALL _ByteBlt
POP DX

;       SwapSourceAndDest(p);

;	BX _ _p
MOV BX,[BP-4]
CALL _SwapSourceAndDest

;       p->length = Swab((31 + ccount) & 0xfffe);

;	BX _ _ccount
MOV BX,[BP-10]
ADD BX,01FX
AND BX,0FFFEX
CALL _Swab
MOV CX,BX

;	BX _ _p
MOV BX,[BP-4]
MOV [BX],CX

;       Block();
CALL _Block

;       p->type = p->type + 1;

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

;	CX _ _p
MOV CX,[BP-4]
MOV DI,CX
MOV AL,[DI+3]
INC AL
MOV [BX+3],AL

;       SendPup(pbi);

;	BX _ _pbi
MOV BX,[BP-2]
CALL _SendPup

;       return;
MOV SP,BP
POP BP
RET;

;     case ELDebug: { CallDebugger(ecPup1+21); goto reject; };
X20:
MOV BX,04015X
CALL _CallDebugger
JMP _reject

;     default: goto reject;
X21:
JMP _reject

;     };
JR X9
X14:
MOV AL,BH
OR AL,AL
JNZ X21
MOV AL,BL
CMP AL,0C0X
JMPZ X10
CMP AL,0C2X
JMPZ X11
CMP AL,0CEX
JMPZ X15
CMP AL,0D0X
JMPZ X16
CMP AL,0D2X
JMPZ X17
CMP AL,0C6X
JMPZ X18
CMP AL,0C8X
JZ X20
JR X21
X9:
_reject:

;   reject: ReleasePBI(pbi);

;	BX _ _pbi
MOV BX,[BP-2]
CALL _ReleasePBI

;   };
MOV SP,BP
POP BP
RET;

; ELoad()
_ELoad:
PUSH BP
MOV BP,SP

;   {

;   elPort.net = localNet;
MOV AX,_localNet
MOV _elPort,AL

;   elPort.host = localHost;
MOV AX,_localHost
MOV _elPort+1,AL

;   elPort.socket.LS = 0;
MOV WORD PTR _elPort+2,0

;   elPort.socket.ms = 0x3000;
MOV WORD PTR _elPort+4,03000X

;   elSoc = OpenLevel1Socket(&elPort, &ELoadProc, 0);
LEA BX,_elPort
PUSH BX
XOR BX,BX
MOV CX,OFFSET _ELoadProc
CALL _OpenLevel1Socket
POP DX
MOV _elSoc,BX

;   if (!elSoc) CallDebugger(ecPup1+10);
MOV BX,_elSoc
OR BX,BX
JNZ X22
MOV BX,0400AX
CALL _CallDebugger
X22:

;   };
MOV SP,BP
POP BP
RET;

; struct CCPArgs {

;   int proc;

;   int nargs;

;   int returnSlot;

;   int args[5];

;   };

; ClientCallPkt(cp)
_ClientCallPkt:

;   struct CCPArgs *cp;
PUSH BP
MOV BP,SP
PUSH BX

;   {

;   BlockSwab(cp, 8);
MOV BX,8

;	CX _ _cp
POP CX
PUSH CX
CALL _BlockSwab

;   if (cp->nargs > 5) return;

;	BX _ _cp
POP BX
PUSH BX
MOV CX,[BX+2]
MOV BX,CX
CMP BX,5
JLE X23
MOV SP,BP
POP BP
RET;
X23:

;   cp->returnSlot = Apply(&cp->args[0], cp->proc, cp->nargs);

;	BX _ _cp
POP BX
PUSH BX
PUSH BX

;	BX _ _cp
MOV BX,[BP-2]
ADD BX,6
PUSH BX

;	DI _ _cp
MOV DI,[BP-2]
MOV BX,[DI]

;	CX _ _cp
MOV CX,[BP-2]
MOV DI,CX
MOV CX,[DI+2]
XCHG BX,CX
CALL _Apply
POP DX
MOV CX,BX
POP BX
MOV [BX+4],CX

;   BlockSwab(cp, 8);
MOV BX,8

;	CX _ _cp
POP CX
PUSH CX
CALL _BlockSwab

;   };
MOV SP,BP
POP BP
RET;

; Externals Declared Here
PUBLIC _ELoadProc
PUBLIC _ClientCallPkt
PUBLIC _ELoad

C_CODE ENDS

; Number of Bytes of Code = 02DCX, (732)