mirror of
https://github.com/SEPPDROID/Digital-Research-Source-Code.git
synced 2025-10-23 08:24:18 +00:00
369 lines
7.0 KiB
C
369 lines
7.0 KiB
C
/* This module performs packet normalization and */
|
|
/* preparation to/from I/O channel. Context dependent */
|
|
/* data are put in a normal form before transmission */
|
|
/* over the I/O channel. Conversly, received messages */
|
|
/* are 'de-normalized' into machine dependent quanti- */
|
|
/* ties before being returned to the caller. This */
|
|
/* portion of code should be machine independent, */
|
|
/* since values such as word-length and long-length */
|
|
/* are declared as externals. */
|
|
|
|
|
|
/*
|
|
*************************************************
|
|
* *
|
|
* Author: David Heintz *
|
|
* Module: Normalc.c *
|
|
* Creation Date: 10/26/82 *
|
|
* Language: Standard C *
|
|
* Version: 0.0 *
|
|
* Last Mod: 01/16/83 *
|
|
* *
|
|
*************************************************
|
|
*/
|
|
|
|
|
|
/*
|
|
*************************************************
|
|
* *
|
|
* STANDARD HEADERS *
|
|
* *
|
|
*************************************************
|
|
*/
|
|
|
|
#include "unstdsys.h"
|
|
#include "fioequ.h"
|
|
#include "chnequ.h"
|
|
|
|
/*
|
|
*************************************************
|
|
* *
|
|
* EXTERNAL DECLARATIONS *
|
|
* *
|
|
*************************************************
|
|
*/
|
|
|
|
|
|
/*
|
|
*************************************************
|
|
* *
|
|
* I/O Channel Related Externals *
|
|
* and Globals *
|
|
* *
|
|
*************************************************
|
|
*/
|
|
|
|
/* Routines defined within this module */
|
|
|
|
extern BYTE rcv_cmd();
|
|
extern BYTE rcv_byte();
|
|
extern BYTE rcv_word();
|
|
extern BYTE rcv_long();
|
|
extern BYTE rcv_data();
|
|
|
|
extern BYTE snd_cmd();
|
|
extern BYTE snd_byte();
|
|
extern BYTE snd_word();
|
|
extern BYTE snd_long();
|
|
extern BYTE snd_data();
|
|
extern chn_err();
|
|
|
|
|
|
/* Routines defined outside of this module */
|
|
|
|
extern BYTE snd_pkt();
|
|
extern BYTE rcv_pkt();
|
|
extern BYTE gb_word();
|
|
extern BYTE gb_long();
|
|
extern pb_word();
|
|
extern pb_long();
|
|
|
|
|
|
/* Machine dependent externals */
|
|
|
|
extern WORD bytlen;
|
|
extern WORD wrdlen;
|
|
extern WORD lnglen;
|
|
|
|
/*
|
|
*************************************************
|
|
* *
|
|
* I/O Channel Data Normalization *
|
|
* Routines *
|
|
* *
|
|
*************************************************
|
|
*/
|
|
|
|
|
|
/*
|
|
*****************************************
|
|
* *
|
|
* snd_byte(): *
|
|
* Normalize and transmit *
|
|
* a byte over I/O channel *
|
|
* *
|
|
*****************************************
|
|
/
|
|
/ Inputs: byte to be transmitted
|
|
/ Outputs: I/O channel status (byte)
|
|
*/
|
|
|
|
BYTE snd_byte(sbyte)
|
|
|
|
BYTE sbyte;
|
|
{
|
|
return(snd_pkt(byttyp, (BYTE *)&sbyte, bytlen));
|
|
}
|
|
|
|
/*
|
|
*****************************************
|
|
* *
|
|
* snd_word(): *
|
|
* Normalize and transmit *
|
|
* a word over I/O channel *
|
|
* *
|
|
*****************************************
|
|
/
|
|
/ Inputs: word to be transmitted
|
|
/ Outputs: I/O channel status (byte)
|
|
*/
|
|
|
|
BYTE snd_word(sword)
|
|
|
|
WORD sword;
|
|
{
|
|
WORD i, nword;
|
|
BYTE *pbyte;
|
|
pbyte = (BYTE *)&nword;
|
|
for (i = 0; i < wrdlen; i++)
|
|
*(pbyte++) = gb_word(&sword, i);
|
|
return(snd_pkt(wrdtyp, (BYTE *)&nword, wrdlen));
|
|
}
|
|
|
|
/*
|
|
*****************************************
|
|
* *
|
|
* snd_long(): *
|
|
* Normalize and transmit *
|
|
* a long over I/O channel *
|
|
* *
|
|
*****************************************
|
|
/
|
|
/ Inputs: long to be transmitted
|
|
/ Outputs: I/O channel status (byte)
|
|
*/
|
|
|
|
BYTE snd_long(slong)
|
|
|
|
LONG slong;
|
|
{
|
|
LONG nlong;
|
|
WORD i;
|
|
BYTE *pbyte;
|
|
pbyte = (BYTE *)&nlong;
|
|
for (i = 0; i < lnglen; i++)
|
|
*(pbyte++) = gb_long(&slong, i);
|
|
return(snd_pkt(lngtyp, (BYTE *)&nlong, lnglen));
|
|
}
|
|
|
|
/*
|
|
*****************************************
|
|
* *
|
|
* snd_data(): *
|
|
* Normalize and transmit *
|
|
* data over I/O channel *
|
|
* *
|
|
*****************************************
|
|
/
|
|
/ Inputs: pointer to data to be transmitted
|
|
/ Outputs: I/O channel status (byte)
|
|
*/
|
|
|
|
BYTE snd_data(pbyte, datlen)
|
|
|
|
BYTE *pbyte;
|
|
WORD datlen;
|
|
{
|
|
return(snd_pkt(dattyp, pbyte, datlen));
|
|
}
|
|
|
|
/*
|
|
*****************************************
|
|
* *
|
|
* snd_cmd(): *
|
|
* Normalize and transmit *
|
|
* a command over I/O channel *
|
|
* *
|
|
*****************************************
|
|
/
|
|
/ Inputs: command to be transmitted
|
|
/ Outputs: I/O channel status (byte)
|
|
*/
|
|
|
|
BYTE snd_cmd(sd0, sd1, sd2)
|
|
|
|
WORD sd0;
|
|
LONG sd1, sd2;
|
|
|
|
{
|
|
struct {
|
|
WORD request;
|
|
LONG param1;
|
|
LONG param2;
|
|
} cmd;
|
|
|
|
LONG nlong;
|
|
WORD i;
|
|
BYTE *pbyte;
|
|
pbyte = (BYTE *)&cmd;
|
|
for (i = 0; i < wrdlen; i++)
|
|
*(pbyte++) = gb_word(&sd0, i);
|
|
for (i = 0; i < lnglen; i++)
|
|
*(pbyte++) = gb_long(&sd1, i);
|
|
for (i = 0; i < lnglen; i++)
|
|
*(pbyte++) = gb_long(&sd2, i);
|
|
return(snd_pkt(cmdtyp, (BYTE *)&cmd, sizeof(cmd)));
|
|
}
|
|
|
|
/*
|
|
*****************************************
|
|
* *
|
|
* rcv_byte(): *
|
|
* Receive and normalize *
|
|
* a byte over I/O channel *
|
|
* *
|
|
*****************************************
|
|
/ Inputs: Address of where to put received byte
|
|
/ Outputs: I/O channel status (BYTE)
|
|
/ Actions: Place received byte at pbyte
|
|
*/
|
|
|
|
BYTE rcv_byte(pbyte)
|
|
|
|
BYTE *pbyte;
|
|
{
|
|
return(rcv_pkt(byttyp, pbyte, bytlen));
|
|
}
|
|
|
|
|
|
/*
|
|
*****************************************
|
|
* *
|
|
* rcv_word(): *
|
|
* Receive and normalize *
|
|
* a word over I/O channel *
|
|
* *
|
|
*****************************************
|
|
/ Inputs: Address of where to put received word
|
|
/ Outputs: I/O channel status (BYTE)
|
|
/ Actions: Place received word at pword
|
|
*/
|
|
|
|
BYTE rcv_word(pword)
|
|
|
|
BYTE *pword;
|
|
|
|
{
|
|
BYTE code, *pbyte;
|
|
WORD i, rword;
|
|
pbyte = (BYTE *)&rword;
|
|
code = rcv_pkt(wrdtyp, (BYTE *)&rword, wrdlen);
|
|
if (code == chsuc)
|
|
for (i = 0; i < wrdlen; i++)
|
|
pb_word(*(pbyte++), pword, i);
|
|
return(code);
|
|
}
|
|
|
|
/*
|
|
*****************************************
|
|
* *
|
|
* rcv_long(): *
|
|
* Receive and normalize *
|
|
* a long over I/O channel *
|
|
* *
|
|
*****************************************
|
|
/ Inputs: Address of where to put received long
|
|
/ Outputs: I/O channel status (BYTE)
|
|
/ Actions: Place received long at plong
|
|
*/
|
|
|
|
BYTE rcv_long(plong)
|
|
|
|
BYTE *plong;
|
|
|
|
{
|
|
BYTE code, *pbyte;
|
|
WORD i;
|
|
LONG rlong;
|
|
pbyte = (BYTE *)&rlong;
|
|
code = rcv_pkt(lngtyp, (BYTE *)&rlong, lnglen);
|
|
if (code == chsuc)
|
|
for (i = 0; i < lnglen; i++)
|
|
pb_long(*(pbyte++), plong, i);
|
|
return(code);
|
|
}
|
|
|
|
/*
|
|
*****************************************
|
|
* *
|
|
* rcv_data(): *
|
|
* Receive and normalize *
|
|
* data over I/O channel *
|
|
* *
|
|
*****************************************
|
|
/ Inputs: Address of where to put received data
|
|
/ Outputs: I/O channel status (BYTE)
|
|
/ Actions: Place received data at pbyte
|
|
*/
|
|
|
|
BYTE rcv_data(pbyte, datlen)
|
|
|
|
BYTE *pbyte;
|
|
{
|
|
return(rcv_pkt(dattyp, pbyte, datlen));
|
|
}
|
|
|
|
/*
|
|
*****************************************
|
|
* *
|
|
* rcv_cmd(): *
|
|
* Receive and Normalize *
|
|
* a command over I/O channel *
|
|
* *
|
|
*****************************************
|
|
/
|
|
/ Inputs: addresses of command parameters
|
|
/ Outputs: I/O channel status (byte)
|
|
*/
|
|
|
|
BYTE rcv_cmd(sd0, sd1, sd2)
|
|
|
|
WORD *sd0;
|
|
LONG *sd1, *sd2;
|
|
|
|
{
|
|
struct {
|
|
WORD request;
|
|
LONG param1;
|
|
LONG param2;
|
|
} cmd;
|
|
|
|
LONG nlong;
|
|
WORD i;
|
|
BYTE code, *pbyte;
|
|
code = rcv_pkt(cmdtyp, (BYTE *)&cmd, sizeof(cmd));
|
|
if (code == chsuc)
|
|
{
|
|
pbyte = (BYTE *)&cmd;
|
|
for (i = 0; i < wrdlen; i++)
|
|
pb_word(*(pbyte++), sd0, i);
|
|
for (i = 0; i < lnglen; i++)
|
|
pb_long(*(pbyte++), sd1, i);
|
|
for (i = 0; i < lnglen; i++)
|
|
pb_long(*(pbyte++), sd2, i);
|
|
}
|
|
return(code);
|
|
}
|
|
|
|
/* End of Module */
|