/*************************************************************************\
* Copyright (c) 2002 The University of Chicago, as Operator of Argonne
*     National Laboratory.
* Copyright (c) 2002 The Regents of the University of California, as
*     Operator of Los Alamos National Laboratory.
* EPICS BASE Versions 3.13.7
* and higher are distributed subject to a Software License Agreement found
* in file LICENSE that is included with this distribution. 
\*************************************************************************/
/*
 *  C O N V E R T . C
 *
 *  Author: D. Kersteins
 *
 *
 *  NOTES: 
 *
 *  1) 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
 *
 */

#include <string.h>

#include "dbDefs.h"
#include "osiSock.h"
#include "osiWireFormat.h"

#define epicsExportSharedSymbols
#include "net_convert.h"
#include "iocinf.h"
#include "caProto.h"
#include "caerr.h"

/*
 * NOOP if this isnt required
 */
#ifdef EPICS_CONVERSION_REQUIRED

/*
 * if hton is true then it is a host to network conversion
 * otherwise vise-versa
 *
 * net format: big endian and IEEE float
 */
typedef void ( * CACVRTFUNCPTR ) ( 
    const void *pSrc, void *pDest, int hton, arrayElementCount count );

inline  void dbr_htond ( 
    const dbr_double_t * pHost, dbr_double_t * pNet )
{
    AlignedWireRef < epicsFloat64 > tmp ( *pNet );
    tmp = *pHost;
}
inline void dbr_ntohd ( 
    const dbr_double_t * pNet, dbr_double_t * pHost )
{
    *pHost = AlignedWireRef < const epicsFloat64 > ( *pNet );
}
inline void dbr_htonf ( 
    const dbr_float_t * pHost, dbr_float_t * pNet )
{
    AlignedWireRef < epicsFloat32 > tmp ( *pNet );
    tmp = *pHost;
}
inline void dbr_ntohf ( 
    const dbr_float_t * pNet, dbr_float_t * pHost )
{
    *pHost = AlignedWireRef < const epicsFloat32 > ( *pNet );
}

inline epicsUInt16 dbr_ntohs( const epicsUInt16 & net ) 
{
    return AlignedWireRef < const epicsUInt16 > ( net );
}

inline epicsUInt16 dbr_htons ( const epicsUInt16 & host ) 
{
    epicsUInt16 tmp;
    AlignedWireRef < epicsUInt16 > awr ( tmp );
    awr = host;
    return tmp;
}

inline epicsUInt32 dbr_ntohl( const epicsUInt32 & net )
{
    return AlignedWireRef < const epicsUInt32 > ( net );
}

inline epicsUInt32 dbr_htonl ( const epicsUInt32 & host )
{
    epicsUInt32 tmp;
    AlignedWireRef < epicsUInt32 > awr ( tmp );
    awr = host;
    return tmp;
}

/*
 * if hton is true then it is a host to network conversion
 * otherwise vise-versa
 *
 * net format: big endian and IEEE float
 * 
 */

/*
 *  CVRT_STRING()
 */
static void cvrt_string(
const void          *s,             /* source           */
void                *d,             /* destination          */
int                 /* encode */,   /* cvrt HOST to NET if T    */
arrayElementCount   num             /* number of values     */
)
{
    char        *pSrc = (char *) s;
    char        *pDest = (char *) d;

    /* convert "in place" -> nothing to do */
    if (s == d)
        return;
    memcpy ( pDest, pSrc, num*MAX_STRING_SIZE );  
}

/*
 *  CVRT_SHORT()
 */
static void cvrt_short(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    dbr_short_t         *pSrc = (dbr_short_t *) s;
    dbr_short_t         *pDest = (dbr_short_t *) d;

    if(encode){
        for(arrayElementCount i=0; i<num; i++){
            pDest[i] = dbr_htons( pSrc[i] );
        }
    }
    else {
        for(arrayElementCount i=0; i<num; i++){
            pDest[i] = dbr_ntohs( pSrc[i] );
        }
    }
}

