MAIN MODULE EXEC
%SET USE_ROUTINE_NAMES=TRUE

IMPORT	NOVANET FROM NETDRIVER
IMPORT	NVINIT FROM NVSTUBS
IMPORT  COMMAND_PROCESSOR FROM COMPROC
USE	IOMODULE,
	ADDROF,
	VECTS,
	TRAPSRV,
	CLKSRV,
	POWERFSRV,
	CDRIVER,
	NETTYPES
//	HLCDEFS

EXPORT	IOSB,
	INCOMING_NET_BUFFER,
	OUTGOING_NET_BUFFER,
	OUT_BUFFER_LENGTH,
	SCB


DECLARE 
	INCOMING_NET_BUFFER	: STATIC ARRAY [0..100]  OF 16 BIT INTEGER
	OUTGOING_NET_BUFFER	: STATIC ARRAY [0..4200] OF 16 BIT INTEGER
	OUT_BUFFER_LENGTH	: STATIC 16 BIT INTEGER
	SCB			: STATIC ARRAY [0..100]	 OF 16 BIT INTEGER
	IOSB			: STATIC ARRAY [0..3]    OF 16 BIT INTEGER
	J			: STATIC 16 BIT INTEGER
	B			: STATIC 16 BIT INTEGER
	START			: STATIC 16 BIT INTEGER
	FINISH			: STATIC 16 BIT INTEGER
	BLOCK_FLAG		: BOOLEAN INITIALLY FALSE
ENDDECLARE

PUT (" ")			// blank line
PUT (" ")			// blank line

VECTORS()			//initialize interrupt vectors

NVINIT()			//initialize the novanet card

PUT ("NV INIT EXECUTED")


CAMACZ(0,CRATE_FLAG)		// zero crate 0
CAMACZ(1,CRATE_FLAG)		// zero crate 1
CAMACI(0,FALSE,CRATE_FLAG)	// clear inhibit on crate 0
CAMACI(1,FALSE,CRATE_FLAG)	// clear inhibit on crate 1


OUTERLOOP:REPEAT		//just a label

   INNERLOOP:REPEAT		//this inner loop is infinite except on error
				//then it is exited and the program starts at
				//outerloop again. 

	START:=0				// beginning of buffer
	FOR I:=0 TO 500 DO			// zero the incoming buffer
		INCOMING_NET_BUFFER[I]:=0
	ENDFOR

	FOR I:=0 TO 100 DO			// zero single command buffer
		SCB[I]:=0
	ENDFOR


////////////////////////////////////////////////////////////////////////////
// first set up a passive read with a 8K byte buffer			  //
////////////////////////////////////////////////////////////////////////////
	IRP.LNK		:=	0
	IRP.FNC		:=	PROC_PASSIVE_READ
	IRP.IOS		:=	ADDR_OF(IOSB[0])
	IRP.BUF		:=	ADDR_OF(INCOMING_NET_BUFFER[0])
	IRP.LEN		:=	1000		//bytes
	IRP.NOD.STATION	:=	0		// station not used on pas w
	IRP.NOD.NODE	:=	0		// node not used on passive rd
	IRP.PRE		:=	EOB		// end of block mode

	NOVANET (IRP)				//make the network call
	
	IF NV_STATUS<>1 DO
		BREAK INNERLOOP			//call bad so break
	ENDIF

	REPEAT					//wait until read has completed
	UNTIL IOSB[0]<>0


// now check for net errors by looking at iosb

	IF IOSB[0]<>1 DO
		PUT16 ("READ ERROR, IOSB[0]=",IOSB[0])
		PUT16 ("LENGTH IN BYTES=",IOSB[1])
		PUT16 ("CSRA=",IOSB[2])
		PUT16 ("CSRB=",IOSB[3])
		BREAK INNERLOOP
	ENDIF


/////////////////////////////////////////////////////////////////////////////
// now pull off one command, then move the pointers to point to the next   //
// command								   //
/////////////////////////////////////////////////////////////////////////////

//     REPEAT			// keep doing this until all commands in the
				// block are done
				// Then do the reply

	FINISH:=START+INCOMING_NET_BUFFER[START]

	J:=0					// set index to 0 for command
	FOR I:= START TO FINISH DO		// fill scb(single_command_buf)
		SCB[J]:=INCOMING_NET_BUFFER[I]
		J:=J+1
	ENDFOR

	START:=FINISH+1		// point to the next command or null

// now the single_command_buffer has one command and the data associated
// with it (if any)



/////////////////////////////////////////////////////////////////////////////
// now call the command processor to do the action required, passing it the//
// single_command_buffer (which may also contain write data)		   //
//
	COMMAND_PROCESSOR	(SCB,
				BLOCK_FLAG,
				OUTGOING_NET_BUFFER,
				OUT_BUFFER_LENGTH)
/////////////////////////////////////////////////////////////////////////////

//    UNTIL BLOCK_FLAG=FALSE			// finish all commands in block


/////////////////////////////////////////////////////////////////////////////
//now send back the buffer using the active write mode			   //
/////////////////////////////////////////////////////////////////////////////



     REPEAT
	IRP.LNK		:=	0
	IRP.FNC		:=	PROC_ACTIVE_WRITE
	IRP.IOS		:=	ADDR_OF(IOSB[0])
	IRP.BUF		:=	ADDR_OF(OUTGOING_NET_BUFFER[0])
	IRP.LEN		:=	OUT_BUFFER_LENGTH+OUT_BUFFER_LENGTH	//bytes
	IRP.NOD.STATION	:=	0		//
	IRP.NOD.NODE	:=	128		// to vax node 128 decimal
	IRP.PRE		:=	EOB		// end of block mode

	NOVANET (IRP)
	
	IF NV_STATUS<>1 DO
		BREAK INNERLOOP			//call bad so break
	ENDIF

	REPEAT					//wait until write completed
	UNTIL IOSB[0]<>0

	IF IOSB[0]<>1 DO
		PUT16 ("WRITE ERROR, IOSB[0]=",IOSB[0])
		PUT16 ("LENGTH IN BYTES=",IOSB[1])
		PUT16 ("CSRA=",IOSB[2])
		PUT16 ("CSRB=",IOSB[3])
	ENDIF
    UNTIL IOSB[0]=1

  UNTIL FALSE

UNTIL FALSE

ENDMODULE{EXEC}