1701 lines
47 KiB
C
1701 lines
47 KiB
C
/*
|
||
* C O N V E R T . C
|
||
*
|
||
* Author: D. Kersteins
|
||
*
|
||
*
|
||
* NOTES:
|
||
* 1) converts arrays without subroutine call
|
||
* for improved efficiency -joh
|
||
*
|
||
* 2) These routines only do VAX conversions for now - joh
|
||
*
|
||
* 3) All routines in this file have an encode argument which
|
||
* determines if we are converting from the standard format to
|
||
* the local format or vise versa. To date only float and double data
|
||
* types must be converted differently depending on the encode
|
||
* argument - joh
|
||
*
|
||
* History
|
||
* joh 10-21-90 Moved atomic types here to avoid
|
||
* maintenance problems in service.c
|
||
* This also provides for a cleaner seperation
|
||
* of function.
|
||
* joh 10-21-90 Added new DBR_XXXX types for release two
|
||
* joh 03-15-94 Added many missing types
|
||
*
|
||
*
|
||
*/
|
||
|
||
static char *sccsId = "%S% $Date$";
|
||
|
||
#include <string.h>
|
||
|
||
#include <db_access.h>
|
||
#include <net_convert.h>
|
||
|
||
#ifdef __STDC__
|
||
|
||
/*
|
||
* if hton is true then it is a host to network conversion
|
||
* otherwise vise-versa
|
||
*
|
||
* net format: big endian and IEEE float
|
||
*
|
||
*/
|
||
typedef LOCAL void CACVRTFUNC(
|
||
void *pSource,
|
||
void *pDestination,
|
||
int hton,
|
||
unsigned long count);
|
||
#else /*__STDC__*/
|
||
typedef LOCAL void CACVRTFUNC();
|
||
#endif /*__STDC__*/
|
||
|
||
CACVRTFUNC cvrt_string;
|
||
CACVRTFUNC cvrt_short;
|
||
CACVRTFUNC cvrt_float;
|
||
CACVRTFUNC cvrt_enum;
|
||
CACVRTFUNC cvrt_char;
|
||
CACVRTFUNC cvrt_long;
|
||
CACVRTFUNC cvrt_double;
|
||
|
||
CACVRTFUNC cvrt_sts_string;
|
||
CACVRTFUNC cvrt_sts_short;
|
||
CACVRTFUNC cvrt_sts_float;
|
||
CACVRTFUNC cvrt_sts_enum;
|
||
CACVRTFUNC cvrt_sts_char;
|
||
CACVRTFUNC cvrt_sts_long;
|
||
CACVRTFUNC cvrt_sts_double;
|
||
|
||
CACVRTFUNC cvrt_time_string;
|
||
CACVRTFUNC cvrt_time_short;
|
||
CACVRTFUNC cvrt_time_float;
|
||
CACVRTFUNC cvrt_time_enum;
|
||
CACVRTFUNC cvrt_time_char;
|
||
CACVRTFUNC cvrt_time_long;
|
||
CACVRTFUNC cvrt_time_double;
|
||
|
||
CACVRTFUNC cvrt_gr_short;
|
||
CACVRTFUNC cvrt_gr_float;
|
||
CACVRTFUNC cvrt_gr_enum;
|
||
CACVRTFUNC cvrt_gr_char;
|
||
CACVRTFUNC cvrt_gr_long;
|
||
CACVRTFUNC cvrt_gr_double;
|
||
|
||
CACVRTFUNC cvrt_ctrl_short;
|
||
CACVRTFUNC cvrt_ctrl_float;
|
||
CACVRTFUNC cvrt_ctrl_enum;
|
||
CACVRTFUNC cvrt_ctrl_char;
|
||
CACVRTFUNC cvrt_ctrl_long;
|
||
CACVRTFUNC cvrt_ctrl_double;
|
||
|
||
/* cvrt is (array of) (pointer to) (function returning) int */
|
||
LOCAL CACVRTFUNC *cvrt[]
|
||
=
|
||
{
|
||
cvrt_string,
|
||
cvrt_short,
|
||
cvrt_float,
|
||
cvrt_enum,
|
||
cvrt_char,
|
||
cvrt_long,
|
||
cvrt_double,
|
||
|
||
cvrt_sts_string,
|
||
cvrt_sts_short,
|
||
cvrt_sts_float,
|
||
cvrt_sts_enum,
|
||
cvrt_sts_char,
|
||
cvrt_sts_long,
|
||
cvrt_sts_double,
|
||
|
||
cvrt_time_string,
|
||
cvrt_time_short,
|
||
cvrt_time_float,
|
||
cvrt_time_enum,
|
||
cvrt_time_char,
|
||
cvrt_time_long,
|
||
cvrt_time_double,
|
||
|
||
cvrt_sts_string, /* DBR_GR_STRING identical to dbr_sts_string */
|
||
cvrt_gr_short,
|
||
cvrt_gr_float,
|
||
cvrt_gr_enum,
|
||
cvrt_gr_char,
|
||
cvrt_gr_long,
|
||
cvrt_gr_double,
|
||
|
||
cvrt_sts_string, /* DBR_CTRL_STRING identical to dbr_sts_string */
|
||
cvrt_ctrl_short,
|
||
cvrt_ctrl_float,
|
||
cvrt_ctrl_enum,
|
||
cvrt_ctrl_char,
|
||
cvrt_ctrl_long,
|
||
cvrt_ctrl_double
|
||
};
|
||
|
||
static void no_cvrt();
|
||
|
||
/*
|
||
* Native types may not match EPICS types
|
||
*/
|
||
typedef dbr_short_t short;
|
||
typedef dbr_float_t float;
|
||
typedef dbr_enum_t enum;
|
||
typedef dbr_char_t char;
|
||
typedef dbr_long_t long;
|
||
typedef dbr_double_t double;
|
||
#define dbr_ntohs(A) ntohs(A)
|
||
#define dbr_ntohl(A) ntohl(A)
|
||
#define dbr_htons(A) htons(A)
|
||
#define dbr_htonl(A) htonl(A)
|
||
|
||
|
||
|
||
/*
|
||
* CVRT_STRING()
|
||
*
|
||
*
|
||
*
|
||
*
|
||
*/
|
||
#ifdef __STDC__
|
||
void cvrt_string(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
void cvrt_short(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T */
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
dbr_char_t *pSrc = s;
|
||
dbr_char_t *pDest = d;
|
||
|
||
if(num == 1){
|
||
strcpy(pDest, pSrc);
|
||
}
|
||
else{
|
||
memcpy(pDest, pSrc, num*MAXSTRINGSIZE);
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
* CVRT_SHORT()
|
||
*
|
||
*
|
||
*
|
||
*
|
||
*/
|
||
#ifdef __STDC__
|
||
void cvrt_short(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
void cvrt_short(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T */
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
dbr_short_t *pSrc = s;
|
||
dbr_short_t *pDest = d;
|
||
unsigned long i;
|
||
|
||
for(i=0; i<num; i++){
|
||
*pDest++ = dbr_ntohs( *pSrc++ );
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
* CVRT_CHAR()
|
||
*
|
||
*
|
||
*
|
||
*
|
||
*/
|
||
#ifdef __STDC__
|
||
void cvrt_char(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
void cvrt_char(
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T */
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
unsigned int i;
|
||
dbr_char_t *pSrc = s;
|
||
dbr_char_t *pDest = d;
|
||
|
||
for(i=0; i<num; i++){
|
||
*pDest++ = *pSrc++;
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
* CVRT_LONG()
|
||
*
|
||
*
|
||
*
|
||
*
|
||
*/
|
||
#ifdef __STDC__
|
||
void cvrt_long(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
void cvrt_long(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T */
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
unsigned long i;
|
||
dbr_long_t *pSrc = s;
|
||
dbr_long_t *pDest = d;
|
||
|
||
for(i=0; i<num; i++){
|
||
*pDest++ = dbr_ntohl( *pSrc++ );
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
* CVRT_ENUM()
|
||
*
|
||
*
|
||
*
|
||
*
|
||
*/
|
||
#ifdef __STDC__
|
||
void cvrt_enum(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
void cvrt_enum(s,d,encode,num)
|
||
short *s; /* source */
|
||
short *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T */
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
unsigned int i;
|
||
dbr_enum_t *pSrc = s;
|
||
dbr_enum_t *pDest = d;
|
||
|
||
for(i=0; i<num; i++){
|
||
*pDest++ = dbr_ntohs(*pSrc++);
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
* CVRT_FLOAT()
|
||
*
|
||
*
|
||
* NOTES:
|
||
* placing encode outside the loop results in more
|
||
* code but better performance.
|
||
*
|
||
*/
|
||
#ifdef __STDC__
|
||
void cvrt_float(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
#else
|
||
void cvrt_float(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
unsigned long i;
|
||
dbr_float_t *pSrc = s;
|
||
dbr_float_t *pDest = d;
|
||
|
||
for(i=0; i<num; i++){
|
||
if(encode){
|
||
dbr_htonf(pSrc, pDest);
|
||
}
|
||
else{
|
||
dbr_ntohf(pSrc, pDest);
|
||
}
|
||
/*
|
||
* incrementing these inside the MACRO could be unhealthy
|
||
*/
|
||
pSrc++;
|
||
pDest++;
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
* CVRT_DOUBLE()
|
||
*
|
||
*
|
||
*
|
||
*
|
||
*/
|
||
#ifdef __STDC__
|
||
void cvrt_double(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
void cvrt_double(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
unsigned int i;
|
||
|
||
if(encode){
|
||
for(i=0; i<num; i++){
|
||
htond(s,d);
|
||
}
|
||
}
|
||
else{
|
||
for(i=0; i<num; i++){
|
||
ntohd(s,d;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_sts_string(s,d)
|
||
** struct dbr_sts_string *s pointer to source struct
|
||
** struct dbr_sts_string *d pointer to destination struct
|
||
** int encode; boolean, if true vax to ieee
|
||
** else ieee to vax
|
||
**
|
||
** converts fields of struct in VAX format to IEEE format
|
||
** or
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format;
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
void cvrt_sts_string(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
void cvrt_sts_string(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_sts_string *pSrc = s;
|
||
struct dbr_sts_string *pDest = d;
|
||
|
||
/* convert ieee to vax format or vax to ieee */
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
if (num == 1) /* if single value */
|
||
strcpy(pDest->value, pSrc->value);
|
||
else
|
||
memcpy(pDest->value, pSrc->value, (MAX_STRING_SIZE * num));
|
||
|
||
}
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_sts_short(s,d)
|
||
** struct dbr_sts_int *s pointer to source struct
|
||
** struct dbr_sts_int *d pointer to destination struct
|
||
** int encode; boolean, if true vax to ieee
|
||
** else ieee to vax
|
||
**
|
||
** converts fields ofstruct in VAX format to ieee format
|
||
** or
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
void cvrt_sts_short(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
void cvrt_sts_short(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_sts_int *pSrc = s;
|
||
struct dbr_sts_int *pDest = d;
|
||
|
||
/* convert vax to ieee or ieee to vax format -- same code*/
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
|
||
if (num == 1) /* single value */
|
||
pDest->value = dbr_ntohs(pSrc->value);
|
||
else /* array chan-- multiple pts */
|
||
{
|
||
cvrt_short(&pSrc->value, &pDest->value, encode, num);
|
||
}
|
||
}
|
||
|
||
/****************************************************************************
|
||
** cvrt_sts_float(s,d)
|
||
** struct dbr_sts_float *s pointer to source struct
|
||
** struct dbr_sts_float *d pointer to destination struct
|
||
** int encode; boolean, if true vax to ieee
|
||
** else ieee to vax
|
||
**
|
||
** if encode
|
||
** converts struct in VAX format to ieee format
|
||
** else
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format;
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
void cvrt_sts_float(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
void cvrt_sts_float(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_sts_float *pSrc = s;
|
||
struct dbr_sts_float *pDest = d;
|
||
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
|
||
cvrt_float(&pSrc->value, &pDest->value, encode, num);
|
||
}
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_sts_double(s,d)
|
||
**
|
||
** if encode
|
||
** converts struct in VAX format to ieee format
|
||
** else
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format;
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_sts_double(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_sts_double(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_sts_double *pSrc = s;
|
||
struct dbr_sts_double *pDest = d;
|
||
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
|
||
cvrt_double(&pSrc->value, &pDest->value, encode, num);
|
||
}
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_sts_enum(s,d)
|
||
** struct dbr_sts_enum *s pointer to source struct
|
||
** struct dbr_sts_enum *d pointer to destination struct
|
||
** int encode; boolean, if true vax to ieee
|
||
** else ieee to vax
|
||
**
|
||
** converts fields of struct in IEEE format to fields with VAX format
|
||
** or
|
||
** converts fields of struct in VAX format to fields with IEEE format
|
||
**
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_sts_enum(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_sts_enum(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T */
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_sts_enum *pSrc = s;
|
||
struct dbr_sts_enum *pDest = d;
|
||
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
memcpy(&pDest->strs, &pSrc->strs, sizeof(pDest->strs));
|
||
if (num == 1)
|
||
d->value = dbr_ntohs(s->value);
|
||
else {
|
||
cvrt_enum(&pSrc->value,&pDest->value,encode,num)
|
||
}
|
||
}
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_gr_short()
|
||
**
|
||
** converts fields of struct in IEEE format to fields with VAX format
|
||
** or
|
||
** converts fields of struct in VAX format to fields with IEEE format
|
||
**
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_gr_short(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_gr_short(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_gr_int *pSrc = s;
|
||
struct dbr_gr_int *pDest = d;
|
||
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
memcpy(pDest->units,pSrc->units,sizeof(pSrc->units));
|
||
|
||
pDest->upper_disp_limit = dbr_ntohs(pSrc->upper_disp_limit);
|
||
pDest->lower_disp_limit = dbr_ntohs(pSrc->lower_disp_limit);
|
||
pDest->upper_alarm_limit = dbr_ntohs(pSrc->upper_alarm_limit);
|
||
pDest->upper_warning_limit = dbr_ntohs(pSrc->upper_warning_limit);
|
||
pDest->lower_alarm_limit = dbr_ntohs(pSrc->lower_alarm_limit);
|
||
pDest->lower_warning_limit = dbr_ntohs(pSrc->lower_warning_limit);
|
||
|
||
if (num == 1)
|
||
pDest->value = dbr_ntohs(pSrc->value);
|
||
else {
|
||
cvrt_short(&pSrc->value, &pDest->value, encode,num);
|
||
}
|
||
}
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_gr_char()
|
||
**
|
||
** converts fields of struct in IEEE format to fields with VAX format
|
||
** or
|
||
** converts fields of struct in VAX format to fields with IEEE format
|
||
**
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_gr_char(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else /*__STDC__*/
|
||
LOCAL void cvrt_gr_char(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif /*__STDC__*/
|
||
{
|
||
struct dbr_gr_char *pSrc = s;
|
||
struct dbr_gr_char *pDest = d;
|
||
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
memcpy(pDest->units,pSrc->units,sizeof(pSrc->units));
|
||
|
||
pDest->upper_disp_limit = pSrc->upper_disp_limit;
|
||
pDest->lower_disp_limit = pSrc->lower_disp_limit;
|
||
pDest->upper_alarm_limit = pSrc->upper_alarm_limit;
|
||
pDest->upper_warning_limit = pSrc->upper_warning_limit;
|
||
pDest->lower_alarm_limit = pSrc->lower_alarm_limit;
|
||
pDest->lower_warning_limit = pSrc->lower_warning_limit;
|
||
|
||
if (num == 1)
|
||
pDest->value = pSrc->value;
|
||
else {
|
||
memcpy(&pDest->value, &pSrc->value, num);
|
||
}
|
||
}
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_gr_long()
|
||
**
|
||
** converts fields of struct in IEEE format to fields with VAX format
|
||
** or
|
||
** converts fields of struct in VAX format to fields with IEEE format
|
||
**
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_gr_long(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_gr_long(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_gr_long *pSrc = s;
|
||
struct dbr_gr_long *pDest = d;
|
||
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
memcpy(pDest->units,pSrc->units,sizeof(pSrc->units));
|
||
|
||
pDest->upper_disp_limit = dbr_ntohl(pSrc->upper_disp_limit);
|
||
pDest->lower_disp_limit = dbr_ntohl(pSrc->lower_disp_limit);
|
||
pDest->upper_alarm_limit = dbr_ntohl(pSrc->upper_alarm_limit);
|
||
pDest->upper_warning_limit = dbr_ntohl(pSrc->upper_warning_limit);
|
||
pDest->lower_alarm_limit = dbr_ntohl(pSrc->lower_alarm_limit);
|
||
pDest->lower_warning_limit = dbr_ntohl(pSrc->lower_warning_limit);
|
||
|
||
if (num == 1)
|
||
pDest->value = dbr_ntohl(pSrc->value);
|
||
else {
|
||
cvrt_long(&pSrc->value, &pDest->value, encode, num);
|
||
}
|
||
}
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_gr_enum(s,d)
|
||
**
|
||
** if encode
|
||
** converts struct in VAX format to ieee format
|
||
** else
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format;
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_gr_enum(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_gr_enum(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_gr_enum *pSrc = s;
|
||
struct dbr_gr_enum *pDest = d;
|
||
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
pDest->no_str = dbr_ntohs(pSrc->no_str);
|
||
memcpy(pDest->strs,pSrc->strs,sizeof(pSrc->strs));
|
||
|
||
if (num == 1) /* single value */
|
||
pDest->value = dbr_ntohs(pSrc->value);
|
||
else /* array chan-- multiple pts */
|
||
{
|
||
cvrt_enum(&(pSrc->value), &(pDest->value), encode, num);
|
||
}
|
||
}
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_gr_double(s,d)
|
||
**
|
||
** if encode
|
||
** converts struct in VAX format to ieee format
|
||
** else
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format;
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_gr_double(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_gr_double(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_gr_double *pSrc = s;
|
||
struct dbr_gr_double *pDest = d;
|
||
|
||
/* these are same for vax to ieee or ieee to vax */
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
pDest->precision = dbr_ntohs(pSrc->precision);
|
||
memcpy(pDest->units,pSrc->units,sizeof(pSrc->units));
|
||
|
||
if (encode) /* vax to ieee convert */
|
||
{
|
||
if (num == 1){
|
||
htond(&s->value, &d->value);
|
||
}
|
||
else {
|
||
cvrt_double(&pSrc->value, &pDest->value, encode,num);
|
||
}
|
||
htond(&pSrc->upper_disp_limit,&pDest->upper_disp_limit);
|
||
htond(&pSrc->lower_disp_limit, &pDest->lower_disp_limit);
|
||
htond(&pSrc->upper_alarm_limit, &pDest->upper_alarm_limit);
|
||
htond(&pSrc->upper_warning_limit, &pDest->upper_warning_limit);
|
||
htond(&pSrc->lower_alarm_limit, &pDest->lower_alarm_limit);
|
||
htond(&pSrc->lower_warning_limit, &pDest->lower_warning_limit);
|
||
}
|
||
else /* ieee to vax convert */
|
||
{
|
||
if (num == 1){
|
||
ntohd(&pSrc->value, &pDest->value);
|
||
}
|
||
else {
|
||
cvrt_double(&pSrc->value, &pDest->value, encode,num);
|
||
}
|
||
ntohd(&pSrc->upper_disp_limit,&pDest->upper_disp_limit);
|
||
ntohd(&pSrc->lower_disp_limit, &pDest->lower_disp_limit);
|
||
ntohd(&pSrc->upper_alarm_limit, &pDest->upper_alarm_limit);
|
||
ntohd(&pSrc->upper_warning_limit, &pDest->upper_warning_limit);
|
||
ntohd(&pSrc->lower_alarm_limit, &pDest->lower_alarm_limit);
|
||
ntohd(&pSrc->lower_warning_limit, &pDest->lower_warning_limit);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_gr_float(s,d)
|
||
** struct dbr_gr_float *d pointer to destination struct
|
||
** int encode; boolean, if true vax to ieee
|
||
** else ieee to vax
|
||
**
|
||
** if encode
|
||
** converts struct in VAX format to ieee format
|
||
** else
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format;
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_gr_float(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_gr_float(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_gr_float *pSrc = s;
|
||
struct dbr_gr_float *pDest = d;
|
||
|
||
/* these are same for vax to ieee or ieee to vax */
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
pDest->precision = dbr_ntohs(pSrc->precision);
|
||
memcpy(pDest->units,pSrc->units,sizeof(pSrc->units));
|
||
|
||
if (encode) /* vax to ieee convert */
|
||
{
|
||
if (num == 1){
|
||
htonf(&s->value, &d->value);
|
||
}
|
||
else {
|
||
cvrt_float(&pSrc->value, &pDest->value, encode,num);
|
||
}
|
||
htonf(&pSrc->upper_disp_limit,&pDest->upper_disp_limit);
|
||
htonf(&pSrc->lower_disp_limit, &pDest->lower_disp_limit);
|
||
htonf(&pSrc->upper_alarm_limit, &pDest->upper_alarm_limit);
|
||
htonf(&pSrc->upper_warning_limit, &pDest->upper_warning_limit);
|
||
htonf(&pSrc->lower_alarm_limit, &pDest->lower_alarm_limit);
|
||
htonf(&pSrc->lower_warning_limit, &pDest->lower_warning_limit);
|
||
}
|
||
else /* ieee to vax convert */
|
||
{
|
||
if (num == 1){
|
||
ntohf(&pSrc->value, &pDest->value);
|
||
}
|
||
else {
|
||
cvrt_float(&pSrc->value, &pDest->value, encode,num);
|
||
}
|
||
ntohf(&pSrc->upper_disp_limit,&pDest->upper_disp_limit);
|
||
ntohf(&pSrc->lower_disp_limit, &pDest->lower_disp_limit);
|
||
ntohf(&pSrc->upper_alarm_limit, &pDest->upper_alarm_limit);
|
||
ntohf(&pSrc->upper_warning_limit, &pDest->upper_warning_limit);
|
||
ntohf(&pSrc->lower_alarm_limit, &pDest->lower_alarm_limit);
|
||
ntohf(&pSrc->lower_warning_limit, &pDest->lower_warning_limit);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_ctrl_short(s,d)
|
||
** struct dbr_gr_int *s pointer to source struct
|
||
** struct dbr_gr_int *d pointer to destination struct
|
||
** int encode; boolean, if true vax to ieee
|
||
** else ieee to vax
|
||
**
|
||
** converts fields of struct in IEEE format to fields with VAX format
|
||
** or
|
||
** converts fields of struct in VAX format to fields with IEEE format
|
||
**
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_ctrl_short(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_ctrl_short(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_ctrl_int *pSrc = s;
|
||
struct dbr_ctrl_int *pDest = d;
|
||
|
||
/* vax to ieee or ieee to vax -- same code */
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
memcpy(pDest->units,pSrc->units,sizeof(pSrc->units));
|
||
|
||
pDest->upper_disp_limit = dbr_ntohs(pSrc->upper_disp_limit);
|
||
pDest->lower_disp_limit = dbr_ntohs(pSrc->lower_disp_limit);
|
||
pDest->upper_alarm_limit = dbr_ntohs(pSrc->upper_alarm_limit);
|
||
pDest->upper_warning_limit = dbr_ntohs(pSrc->upper_warning_limit);
|
||
pDest->lower_alarm_limit = dbr_ntohs(pSrc->lower_alarm_limit);
|
||
pDest->lower_warning_limit = dbr_ntohs(pSrc->lower_warning_limit);
|
||
pDest->lower_ctrl_limit = dbr_ntohs(pSrc->lower_ctrl_limit);
|
||
pDest->upper_ctrl_limit = dbr_ntohs(pSrc->upper_ctrl_limit);
|
||
|
||
if (num == 1)
|
||
pDest->value = dbr_ntohs(pSrc->value);
|
||
else {
|
||
cvrtshort(&pSrc->value, &pDest->value, encode, num);
|
||
}
|
||
}
|
||
|
||
/****************************************************************************
|
||
** cvrt_ctrl_long(s,d)
|
||
**
|
||
** converts fields of struct in IEEE format to fields with VAX format
|
||
** or
|
||
** converts fields of struct in VAX format to fields with IEEE format
|
||
**
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_ctrl_long(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_ctrl_long(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_ctrl_long *pSrc = s;
|
||
struct dbr_ctrl_long *pDest = d;
|
||
|
||
/* vax to ieee or ieee to vax -- same code */
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
memcpy(pDest->units,pSrc->units,sizeof(pSrc->units));
|
||
|
||
pDest->upper_disp_limit = dbr_ntohl(pSrc->upper_disp_limit);
|
||
pDest->lower_disp_limit = dbr_ntohl(pSrc->lower_disp_limit);
|
||
pDest->upper_alarm_limit = dbr_ntohl(pSrc->upper_alarm_limit);
|
||
pDest->upper_warning_limit = dbr_ntohl(pSrc->upper_warning_limit);
|
||
pDest->lower_alarm_limit = dbr_ntohl(pSrc->lower_alarm_limit);
|
||
pDest->lower_warning_limit = dbr_ntohl(pSrc->lower_warning_limit);
|
||
pDest->lower_ctrl_limit = dbr_ntohl(pSrc->lower_ctrl_limit);
|
||
pDest->upper_ctrl_limit = dbr_ntohl(pSrc->upper_ctrl_limit);
|
||
|
||
if (num == 1)
|
||
pDest->value = dbr_ntohl(pSrc->value);
|
||
else {
|
||
cvrtlong(&pSrc->value, &pDest->value, encode, num);
|
||
}
|
||
}
|
||
|
||
/****************************************************************************
|
||
** cvrt_ctrl_short(s,d)
|
||
**
|
||
** converts fields of struct in IEEE format to fields with VAX format
|
||
** or
|
||
** converts fields of struct in VAX format to fields with IEEE format
|
||
**
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_ctrl_char(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_ctrl_char(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_ctrl_char *pSrc = s;
|
||
struct dbr_ctrl_char *pDest = d;
|
||
|
||
/* vax to ieee or ieee to vax -- same code */
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
|
||
pDest->upper_disp_limit = pSrc->upper_disp_limit;
|
||
pDest->lower_disp_limit = pSrc->lower_disp_limit;
|
||
pDest->upper_alarm_limit = pSrc->upper_alarm_limit;
|
||
pDest->upper_warning_limit = pSrc->upper_warning_limit;
|
||
pDest->lower_ctrl_limit = pSrc->lower_ctrl_limit;
|
||
pDest->upper_ctrl_limit = pSrc->upper_ctrl_limit;
|
||
|
||
if (num == 1)
|
||
pDest->value = pSrc->value;
|
||
else {
|
||
memcpy(&pDest->value, &pSrc->value, num);
|
||
}
|
||
}
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_ctrl_double(s,d)
|
||
**
|
||
** if encode
|
||
** converts struct in VAX format to ieee format
|
||
** else
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format;
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_ctrl_double(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_ctrl_double(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_ctrl_double *pSrc = s;
|
||
struct dbr_ctrl_double *pDest = d;
|
||
|
||
/* these are the same for ieee to vaax or vax to ieee */
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
pDest->precision = dbr_ntohs(pSrc->precision);
|
||
memcpy(pDest->units,pSrc->units,sizeof(pSrc->units));
|
||
if (encode) /* vax to ieee convert */
|
||
{
|
||
if (num == 1){
|
||
htond(&pSrc->value, &pDest->value);
|
||
}
|
||
else {
|
||
cvrt_double(&pSrc->value, &pDest->value, encode, num);
|
||
}
|
||
htond(&pSrc->upper_disp_limit,&pDest->upper_disp_limit);
|
||
htond(&pSrc->lower_disp_limit, &pDest->lower_disp_limit);
|
||
htond(&pSrc->upper_alarm_limit, &pDest->upper_alarm_limit);
|
||
htond(&pSrc->upper_warning_limit, &pDest->upper_warning_limit);
|
||
htond(&pSrc->lower_alarm_limit, &pDest->lower_alarm_limit);
|
||
htond(&pSrc->lower_warning_limit, &pDest->lower_warning_limit);
|
||
htond(&pSrc->lower_ctrl_limit, &pDest->lower_ctrl_limit);
|
||
htond(&pSrc->upper_ctrl_limit, &pDest->upper_ctrl_limit);
|
||
}
|
||
else /* ieee to vax convert */
|
||
{
|
||
if (num == 1){
|
||
ntohd(&pSrc->value, &pDest->value);
|
||
}
|
||
else {
|
||
cvrt_double(&pSrc->value, &pDest->value, encode, num);
|
||
}
|
||
ntohd(&pSrc->lower_disp_limit, &pDest->lower_disp_limit);
|
||
ntohd(&pSrc->upper_alarm_limit, &pDest->upper_alarm_limit);
|
||
ntohd(&pSrc->upper_warning_limit, &pDest->upper_warning_limit);
|
||
ntohd(&pSrc->lower_alarm_limit, &pDest->lower_alarm_limit);
|
||
ntohd(&pSrc->lower_warning_limit, &pDest->lower_warning_limit);
|
||
ntohd(&pSrc->lower_ctrl_limit, &pDest->lower_ctrl_limit);
|
||
ntohd(&pSrc->upper_ctrl_limit, &pDest->upper_ctrl_limit);
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_ctrl_float(s,d)
|
||
**
|
||
** if encode
|
||
** converts struct in VAX format to ieee format
|
||
** else
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format;
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_ctrl_float(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_ctrl_float(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_ctrl_float *pSrc = s;
|
||
struct dbr_ctrl_float *pDest = d;
|
||
|
||
/* these are the same for ieee to vaax or vax to ieee */
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
pDest->precision = dbr_ntohs(pSrc->precision);
|
||
memcpy(pDest->units,pSrc->units,sizeof(pSrc->units));
|
||
if (encode) /* vax to ieee convert */
|
||
{
|
||
if (num == 1){
|
||
htonf(&pSrc->value, &pDest->value);
|
||
}
|
||
else {
|
||
cvrt_float(&pSrc->value, &pDest->value, encode, num);
|
||
}
|
||
htonf(&pSrc->upper_disp_limit,&pDest->upper_disp_limit);
|
||
htonf(&pSrc->lower_disp_limit, &pDest->lower_disp_limit);
|
||
htonf(&pSrc->upper_alarm_limit, &pDest->upper_alarm_limit);
|
||
htonf(&pSrc->upper_warning_limit, &pDest->upper_warning_limit);
|
||
htonf(&pSrc->lower_alarm_limit, &pDest->lower_alarm_limit);
|
||
htonf(&pSrc->lower_warning_limit, &pDest->lower_warning_limit);
|
||
htonf(&pSrc->lower_ctrl_limit, &pDest->lower_ctrl_limit);
|
||
htonf(&pSrc->upper_ctrl_limit, &pDest->upper_ctrl_limit);
|
||
}
|
||
else /* ieee to vax convert */
|
||
{
|
||
if (num == 1){
|
||
ntohf(&pSrc->value, &pDest->value);
|
||
}
|
||
else {
|
||
cvrt_float(&pSrc->value, &pDest->value, encode, num);
|
||
}
|
||
ntohf(&pSrc->lower_disp_limit, &pDest->lower_disp_limit);
|
||
ntohf(&pSrc->upper_alarm_limit, &pDest->upper_alarm_limit);
|
||
ntohf(&pSrc->upper_warning_limit, &pDest->upper_warning_limit);
|
||
ntohf(&pSrc->lower_alarm_limit, &pDest->lower_alarm_limit);
|
||
ntohf(&pSrc->lower_warning_limit, &pDest->lower_warning_limit);
|
||
ntohf(&pSrc->lower_ctrl_limit, &pDest->lower_ctrl_limit);
|
||
ntohf(&pSrc->upper_ctrl_limit, &pDest->upper_ctrl_limit);
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_ctrl_enum(s,d)
|
||
**
|
||
** if encode
|
||
** converts struct in VAX format to ieee format
|
||
** else
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format;
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_ctrl_enum(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_ctrl_enum(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_ctrl_enum *pSrc = s;
|
||
struct dbr_ctrl_enum *pDest = d;
|
||
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
pDest->no_str = dbr_ntohs(pSrc->no_str);
|
||
memcpy(pDest->strs,pSrc->strs,sizeof(pSrc->strs));
|
||
|
||
if (num == 1) /* single value */
|
||
pDest->value = dbr_ntohs(pSrc->value);
|
||
else /* array chan-- multiple pts */
|
||
{
|
||
cvrt_enum(&(pSrc->value), &(pDest->value), encode, num);
|
||
}
|
||
}
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_sts_char(s,d)
|
||
** struct dbr_sts_int *s pointer to source struct
|
||
** struct dbr_sts_int *d pointer to destination struct
|
||
** int encode; boolean, if true vax to ieee
|
||
** else ieee to vax
|
||
**
|
||
** converts fields ofstruct in VAX format to ieee format
|
||
** or
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_sts_char(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_sts_char(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_sts_char *pSrc = s;
|
||
struct dbr_sts_char *pDest = d;
|
||
|
||
/* convert vax to ieee or ieee to vax format -- same code*/
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
|
||
if (num == 1) /* single value */
|
||
pDest->value = pSrc->value;
|
||
else /* array chan-- multiple pts */
|
||
{
|
||
memcpy(&pDest->value, &pSrc->value, num);
|
||
}
|
||
}
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_sts_long(s,d)
|
||
**
|
||
** converts fields ofstruct in VAX format to ieee format
|
||
** or
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_sts_long(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_sts_long(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_sts_long *pSrc = s;
|
||
struct dbr_sts_long *pDest = d;
|
||
|
||
/* convert vax to ieee or ieee to vax format -- same code*/
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
|
||
if (num == 1) /* single value */
|
||
pDest->value = dbr_ntohl(pSrc->value);
|
||
else /* array chan-- multiple pts */
|
||
{
|
||
cvrt_long(&pDest->value, &pSrc->value, encode, num);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_time_string(s,d)
|
||
**
|
||
** converts fields of struct in VAX format to IEEE format
|
||
** or
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format;
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_time_string(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_time_string(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_time_string *pSrc = s;
|
||
struct dbr_time_string *pDest = d;
|
||
|
||
/* convert ieee to vax format or vax to ieee */
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
pDest->stamp.secPastEpoch = dbr_ntohl(pSrc->stamp.secPastEpoch);
|
||
pDest->stamp.nsec = dbr_ntohl(pSrc->stamp.nsec);
|
||
|
||
if (num == 1) /* if single value */
|
||
strcpy(pDest->value, pSrc->value);
|
||
else
|
||
memcpy(pDest->value, pSrc->value, (MAX_STRING_SIZE * num));
|
||
|
||
}
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_time_short(s,d)
|
||
**
|
||
** converts fields ofstruct in VAX format to ieee format
|
||
** or
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_time_short(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_time_short(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_time_int *pSrc = s;
|
||
struct dbr_time_int *pDest = d;
|
||
|
||
/* convert vax to ieee or ieee to vax format -- same code*/
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
pDest->stamp.secPastEpoch = dbr_ntohl(pSrc->stamp.secPastEpoch);
|
||
pDest->stamp.nsec = dbr_ntohl(pSrc->stamp.nsec);
|
||
|
||
if (num == 1) /* single value */
|
||
pDest->value = dbr_ntohs(pSrc->value);
|
||
else /* array chan-- multiple pts */
|
||
{
|
||
cvrt_short(&pSrc->value, &pDest->value, encode, num);
|
||
}
|
||
}
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_time_float(s,d)
|
||
**
|
||
** if encode
|
||
** converts struct in VAX format to ieee format
|
||
** else
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format;
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_time_float(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
cvrt_time_float(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_time_float *pSrc = s;
|
||
struct dbr_time_float *pDest = d;
|
||
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
pDest->stamp.secPastEpoch = dbr_ntohl(pSrc->stamp.secPastEpoch);
|
||
pDest->stamp.nsec = dbr_ntohl(pSrc->stamp.nsec);
|
||
|
||
cvrt_float(&pSrc->value, &pDest->value, encode, num);
|
||
}
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_time_double(s,d)
|
||
**
|
||
** if encode
|
||
** converts struct in VAX format to ieee format
|
||
** else
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format;
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_time_double(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
cvrt_time_double(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_time_double *pSrc = s;
|
||
struct dbr_time_double *pDest = d;
|
||
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
pDest->stamp.secPastEpoch = dbr_ntohl(pSrc->stamp.secPastEpoch);
|
||
pDest->stamp.nsec = dbr_ntohl(pSrc->stamp.nsec);
|
||
|
||
cvrt_double(&pSrc->value, &pDest->value, encode, num);
|
||
}
|
||
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_time_string(s,d)
|
||
**
|
||
** converts fields of struct in VAX format to IEEE format
|
||
** or
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format;
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_time_string(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_time_string(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_time_string *pSrc = s;
|
||
struct dbr_time_string *pDest = d;
|
||
|
||
/* convert ieee to vax format or vax to ieee */
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
pDest->stamp.secPastEpoch = dbr_ntohl(pSrc->stamp.secPastEpoch);
|
||
pDest->stamp.nsec = dbr_ntohl(pSrc->stamp.nsec);
|
||
if (num == 1) /* if single value */
|
||
strcpy(pDest->value, pSrc->value);
|
||
else
|
||
memcpy(pDest->value, pSrc->value, MAX_STRING_SIZE*num);
|
||
|
||
}
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_time_short(s,d)
|
||
**
|
||
** converts fields ofstruct in VAX format to ieee format
|
||
** or
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_time_short(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_time_short(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_time_int *pSrc = s;
|
||
struct dbr_time_int *pDest = d;
|
||
|
||
/* convert vax to ieee or ieee to vax format -- same code*/
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
pDest->stamp.secPastEpoch = dbr_ntohl(pSrc->stamp.secPastEpoch);
|
||
pDest->stamp.nsec = dbr_ntohl(pSrc->stamp.nsec);
|
||
|
||
if (num == 1) /* single value */
|
||
pDest->value = dbr_ntohs(pSrc->value);
|
||
else /* array chan-- multiple pts */
|
||
{
|
||
cvrt_short(&pSrc->value, &pDest->value, encode, num);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_time_enum(s,d)
|
||
**
|
||
** converts fields of struct in IEEE format to fields with VAX format
|
||
** or
|
||
** converts fields of struct in VAX format to fields with IEEE format
|
||
**
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_time_enum(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else /*__STDC__*/
|
||
LOCAL void cvrt_time_enum(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif /*__STDC__*/
|
||
{
|
||
struct dbr_time_enum *pSrc = s;
|
||
struct dbr_time_enum *pDest = d;
|
||
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
pDest->stamp.secPastEpoch = dbr_ntohl(pSrc->stamp.secPastEpoch);
|
||
pDest->stamp.nsec = dbr_ntohl(pSrc->stamp.nsec);
|
||
if (num == 1)
|
||
d->value = dbr_ntohs(s->value);
|
||
else {
|
||
cvrt_enum(&pSrc->value,&pDest->value,encode,num)
|
||
}
|
||
}
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_sts_char(s,d)
|
||
**
|
||
** converts fields ofstruct in VAX format to ieee format
|
||
** or
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_time_char(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_time_char(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_time_char *pSrc = s;
|
||
struct dbr_time_char *pDest = d;
|
||
|
||
/* convert vax to ieee or ieee to vax format -- same code*/
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
pDest->stamp.secPastEpoch = dbr_ntohl(pSrc->stamp.secPastEpoch);
|
||
pDest->stamp.nsec = dbr_ntohl(pSrc->stamp.nsec);
|
||
|
||
if (num == 1) /* single value */
|
||
pDest->value = pSrc->value;
|
||
else /* array chan-- multiple pts */
|
||
{
|
||
memcpy(&pDest->value, &pSrc->value, num);
|
||
}
|
||
}
|
||
|
||
/****************************************************************************
|
||
** cvrt_time_long(s,d)
|
||
**
|
||
** converts fields ofstruct in VAX format to ieee format
|
||
** or
|
||
** converts fields of struct in IEEE format to fields with VAX
|
||
** format
|
||
****************************************************************************/
|
||
|
||
#ifdef __STDC__
|
||
LOCAL void cvrt_time_long(
|
||
void *s, /* source */
|
||
void *d, /* destination */
|
||
int encode, /* cvrt VAX to IEEE if T */
|
||
unsigned long num /* number of values */
|
||
)
|
||
#else
|
||
LOCAL void cvrt_time_long(s,d,encode,num)
|
||
void *s; /* source */
|
||
void *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
unsigned long num; /* number of values */
|
||
#endif
|
||
{
|
||
struct dbr_time_long *pSrc = s;
|
||
struct dbr_time_long *pDest = d;
|
||
|
||
/* convert vax to ieee or ieee to vax format -- same code*/
|
||
pDest->status = dbr_ntohs(pSrc->status);
|
||
pDest->severity = dbr_ntohs(pSrc->severity);
|
||
pDest->stamp.secPastEpoch = dbr_ntohl(pSrc->stamp.secPastEpoch);
|
||
pDest->stamp.nsec = dbr_ntohl(pSrc->stamp.nsec);
|
||
|
||
if (num == 1) /* single value */
|
||
pDest->value = dbr_ntohl(pSrc->value);
|
||
else /* array chan-- multiple pts */
|
||
{
|
||
cvrt_long(&pDest->value, &pSrc->value, encode, num);
|
||
}
|
||
}
|
||
|
||
|