;Alto->8086 small-c compiler rev 2.0
C←CODE SEGMENT

$INCLUDE(8086LIB.D)

$INCLUDE(dtslc.DEC)

ASSUME CS:C←CODE, DS:C←DATA

; #include <Lark.h>

; struct ccb {

;   char cmda;

;   char *addra;

;   char counta;

;   char stata;

;   };

; extern InByte();

; extern Swab();

; extern SetTmr();

; extern TmrExp();

; extern SLCInit();

; extern SLTStart();

; extern SLRStart();

; static struct ccb rxccb;

; static struct PBI *rxPBI;

; static int rxLength;

; static int rxTmr;

; SStartRx(pbi, length)
←SStartRx:

;   struct PBI *pbi;

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

;   {

;   rxPBI = pbi;

;	BX ← ←pbi
MOV BX,[BP-2]
MOV ←rxPBI,BX

;   rxLength = length;

;	BX ← ←length
POP BX
PUSH BX
MOV ←rxLength,BX

;   rxccb.cmda = 0x00;
MOV ←rxccb,0

;   rxccb.addra = rxPBI->pup;
MOV BX,←rxPBI
MOV CX,[BX+6]
MOV WORD PTR ←rxccb+1,CX

;   rxccb.addra = rxccb.addra - 4;
MOV BX,WORD PTR ←rxccb+1
ADD BX,0FFFCX
MOV WORD PTR ←rxccb+1,BX

;   rxccb.counta = (-rxLength) & 0x00ff;
MOV BX,←rxLength
NEG BX
AND BX,0FFX
MOV ←rxccb+3,BL

;   rxccb.stata = 0;
MOV ←rxccb+4,0

;   SLRStart(&rxccb);
LEA BX,←rxccb
CALL ←SLRStart

;   SetTmr(10000, &rxTmr);
LEA BX,←rxTmr
MOV CX,02710X
CALL ←SetTmr

;   };
MOV SP,BP
POP BP
RET;

; struct PBI *SCheckRx()
←SCheckRx:
PUSH BP
MOV BP,SP

;   {

;   struct EtherEncapsulation *ee;

;   int temp;

;   if (rxccb.stata & 0x80) {
ADD SP,0FFFCX
MOV AX,WORD PTR ←rxccb+4
AND AL,080X
OR AL,AL
JZ X1

;     if (rxccb.stata == 0x88) {
MOV AX,WORD PTR ←rxccb+4
CMP AL,088X
JNZ X2

;       temp = (int) rxPBI->pup;
MOV BX,←rxPBI
MOV CX,[BX+6]

;	←temp ← CX
POP DX
PUSH CX

;       temp -= 4;
SUB WORD PTR [BP-4],4

;       ee = (struct EtherEncapsulation *) temp;

;	BX ← ←temp
POP BX
PUSH BX

;	←ee ← BX
MOV [BP-2],BX

;       if (ee->type == 2) return(rxPBI);  /* Swabbed typePup */

;	BX ← ←ee
MOV BX,[BP-2]
MOV CX,[BX+2]
MOV BX,CX
CMP BX,2
JNZ X3
MOV BX,←rxPBI
MOV SP,BP
POP BP
RET;
X3:

;       };
X2:

;     SStartRx(rxPBI, rxLength)
MOV BX,←rxLength
MOV CX,←rxPBI
CALL ←SStartRx

;     };
X1:

;   if (TmrExp(&rxTmr)) {
LEA BX,←rxTmr
CALL ←TmrExp
OR BX,BX
JZ X4

;     SLCReset();  /* violent ! */
CALL ←SLCReset

;     SStartRx(rxPBI, rxLength)
MOV BX,←rxLength
MOV CX,←rxPBI
CALL ←SStartRx

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

;     };
X4:

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

;   };

; int EtherHost()
←EtherHost:
PUSH BP
MOV BP,SP

;   {

;   return (FetchW(0xFFFE));
MOV BX,0FFFEX
CALL ←FetchW
MOV SP,BP
POP BP
RET;

;   };

; SLCReset()
←SLCReset:
PUSH BP
MOV BP,SP

;   {

;   SLCInit(EtherHost());
CALL ←EtherHost
CALL ←SLCInit

;   };
MOV SP,BP
POP BP
RET;

; static struct ccb txccb;

; static int txTmr;

; SStartTx(pbi)
←SStartTx:

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

;   {

;   int len;
PUSH DX

;   len = Swab(pbi->pup->length);

;	BX ← ←pbi
MOV BX,[BP-2]
MOV CX,[BX+6]
MOV DI,CX
MOV BX,[DI]
CALL ←Swab

;	←len ← BX
POP DX
PUSH BX

;   len = (len + 5) & 0x0fffe;

;	BX ← ←len
POP BX
ADD BX,5
AND BX,0FFFEX

;	←len ← BX
PUSH BX

;   txccb.cmda = 0x50;
MOV ←txccb,050X

;   txccb.addra = pbi->pup;

;	BX ← ←pbi
MOV BX,[BP-2]
MOV CX,[BX+6]
MOV WORD PTR ←txccb+1,CX

;   txccb.addra = txccb.addra - 4;
MOV BX,WORD PTR ←txccb+1
ADD BX,0FFFCX
MOV WORD PTR ←txccb+1,BX

;   txccb.counta = len & 0x00ff;

;	BX ← ←len
POP BX
PUSH BX
AND BX,0FFX
MOV ←txccb+3,BL

;   txccb.stata = 0;
MOV ←txccb+4,0

;   SLTStart(&txccb);
LEA BX,←txccb
CALL ←SLTStart

;   SetTmr(200, &txTmr);
LEA BX,←txTmr
MOV CX,0C8X
CALL ←SetTmr

;   };
MOV SP,BP
POP BP
RET;

; SCheckTx()
←SCheckTx:
PUSH BP
MOV BP,SP

;   {

;   if (txccb.stata & 0x80) return(true);
MOV AX,WORD PTR ←txccb+4
AND AL,080X
OR AL,AL
JZ X5
MOV BX,0FFFFX
MOV SP,BP
POP BP
RET;
X5:

;   if (TmrExp(&txTmr)) {
LEA BX,←txTmr
CALL ←TmrExp
OR BX,BX
JZ X6

;     SLCReset();  /* violent ! */
CALL ←SLCReset

;     return(true);
MOV BX,0FFFFX
MOV SP,BP
POP BP
RET;

;     };
X6:

;   return(false);
XOR BX,BX
MOV SP,BP
POP BP
RET;

;   };

; Externals Declared Here
PUBLIC ←SStartRx
PUBLIC ←SCheckRx
PUBLIC ←SLCReset
PUBLIC ←EtherHost
PUBLIC ←SStartTx
PUBLIC ←SCheckTx

C←CODE ENDS

; Number of Bytes of Code = 0160X, (352)