/*
 *  CVRT_CHAR()
 *
 *
 *
 *
 */
static void cvrt_char(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 /*encode*/, /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    dbr_char_t          *pSrc = (dbr_char_t *) s;
    dbr_char_t          *pDest = (dbr_char_t *) d;

    /* convert "in place" -> nothing to do */
    if (s == d)
        return;
    for( arrayElementCount i=0; i<num; i++){
        pDest[i] = pSrc[i];
    }
}

/*
 *  CVRT_LONG()
 */
static void cvrt_long(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    dbr_long_t          *pSrc = (dbr_long_t *) s;
    dbr_long_t          *pDest = (dbr_long_t *) d;

    if(encode){
        for(arrayElementCount i=0; i<num; i++){
            pDest[i] = dbr_htonl( pSrc[i] );
        }
    }
    else {
        for(arrayElementCount i=0; i<num; i++){
            pDest[i] = dbr_ntohl( pSrc[i] );
        }
    }
}

/*
 *  CVRT_ENUM()
 *
 *
 *
 *
 */
static void cvrt_enum(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    dbr_enum_t          *pSrc = (dbr_enum_t *) s;
    dbr_enum_t          *pDest = (dbr_enum_t *) d;

    if(encode){
        for(arrayElementCount i=0; i<num; i++){
            pDest[i] = dbr_htons ( pSrc[i] );
        }
    }
    else {
        for(arrayElementCount i=0; i<num; i++){
            pDest[i] = dbr_ntohs ( pSrc[i] );
        }
    }
}

/*
 *  CVRT_FLOAT()
 *
 *
 *  NOTES:
 *  placing encode outside the loop results in more 
 *  code but better performance.
 *
 */
static void cvrt_float(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    const dbr_float_t   *pSrc = (const dbr_float_t *) s;
    dbr_float_t         *pDest = (dbr_float_t *) d;

    if(encode){
        for(arrayElementCount i=0; i<num; i++){
            dbr_htonf ( &pSrc[i], &pDest[i] );
        }
    }
    else{
        for(arrayElementCount i=0; i<num; i++){
            dbr_ntohf ( &pSrc[i], &pDest[i] );
        }
    }
}

/*
 *  CVRT_DOUBLE()
 */
static void cvrt_double(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    dbr_double_t        *pSrc = (dbr_double_t *) s;
    dbr_double_t        *pDest = (dbr_double_t *) d;

    if(encode){
        for(arrayElementCount i=0; i<num; i++){
            dbr_htond ( &pSrc[i], &pDest[i] );
        }
    }
    else{
        for(arrayElementCount i=0; i<num; i++){
            dbr_ntohd( &pSrc[i], &pDest[i] );
        }
    }
}

/****************************************************************************
**  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 HOST format to NET format
**     or 
**  converts fields of struct in NET format to fields with HOST 
**      format;
****************************************************************************/

