744 lines
17 KiB
C
744 lines
17 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
|
||
*
|
||
*
|
||
*/
|
||
|
||
|
||
|
||
#include <db_access.h>
|
||
#include <net_convert.h>
|
||
|
||
#ifdef vxWorks
|
||
# define memcpy(D,S,N) bcopy(S,D,N)
|
||
# define memset(D,V,N) bfill(D,N,V)
|
||
#endif
|
||
|
||
|
||
/*
|
||
* Routine we will do later
|
||
*
|
||
*
|
||
*
|
||
*/
|
||
no_cvrt()
|
||
{
|
||
printf("Sorry, conversion for that type currently not implemented\n");
|
||
exit();
|
||
}
|
||
cvrt_sts_char() {no_cvrt();}
|
||
cvrt_sts_long() {no_cvrt();}
|
||
cvrt_sts_double() {no_cvrt();}
|
||
|
||
cvrt_time_string() {no_cvrt();}
|
||
cvrt_time_short() {no_cvrt();}
|
||
cvrt_time_float() {no_cvrt();}
|
||
cvrt_time_enum() {no_cvrt();}
|
||
cvrt_time_char() {no_cvrt();}
|
||
cvrt_time_long() {no_cvrt();}
|
||
cvrt_time_double() {no_cvrt();}
|
||
|
||
cvrt_gr_char() {no_cvrt();}
|
||
cvrt_gr_double() {no_cvrt();}
|
||
cvrt_gr_long() {no_cvrt();}
|
||
cvrt_gr_string() {no_cvrt();}
|
||
cvrt_gr_enum() {no_cvrt();}
|
||
|
||
cvrt_ctrl_char() {no_cvrt();}
|
||
cvrt_ctrl_long() {no_cvrt();}
|
||
cvrt_ctrl_string() {no_cvrt();}
|
||
cvrt_ctrl_double() {no_cvrt();}
|
||
|
||
|
||
|
||
|
||
|
||
/*
|
||
* CVRT_SHORT()
|
||
*
|
||
*
|
||
*
|
||
*
|
||
*/
|
||
cvrt_short(s,d,encode,num)
|
||
short *s; /* source */
|
||
short *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T */
|
||
int num; /* number of values */
|
||
{
|
||
unsigned int i;
|
||
|
||
for(i=0; i<num; i++){
|
||
*d++ = ntohs( *s++ );
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
|
||
/*
|
||
* CVRT_CHAR()
|
||
*
|
||
*
|
||
*
|
||
*
|
||
*/
|
||
cvrt_char(s,d,encode,num)
|
||
char *s; /* source */
|
||
char *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T */
|
||
int num; /* number of values */
|
||
{
|
||
unsigned int i;
|
||
|
||
for(i=0; i<num; i++){
|
||
*d++ = *s++;
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
|
||
/*
|
||
* CVRT_LONG()
|
||
*
|
||
*
|
||
*
|
||
*
|
||
*/
|
||
cvrt_long(s,d,encode,num)
|
||
long *s; /* source */
|
||
long *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T */
|
||
int num; /* number of values */
|
||
{
|
||
unsigned int i;
|
||
|
||
for(i=0; i<num; i++){
|
||
*d++ = ntohl( *s++ );
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
|
||
/*
|
||
* CVRT_ENUM()
|
||
*
|
||
*
|
||
*
|
||
*
|
||
*/
|
||
cvrt_enum(s,d,encode,num)
|
||
short *s; /* source */
|
||
short *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T */
|
||
int num; /* number of values */
|
||
{
|
||
unsigned int i;
|
||
|
||
for(i=0; i<num; i++){
|
||
*d++ = ntohs(*s++);
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
|
||
/*
|
||
* CVRT_FLOAT()
|
||
*
|
||
*
|
||
* NOTES:
|
||
* placing encode outside the loop results in more
|
||
* code but better performance.
|
||
*
|
||
*/
|
||
cvrt_float(s,d,encode,num)
|
||
float *s; /* source */
|
||
float *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T*/
|
||
int num; /* number of values */
|
||
{
|
||
unsigned int i;
|
||
|
||
for(i=0; i<num; i++){
|
||
if(encode){
|
||
htonf(s, d);
|
||
}
|
||
else{
|
||
ntohf(s, d);
|
||
}
|
||
/*
|
||
* incrementing these inside the MACRO could be unhealthy
|
||
*/
|
||
s++;
|
||
d++;
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
|
||
|
||
/*
|
||
* CVRT_DOUBLE()
|
||
*
|
||
*
|
||
*
|
||
*
|
||
*/
|
||
cvrt_double(s,d,encode,num)
|
||
double *s; /* source */
|
||
double *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T */
|
||
int num; /* number of values */
|
||
{
|
||
unsigned int i;
|
||
|
||
printf("CA: sorry no code for conversions of doubles\n");
|
||
printf("CA: setting your variable to nill\n");
|
||
for(i=0; i<num; i++){
|
||
*d++ = 0.0;
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
|
||
|
||
/*
|
||
* CVRT_STRING()
|
||
*
|
||
*
|
||
*
|
||
*
|
||
*/
|
||
cvrt_string(s,d,encode,num)
|
||
char *s; /* source */
|
||
char *d; /* destination */
|
||
int encode; /* cvrt VAX to IEEE if T */
|
||
int num; /* number of values */
|
||
{
|
||
unsigned int i;
|
||
|
||
if(num == 1)
|
||
strcpy(d, s);
|
||
else
|
||
memcpy(d, s, (MAX_STRING_SIZE * num));
|
||
return 1;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/****************************************************************************
|
||
** 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;
|
||
****************************************************************************/
|
||
|
||
cvrt_sts_string(s,d,encode,num)
|
||
struct dbr_sts_string *s; /* source */
|
||
struct dbr_sts_string *d; /* destination */
|
||
int encode; /* do VAX to IEEE */
|
||
int num; /* number of values */
|
||
{
|
||
|
||
/* convert ieee to vax format or vax to ieee */
|
||
d->status = ntohs(s->status);
|
||
d->severity = ntohs(s->severity);
|
||
if (num == 1) /* if single value */
|
||
strcpy(d->value,s->value);
|
||
else
|
||
memcpy(d->value,s->value,(MAX_STRING_SIZE * num));
|
||
|
||
return 1;
|
||
}
|
||
|
||
|
||
/****************************************************************************
|
||
** 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
|
||
****************************************************************************/
|
||
|
||
cvrt_sts_short(s,d,encode,num)
|
||
struct dbr_sts_int *s; /* source */
|
||
struct dbr_sts_int *d; /* destination */
|
||
int encode; /* if true, vax to ieee */
|
||
int num; /* number of values */
|
||
{
|
||
register i;
|
||
short *sval_ptr,*dval_ptr; /* ptrs to source, destination */
|
||
|
||
/* convert vax to ieee or ieee to vax format -- same code*/
|
||
d->status = ntohs(s->status);
|
||
d->severity = ntohs(s->severity);
|
||
|
||
if (num == 1) /* single value */
|
||
d->value = ntohs(s->value);
|
||
else /* array chan-- multiple pts */
|
||
{
|
||
sval_ptr = &(s->value);
|
||
dval_ptr = &(d->value);
|
||
for (i = 0; i < num; i++){
|
||
*dval_ptr = ntohs(*sval_ptr);
|
||
sval_ptr++;
|
||
dval_ptr++;
|
||
}
|
||
}
|
||
|
||
|
||
return 1;
|
||
}
|
||
|
||
|
||
|
||
|
||
/****************************************************************************
|
||
** 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;
|
||
****************************************************************************/
|
||
|
||
cvrt_sts_float(s,d,encode,num)
|
||
struct dbr_sts_float *s; /* source */
|
||
struct dbr_sts_float *d; /* destination */
|
||
int encode; /* it true, vax to ieee */
|
||
int num; /* number of values */
|
||
{
|
||
register i;
|
||
float *sval_ptr,*dval_ptr;
|
||
|
||
d->status = ntohs(s->status);
|
||
d->severity = ntohs(s->severity);
|
||
|
||
if(encode) /* vax to ieee convert */
|
||
if(num == 1){
|
||
htonf(&s->value, &d->value);
|
||
}
|
||
else
|
||
{
|
||
sval_ptr = &(s->value);
|
||
dval_ptr = &(d->value);
|
||
for (i = 0;i < num; i++){
|
||
htonf(sval_ptr,dval_ptr);
|
||
sval_ptr++;
|
||
dval_ptr++;
|
||
}
|
||
}
|
||
|
||
else /* ieee to vax convert */
|
||
if(num == 1){
|
||
ntohf(&s->value,&d->value);
|
||
}
|
||
else
|
||
{
|
||
sval_ptr = &(s->value);
|
||
dval_ptr = &(d->value);
|
||
for (i = 0;i < num; i++){
|
||
ntohf(sval_ptr,dval_ptr);
|
||
dval_ptr++;
|
||
sval_ptr++;
|
||
}
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
|
||
|
||
|
||
|
||
/****************************************************************************
|
||
** 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
|
||
**
|
||
****************************************************************************/
|
||
|
||
cvrt_sts_enum(s,d,encode,num)
|
||
struct dbr_sts_enum *s; /* source */
|
||
struct dbr_sts_enum *d; /* destination */
|
||
int encode; /* if true, vax to ieee */
|
||
int num; /* number of values */
|
||
{
|
||
register i;
|
||
short *dval_ptr,*sval_ptr;
|
||
|
||
/* convert vax to ieee or ieee to vax --same code */
|
||
d->status = ntohs(s->status);
|
||
d->severity = ntohs(s->severity);
|
||
if (num == 1)
|
||
d->value = ntohs(s->value);
|
||
else {
|
||
sval_ptr = &(s->value);
|
||
dval_ptr = &(d->value);
|
||
for (i = 0; i < num; i++){
|
||
*dval_ptr = ntohs(*sval_ptr);
|
||
dval_ptr++;
|
||
sval_ptr++;
|
||
}
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_gr_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
|
||
**
|
||
****************************************************************************/
|
||
|
||
cvrt_gr_short(s,d,encode,num)
|
||
struct dbr_gr_int *s; /* source */
|
||
struct dbr_gr_int *d; /* destination */
|
||
int encode; /* if true, vax to ieee */
|
||
int num; /* number of values */
|
||
{
|
||
register i;
|
||
short *sval_ptr,*dval_ptr;
|
||
|
||
/* convert ieee to vax or vax to ieee -- same code */
|
||
d->status = ntohs(s->status);
|
||
d->severity = ntohs(s->severity);
|
||
strcpy(d->units,s->units);
|
||
|
||
d->upper_disp_limit = ntohs(s->upper_disp_limit);
|
||
d->lower_disp_limit = ntohs(s->lower_disp_limit);
|
||
d->upper_alarm_limit = ntohs(s->upper_alarm_limit);
|
||
d->upper_warning_limit = ntohs(s->upper_warning_limit);
|
||
d->lower_alarm_limit = ntohs(s->lower_alarm_limit);
|
||
d->lower_warning_limit = ntohs(s->lower_warning_limit);
|
||
|
||
if (num == 1)
|
||
d->value = ntohs(s->value);
|
||
else {
|
||
sval_ptr = &(s->value);
|
||
dval_ptr = &(d->value);
|
||
for (i = 0;i < num; i++){
|
||
*dval_ptr = ntohs(*sval_ptr);
|
||
dval_ptr++;
|
||
sval_ptr++;
|
||
}
|
||
}
|
||
|
||
|
||
return 1;
|
||
}
|
||
|
||
|
||
|
||
|
||
/****************************************************************************
|
||
** 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;
|
||
****************************************************************************/
|
||
|
||
cvrt_gr_float(s,d,encode,num)
|
||
struct dbr_gr_float *s; /* source */
|
||
struct dbr_gr_float *d; /* destination */
|
||
int encode; /* if true, vax to ieee */
|
||
int num; /* number of values */
|
||
{
|
||
register i;
|
||
float *sval_ptr,*dval_ptr;
|
||
|
||
/* these are same for vax to ieee or ieee to vax */
|
||
d->status = ntohs(s->status);
|
||
d->severity = ntohs(s->severity);
|
||
d->precision = ntohs(s->precision);
|
||
strcpy(d->units,s->units);
|
||
|
||
if (encode) /* vax to ieee convert */
|
||
{
|
||
if (num == 1){
|
||
htonf(&s->value, &d->value);
|
||
}
|
||
else {
|
||
sval_ptr = &(s->value);
|
||
dval_ptr = &(d->value);
|
||
for (i = 0;i < num; i++){
|
||
htonf(sval_ptr,dval_ptr);
|
||
dval_ptr++;
|
||
sval_ptr++;
|
||
}
|
||
}
|
||
htonf(&s->upper_disp_limit,&d->upper_disp_limit);
|
||
htonf(&s->lower_disp_limit, &d->lower_disp_limit);
|
||
htonf(&s->upper_alarm_limit, &d->upper_alarm_limit);
|
||
htonf(&s->upper_warning_limit, &d->upper_warning_limit);
|
||
htonf(&s->lower_alarm_limit, &d->lower_alarm_limit);
|
||
htonf(&s->lower_warning_limit, &d->lower_warning_limit);
|
||
}
|
||
else /* ieee to vax convert */
|
||
{
|
||
if (num == 1){
|
||
ntohf(&s->value, &d->value);
|
||
}
|
||
else {
|
||
sval_ptr = &(s->value);
|
||
dval_ptr = &(d->value);
|
||
for (i = 0;i < num; i++){
|
||
ntohf(sval_ptr,dval_ptr);
|
||
dval_ptr++;
|
||
sval_ptr++;
|
||
}
|
||
}
|
||
ntohf(&s->upper_disp_limit,&d->upper_disp_limit);
|
||
ntohf(&s->lower_disp_limit, &d->lower_disp_limit);
|
||
ntohf(&s->upper_alarm_limit, &d->upper_alarm_limit);
|
||
ntohf(&s->upper_warning_limit, &d->upper_warning_limit);
|
||
ntohf(&s->lower_alarm_limit, &d->lower_alarm_limit);
|
||
ntohf(&s->lower_warning_limit, &d->lower_warning_limit);
|
||
}
|
||
|
||
|
||
return 1;
|
||
}
|
||
|
||
|
||
|
||
|
||
/****************************************************************************
|
||
** 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
|
||
**
|
||
****************************************************************************/
|
||
|
||
cvrt_ctrl_short(s,d,encode,num)
|
||
struct dbr_ctrl_int *s; /* source */
|
||
struct dbr_ctrl_int *d; /* destination */
|
||
int encode; /* if true, vax to ieee */
|
||
int num; /* number of values */
|
||
{
|
||
register i;
|
||
short *sval_ptr,*dval_ptr;
|
||
|
||
/* vax to ieee or ieee to vax -- same code */
|
||
d->status = ntohs(s->status);
|
||
d->severity = ntohs(s->severity);
|
||
strcpy(d->units,s->units);
|
||
|
||
d->upper_disp_limit = ntohs(s->upper_disp_limit);
|
||
d->lower_disp_limit = ntohs(s->lower_disp_limit);
|
||
d->upper_alarm_limit = ntohs(s->upper_alarm_limit);
|
||
d->upper_warning_limit = ntohs(s->upper_warning_limit);
|
||
d->lower_alarm_limit = ntohs(s->lower_alarm_limit);
|
||
d->lower_warning_limit = ntohs(s->lower_warning_limit);
|
||
d->lower_ctrl_limit = ntohs(s->lower_ctrl_limit);
|
||
d->upper_ctrl_limit = ntohs(s->upper_ctrl_limit);
|
||
|
||
if (num == 1)
|
||
d->value = ntohs(s->value);
|
||
else {
|
||
sval_ptr = &(s->value);
|
||
dval_ptr = &(d->value);
|
||
for (i = 0;i < num; i++){
|
||
*dval_ptr = ntohs(*sval_ptr);
|
||
dval_ptr++;
|
||
sval_ptr++;
|
||
}
|
||
}
|
||
|
||
|
||
return 1;
|
||
}
|
||
|
||
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_ctrl_float(s,d)
|
||
** struct dbr_ctrl_float *s pointer to source struct
|
||
** struct dbr_ctrl_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;
|
||
****************************************************************************/
|
||
|
||
cvrt_ctrl_float(s,d,encode,num)
|
||
struct dbr_ctrl_float *s; /* source */
|
||
struct dbr_ctrl_float *d; /* destination */
|
||
int encode; /* if true, vax to ieee */
|
||
int num; /* number of values */
|
||
{
|
||
register i;
|
||
float *sval_ptr,*dval_ptr;
|
||
|
||
/* these are the same for ieee to vaax or vax to ieee */
|
||
d->status = ntohs(s->status);
|
||
d->severity = ntohs(s->severity);
|
||
d->precision = ntohs(s->precision);
|
||
strcpy(d->units,s->units);
|
||
if (encode) /* vax to ieee convert */
|
||
{
|
||
if (num == 1){
|
||
htonf(&s->value, &d->value);
|
||
}
|
||
else {
|
||
sval_ptr = &(s->value);
|
||
dval_ptr = &(d->value);
|
||
for (i = 0;i < num; i++){
|
||
htonf(sval_ptr,dval_ptr);
|
||
dval_ptr++;
|
||
sval_ptr++;
|
||
}
|
||
}
|
||
htonf(&s->upper_disp_limit,&d->upper_disp_limit);
|
||
htonf(&s->lower_disp_limit, &d->lower_disp_limit);
|
||
htonf(&s->upper_alarm_limit, &d->upper_alarm_limit);
|
||
htonf(&s->upper_warning_limit, &d->upper_warning_limit);
|
||
htonf(&s->lower_alarm_limit, &d->lower_alarm_limit);
|
||
htonf(&s->lower_warning_limit, &d->lower_warning_limit);
|
||
htonf(&s->lower_ctrl_limit, &d->lower_ctrl_limit);
|
||
htonf(&s->upper_ctrl_limit, &d->upper_ctrl_limit);
|
||
}
|
||
else /* ieee to vax convert */
|
||
{
|
||
if (num == 1){
|
||
ntohf(&s->value, &d->value);
|
||
}
|
||
else {
|
||
sval_ptr = &(s->value);
|
||
dval_ptr = &(d->value);
|
||
for (i = 0;i < num; i++){
|
||
ntohf(sval_ptr,dval_ptr);
|
||
dval_ptr++;
|
||
sval_ptr++;
|
||
}
|
||
}
|
||
ntohf(&s->lower_disp_limit, &d->lower_disp_limit);
|
||
ntohf(&s->upper_alarm_limit, &d->upper_alarm_limit);
|
||
ntohf(&s->upper_warning_limit, &d->upper_warning_limit);
|
||
ntohf(&s->lower_alarm_limit, &d->lower_alarm_limit);
|
||
ntohf(&s->lower_warning_limit, &d->lower_warning_limit);
|
||
ntohf(&s->lower_ctrl_limit, &d->lower_ctrl_limit);
|
||
ntohf(&s->upper_ctrl_limit, &d->upper_ctrl_limit);
|
||
}
|
||
|
||
|
||
return 1;
|
||
}
|
||
|
||
|
||
/****************************************************************************
|
||
** cvrt_ctrl_enum(s,d)
|
||
** struct dbr_ctrl_enum *s pointer to source struct
|
||
** struct dbr_ctrl_enum *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;
|
||
****************************************************************************/
|
||
|
||
cvrt_ctrl_enum(s,d,encode,num)
|
||
struct dbr_ctrl_enum *s; /* source */
|
||
struct dbr_ctrl_enum *d; /* destination */
|
||
int encode; /* if true, vax to ieee */
|
||
int num; /* number of values */
|
||
{
|
||
register i;
|
||
short *sval_ptr,*dval_ptr;
|
||
|
||
/* vax to ieee or ieee to vax -- same code */
|
||
d->status = ntohs(s->status);
|
||
d->severity = ntohs(s->severity);
|
||
d->no_str = ntohs(s->no_str);
|
||
memcpy(d->strs,s->strs,sizeof(s->strs));
|
||
|
||
if (num == 1) /* single value */
|
||
d->value = ntohs(s->value);
|
||
else /* array chan-- multiple pts */
|
||
{
|
||
sval_ptr = &(s->value);
|
||
dval_ptr = &(d->value);
|
||
for (i = 0; i < num; i++){
|
||
*dval_ptr = ntohs(*sval_ptr);
|
||
dval_ptr++;
|
||
sval_ptr++;
|
||
}
|
||
}
|
||
|
||
return 1;
|
||
}
|