;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)