static void cvrt_sts_string(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 /*encode*/, /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_sts_string   *pSrc = (struct dbr_sts_string *) s;
    struct dbr_sts_string   *pDest = (struct dbr_sts_string *) d;
            
    /* convert ieee to vax format or vax to ieee */
    pDest->status       = dbr_ntohs(pSrc->status);
    pDest->severity     = dbr_ntohs(pSrc->severity);

    /* convert "in place" -> nothing else to do */
    if (s == d)
        return;

    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 HOST format to ieee format
**     or 
**  converts fields of struct in NET format to fields with HOST 
**      format
****************************************************************************/

static void cvrt_sts_short(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_sts_int  *pSrc = (struct dbr_sts_int *) s;
    struct dbr_sts_int  *pDest = (struct dbr_sts_int *) 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 HOST format to ieee format
**     else 
**      converts fields of struct in NET format to fields with HOST 
**      format;
****************************************************************************/

static void cvrt_sts_float(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_sts_float    *pSrc = (struct dbr_sts_float *) s;
    struct dbr_sts_float    *pDest = (struct dbr_sts_float *) 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 HOST format to ieee format
**     else 
**      converts fields of struct in NET format to fields with HOST 
**      format;
****************************************************************************/

static void cvrt_sts_double(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_sts_double   *pSrc = (struct dbr_sts_double *) s;
    struct dbr_sts_double   *pDest = (struct dbr_sts_double *) 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 NET format to fields with HOST format
**       or  
**  converts fields of struct in HOST format to fields with NET format
**   
****************************************************************************/

static void cvrt_sts_enum(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_sts_enum *pSrc = (struct dbr_sts_enum *) s;
    struct dbr_sts_enum *pDest = (struct dbr_sts_enum *) d;

    pDest->status       = dbr_ntohs(pSrc->status);
    pDest->severity     = dbr_ntohs(pSrc->severity);
    if (num == 1)
        pDest->value    = dbr_ntohs(pSrc->value);
    else {
        cvrt_enum(&pSrc->value,&pDest->value,encode,num);
    }
}

/****************************************************************************
**  cvrt_gr_short()
**
**  converts fields of struct in NET format to fields with HOST format
**       or  
**  converts fields of struct in HOST format to fields with NET format
**   
****************************************************************************/

static void cvrt_gr_short(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_gr_int   *pSrc = (struct dbr_gr_int *) s;
    struct dbr_gr_int   *pDest = (struct dbr_gr_int *) d;

    pDest->status       = dbr_ntohs(pSrc->status);
    pDest->severity     = dbr_ntohs(pSrc->severity);
    if ( s != d ) {
        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 NET format to fields with HOST format
**       or  
**  converts fields of struct in HOST format to fields with NET format
**   
****************************************************************************/

static void cvrt_gr_char(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 /*encode*/, /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_gr_char  *pSrc = (struct dbr_gr_char *) s;
    struct dbr_gr_char  *pDest = (struct dbr_gr_char *) d;

    pDest->status       = dbr_ntohs(pSrc->status);
    pDest->severity     = dbr_ntohs(pSrc->severity);

    if (s == d) /* source == dest -> no more conversions */
        return;

    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((char *)&pDest->value, (char *)&pSrc->value, num);
    }
}

/****************************************************************************
**  cvrt_gr_long()
**
**  converts fields of struct in NET format to fields with HOST format
**       or  
**  converts fields of struct in HOST format to fields with NET format
**   
****************************************************************************/

static void cvrt_gr_long(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_gr_long  *pSrc = (struct dbr_gr_long *) s;
    struct dbr_gr_long  *pDest = (struct dbr_gr_long *) d;

    pDest->status       = dbr_ntohs(pSrc->status);
    pDest->severity     = dbr_ntohs(pSrc->severity);
    if ( s != d ) {
        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 HOST format to ieee format
**     else 
**      converts fields of struct in NET format to fields with HOST 
**      format;
****************************************************************************/

static void cvrt_gr_enum(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_gr_enum  *pSrc = (struct dbr_gr_enum *) s;
    struct dbr_gr_enum  *pDest = (struct dbr_gr_enum *) d;

    pDest->status           = dbr_ntohs(pSrc->status);
    pDest->severity         = dbr_ntohs(pSrc->severity);
    pDest->no_str           = dbr_ntohs(pSrc->no_str);
    if ( s != d ) {
        memcpy((void *)pDest->strs,(void *)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 HOST format to ieee format
**     else 
**      converts fields of struct in NET format to fields with HOST 
**      format;
****************************************************************************/

static void cvrt_gr_double(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_gr_double    *pSrc = (struct dbr_gr_double *) s;
    struct dbr_gr_double    *pDest = (struct dbr_gr_double *) 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);
    if ( s != d ) {
        memcpy(pDest->units,pSrc->units,sizeof(pSrc->units));
    }

    if (encode)         /* vax to ieee convert      */
    {
        if (num == 1){
            dbr_htond(&pSrc->value, &pDest->value);
        }
        else {
            cvrt_double(&pSrc->value, &pDest->value, encode,num);
        }
        dbr_htond(&pSrc->upper_disp_limit,&pDest->upper_disp_limit);
        dbr_htond(&pSrc->lower_disp_limit, &pDest->lower_disp_limit);
        dbr_htond(&pSrc->upper_alarm_limit, &pDest->upper_alarm_limit);
        dbr_htond(&pSrc->upper_warning_limit, &pDest->upper_warning_limit);
        dbr_htond(&pSrc->lower_alarm_limit, &pDest->lower_alarm_limit);
        dbr_htond(&pSrc->lower_warning_limit, &pDest->lower_warning_limit);
    }
    else            /* ieee to vax convert      */
    {
        if (num == 1){
            dbr_ntohd(&pSrc->value, &pDest->value);
        }
        else {
            cvrt_double(&pSrc->value, &pDest->value, encode,num);
        }
        dbr_ntohd(&pSrc->upper_disp_limit,&pDest->upper_disp_limit);
        dbr_ntohd(&pSrc->lower_disp_limit, &pDest->lower_disp_limit);
        dbr_ntohd(&pSrc->upper_alarm_limit, &pDest->upper_alarm_limit);
        dbr_ntohd(&pSrc->upper_warning_limit, &pDest->upper_warning_limit);
        dbr_ntohd(&pSrc->lower_alarm_limit, &pDest->lower_alarm_limit);
        dbr_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 HOST format to ieee format
**     else 
**      converts fields of struct in NET format to fields with HOST 
**      format;
****************************************************************************/

static void cvrt_gr_float(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_gr_float     *pSrc = (struct dbr_gr_float *) s;
    struct dbr_gr_float     *pDest = (struct dbr_gr_float *) 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);
    if ( s != d ) {
        memcpy(pDest->units,pSrc->units,sizeof(pSrc->units));
    }

    if (encode)         /* vax to ieee convert      */
    {
        if (num == 1){
            dbr_htonf(&pSrc->value, &pDest->value);
        }
        else {
            cvrt_float(&pSrc->value, &pDest->value, encode,num);
        }
        dbr_htonf(&pSrc->upper_disp_limit,&pDest->upper_disp_limit);
        dbr_htonf(&pSrc->lower_disp_limit, &pDest->lower_disp_limit);
        dbr_htonf(&pSrc->upper_alarm_limit, &pDest->upper_alarm_limit);
        dbr_htonf(&pSrc->upper_warning_limit, &pDest->upper_warning_limit);
        dbr_htonf(&pSrc->lower_alarm_limit, &pDest->lower_alarm_limit);
        dbr_htonf(&pSrc->lower_warning_limit, &pDest->lower_warning_limit);
    }
    else            /* ieee to vax convert      */
    {
        if (num == 1){
            dbr_ntohf(&pSrc->value, &pDest->value);
        }
        else {
            cvrt_float(&pSrc->value, &pDest->value, encode,num);
        }
        dbr_ntohf(&pSrc->upper_disp_limit,&pDest->upper_disp_limit);
        dbr_ntohf(&pSrc->lower_disp_limit, &pDest->lower_disp_limit);
        dbr_ntohf(&pSrc->upper_alarm_limit, &pDest->upper_alarm_limit);
        dbr_ntohf(&pSrc->upper_warning_limit, &pDest->upper_warning_limit);
        dbr_ntohf(&pSrc->lower_alarm_limit, &pDest->lower_alarm_limit);
        dbr_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 NET format to fields with HOST format
**       or  
**  converts fields of struct in HOST format to fields with NET format
**   
****************************************************************************/

static void cvrt_ctrl_short(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_ctrl_int *pSrc = (struct dbr_ctrl_int *) s;
    struct dbr_ctrl_int *pDest = (struct dbr_ctrl_int *) d;

    /* vax to ieee or ieee to vax -- same code */
    pDest->status           = dbr_ntohs(pSrc->status);
    pDest->severity         = dbr_ntohs(pSrc->severity);
    if ( s != d ) {
        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 {
        cvrt_short(&pSrc->value, &pDest->value, encode, num);
    }
}

/****************************************************************************
**  cvrt_ctrl_long(s,d)
**
**  converts fields of struct in NET format to fields with HOST format
**       or  
**  converts fields of struct in HOST format to fields with NET format
**   
****************************************************************************/

static void cvrt_ctrl_long(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_ctrl_long    *pSrc = (struct dbr_ctrl_long*) s;
    struct dbr_ctrl_long    *pDest = (struct dbr_ctrl_long *) d;

    /* vax to ieee or ieee to vax -- same code */
    pDest->status           = dbr_ntohs(pSrc->status);
    pDest->severity         = dbr_ntohs(pSrc->severity);
    if ( s != d ) {
        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 {
        cvrt_long(&pSrc->value, &pDest->value, encode, num);
    }
}

/****************************************************************************
**  cvrt_ctrl_short(s,d)
**
**  converts fields of struct in NET format to fields with HOST format
**       or  
**  converts fields of struct in HOST format to fields with NET format
**   
****************************************************************************/

static void cvrt_ctrl_char(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 /*encode*/, /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_ctrl_char    *pSrc = (struct dbr_ctrl_char *) s;
    struct dbr_ctrl_char    *pDest = (struct dbr_ctrl_char *) d;

    /* vax to ieee or ieee to vax -- same code */
    pDest->status           = dbr_ntohs(pSrc->status);
    pDest->severity         = dbr_ntohs(pSrc->severity);

    if ( s == d ) 
        return;

    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((void *)&pDest->value, (void *)&pSrc->value, num);
    }
}

/****************************************************************************
**  cvrt_ctrl_double(s,d)
**
**     if encode 
**      converts struct in HOST format to ieee format
**     else 
**      converts fields of struct in NET format to fields with HOST 
**      format;
****************************************************************************/

static void cvrt_ctrl_double(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_ctrl_double  *pSrc = (struct dbr_ctrl_double *) s;
    struct dbr_ctrl_double  *pDest = (struct dbr_ctrl_double *) d;

    /* these are the same for ieee to vax or vax to ieee */
    pDest->status       = dbr_ntohs(pSrc->status);
    pDest->severity     = dbr_ntohs(pSrc->severity);
    pDest->precision    = dbr_ntohs(pSrc->precision);
    if ( s != d ) {
        memcpy(pDest->units,pSrc->units,sizeof(pSrc->units));
    }
    if (encode)         /* vax to ieee convert      */
    {
        if (num == 1){
            dbr_htond(&pSrc->value, &pDest->value);
        }
        else {
            cvrt_double(&pSrc->value, &pDest->value, encode, num);
        }
        dbr_htond(&pSrc->upper_disp_limit,&pDest->upper_disp_limit);
        dbr_htond(&pSrc->lower_disp_limit, &pDest->lower_disp_limit);
        dbr_htond(&pSrc->upper_alarm_limit, &pDest->upper_alarm_limit);
        dbr_htond(&pSrc->upper_warning_limit, &pDest->upper_warning_limit);
        dbr_htond(&pSrc->lower_alarm_limit, &pDest->lower_alarm_limit);
        dbr_htond(&pSrc->lower_warning_limit, &pDest->lower_warning_limit);
        dbr_htond(&pSrc->lower_ctrl_limit, &pDest->lower_ctrl_limit);
        dbr_htond(&pSrc->upper_ctrl_limit, &pDest->upper_ctrl_limit);
    }
    else            /* ieee to vax convert      */
    {
        if (num == 1){
                dbr_ntohd(&pSrc->value, &pDest->value);
        }
        else {
            cvrt_double(&pSrc->value, &pDest->value, encode, num);
        }
        dbr_ntohd(&pSrc->lower_disp_limit, &pDest->lower_disp_limit);
        dbr_ntohd(&pSrc->upper_disp_limit, &pDest->upper_disp_limit);
        dbr_ntohd(&pSrc->upper_alarm_limit, &pDest->upper_alarm_limit);
        dbr_ntohd(&pSrc->upper_warning_limit, &pDest->upper_warning_limit);
        dbr_ntohd(&pSrc->lower_alarm_limit, &pDest->lower_alarm_limit);
        dbr_ntohd(&pSrc->lower_warning_limit, &pDest->lower_warning_limit);
        dbr_ntohd(&pSrc->lower_ctrl_limit, &pDest->lower_ctrl_limit);
        dbr_ntohd(&pSrc->upper_ctrl_limit, &pDest->upper_ctrl_limit);
    }

}



/****************************************************************************
**  cvrt_ctrl_float(s,d)
**
**     if encode 
**      converts struct in HOST format to ieee format
**     else 
**      converts fields of struct in NET format to fields with HOST 
**      format;
****************************************************************************/

static void cvrt_ctrl_float(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_ctrl_float   *pSrc = (struct dbr_ctrl_float *) s;
    struct dbr_ctrl_float   *pDest = (struct dbr_ctrl_float *) 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);
    if ( s != d ) {
        memcpy(pDest->units,pSrc->units,sizeof(pSrc->units));
    }
    if (encode)         /* vax to ieee convert      */
    {
        if (num == 1){
                dbr_htonf(&pSrc->value, &pDest->value);
        }
        else {
            cvrt_float(&pSrc->value, &pDest->value, encode, num);
        }
        dbr_htonf(&pSrc->upper_disp_limit,&pDest->upper_disp_limit);
        dbr_htonf(&pSrc->lower_disp_limit, &pDest->lower_disp_limit);
        dbr_htonf(&pSrc->upper_alarm_limit, &pDest->upper_alarm_limit);
        dbr_htonf(&pSrc->upper_warning_limit, &pDest->upper_warning_limit);
        dbr_htonf(&pSrc->lower_alarm_limit, &pDest->lower_alarm_limit);
        dbr_htonf(&pSrc->lower_warning_limit, &pDest->lower_warning_limit);
        dbr_htonf(&pSrc->lower_ctrl_limit, &pDest->lower_ctrl_limit);
        dbr_htonf(&pSrc->upper_ctrl_limit, &pDest->upper_ctrl_limit);
    }
    else            /* ieee to vax convert      */
    {
        if (num == 1){
            dbr_ntohf(&pSrc->value, &pDest->value);
        }
        else {
            cvrt_float(&pSrc->value, &pDest->value, encode, num);
        }
        dbr_ntohf(&pSrc->lower_disp_limit, &pDest->lower_disp_limit);
        dbr_ntohf(&pSrc->upper_disp_limit, &pDest->upper_disp_limit);
        dbr_ntohf(&pSrc->upper_alarm_limit, &pDest->upper_alarm_limit);
        dbr_ntohf(&pSrc->upper_warning_limit, &pDest->upper_warning_limit);
        dbr_ntohf(&pSrc->lower_alarm_limit, &pDest->lower_alarm_limit);
        dbr_ntohf(&pSrc->lower_warning_limit, &pDest->lower_warning_limit);
        dbr_ntohf(&pSrc->lower_ctrl_limit, &pDest->lower_ctrl_limit);
        dbr_ntohf(&pSrc->upper_ctrl_limit, &pDest->upper_ctrl_limit);
    }

}


/****************************************************************************
**  cvrt_ctrl_enum(s,d)
**
**     if encode 
**      converts struct in HOST format to ieee format
**     else 
**      converts fields of struct in NET format to fields with HOST 
**      format;
****************************************************************************/

static void cvrt_ctrl_enum(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_ctrl_enum    *pSrc = (struct dbr_ctrl_enum *) s;
    struct dbr_ctrl_enum    *pDest = (struct dbr_ctrl_enum *) d;

    pDest->status           = dbr_ntohs(pSrc->status);
    pDest->severity         = dbr_ntohs(pSrc->severity);
    pDest->no_str           = dbr_ntohs(pSrc->no_str); 
    if ( s != d ) {
        memcpy((void *)pDest->strs,(void *)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 HOST format to ieee format
**     or 
**  converts fields of struct in NET format to fields with HOST 
**      format
****************************************************************************/

static void cvrt_sts_char(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 /*encode*/, /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_sts_char *pSrc = (struct dbr_sts_char *) s;
    struct dbr_sts_char *pDest = (struct dbr_sts_char *) 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 ( s == d ) 
        return;

    if (num == 1)   /* single value */
        pDest->value = pSrc->value;
    else        /* array chan-- multiple pts */
    {
        memcpy((void *)&pDest->value, (void *)&pSrc->value, num);
    }
}

/****************************************************************************
**  cvrt_sts_long(s,d)
**
**  converts fields ofstruct in HOST format to ieee format
**     or 
**  converts fields of struct in NET format to fields with HOST 
**      format
****************************************************************************/

static void cvrt_sts_long(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_sts_long *pSrc = (struct dbr_sts_long *) s;
    struct dbr_sts_long *pDest = (struct dbr_sts_long *) 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 HOST format to NET format
**     or 
**  converts fields of struct in NET format to fields with HOST 
**      format;
****************************************************************************/

static void cvrt_time_string(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 /*encode*/, /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_time_string  *pSrc = (struct dbr_time_string *) s;
    struct dbr_time_string  *pDest = (struct dbr_time_string *) 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 ( s != d ) {
        memcpy(pDest->value, pSrc->value, (MAX_STRING_SIZE * num));
    }
}

/****************************************************************************
**  cvrt_time_short(s,d)
**
**  converts fields ofstruct in HOST format to ieee format
**     or 
**  converts fields of struct in NET format to fields with HOST 
**      format
****************************************************************************/

static void cvrt_time_short(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_time_short   *pSrc = (struct dbr_time_short *) s;
    struct dbr_time_short   *pDest = (struct dbr_time_short *) 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 HOST format to ieee format
**     else 
**      converts fields of struct in NET format to fields with HOST 
**      format;
****************************************************************************/

static void cvrt_time_float(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_time_float   *pSrc = (struct dbr_time_float *) s;
    struct dbr_time_float   *pDest = (struct dbr_time_float *) 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 HOST format to ieee format
**     else 
**      converts fields of struct in NET format to fields with HOST 
**      format;
****************************************************************************/

static void cvrt_time_double(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_time_double  *pSrc = (struct dbr_time_double *) s;
    struct dbr_time_double  *pDest = (struct dbr_time_double *) 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_enum(s,d)
**
**  converts fields of struct in NET format to fields with HOST format
**       or  
**  converts fields of struct in HOST format to fields with NET format
**   
****************************************************************************/

static void cvrt_time_enum(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_time_enum    *pSrc = (struct dbr_time_enum *) s;
    struct dbr_time_enum    *pDest = (struct dbr_time_enum *) 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)
        pDest->value    = dbr_ntohs(pSrc->value);
    else {
        cvrt_enum(&pSrc->value,&pDest->value,encode,num);
    }
}

/****************************************************************************
**  cvrt_sts_char(s,d)
**
**  converts fields ofstruct in HOST format to ieee format
**     or 
**  converts fields of struct in NET format to fields with HOST 
**      format
****************************************************************************/

static void cvrt_time_char(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 /*encode*/, /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_time_char    *pSrc = (struct dbr_time_char *) s;
    struct dbr_time_char    *pDest = (struct dbr_time_char *) 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 ( s == d ) 
        return;

    if (num == 1)   /* single value */
        pDest->value = pSrc->value;
    else        /* array chan-- multiple pts */
    {
        memcpy((void *)&pDest->value, (void *)&pSrc->value, num);
    }
}
/****************************************************************************
**  cvrt_time_long(s,d)
**
**  converts fields ofstruct in HOST format to ieee format
**     or 
**  converts fields of struct in NET format to fields with HOST 
**      format
****************************************************************************/

static void cvrt_time_long(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 encode,     /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_time_long    *pSrc = (struct dbr_time_long *) s;
    struct dbr_time_long    *pDest = (struct dbr_time_long *) 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);
    }
}

/*
 *  cvrt_put_ackt()
 *
 *
 *
 *
 */
static void cvrt_put_ackt(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 /*encode*/, /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    dbr_put_ackt_t      *pSrc = (dbr_put_ackt_t *) s;
    dbr_put_ackt_t      *pDest = (dbr_put_ackt_t *) d;
    arrayElementCount   i;

    for(i=0; i<num; i++){
        *pDest = dbr_ntohs( *pSrc );
        /*
         * dont increment these inside the MACRO 
         */
        pDest++;
        pSrc++;
    }
}

/****************************************************************************
**  cvrt_stsack_string(s,d)
**      struct dbr_stsack_string *s     pointer to source struct
**      struct dbr_stsack_string *d pointer to destination struct
**      int  encode;            boolean, if true vax to ieee
**                           else ieee to vax
**        
**  converts fields of struct in HOST format to NET format
**     or 
**  converts fields of struct in NET format to fields with HOST 
**      format;
****************************************************************************/

static void cvrt_stsack_string(
const void          *s,         /* source           */
void                *d,         /* destination          */
int                 /*encode*/, /* cvrt HOST to NET if T    */
arrayElementCount   num         /* number of values     */
)
{
    struct dbr_stsack_string    *pSrc = (struct dbr_stsack_string *) s;
    struct dbr_stsack_string    *pDest = (struct dbr_stsack_string *) d;
            
    /* convert ieee to vax format or vax to ieee */
    pDest->status       = dbr_ntohs(pSrc->status);
    pDest->severity     = dbr_ntohs(pSrc->severity);
    pDest->ackt         = dbr_ntohs(pSrc->ackt);
    pDest->acks         = dbr_ntohs(pSrc->acks);

    /* convert "in place" -> nothing else to do */
    if (s == d)
        return;

    memcpy(pDest->value, pSrc->value, (MAX_STRING_SIZE * num));
}

/*  cvrt is (array of) (pointer to) (function returning) int */
static CACVRTFUNCPTR cac_dbr_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,

    cvrt_put_ackt,  
    cvrt_put_ackt, /* DBR_PUT_ACKS identical to DBR_PUT_ACKT */
    cvrt_stsack_string,
    cvrt_string
};

#endif /* EPICS_CONVERSION_REQUIRED */

int caNetConvert ( unsigned type, const void *pSrc, void *pDest, 
                  int hton, arrayElementCount count )
{
#   ifdef EPICS_CONVERSION_REQUIRED
        if ( type >= NELEMENTS ( cac_dbr_cvrt ) ) {
            return ECA_BADTYPE;
        }        
        ( * cac_dbr_cvrt [ type ] ) ( pSrc, pDest, hton, count );
#   else
        if ( INVALID_DB_REQ ( type ) ) {
            return ECA_BADTYPE;
        }        
        if ( pSrc != pDest ) {
            memcpy ( pDest, pSrc, dbr_size_n ( type, count ) );
        }
#   endif
    return ECA_NORMAL;
}