vms_convert.cpp

Go to the documentation of this file.

/*
 *      Module:         vms_convert
 *      Author:         Freddie Akeroyd, ISIS
 *      Purpose:        Routines to convert from VAX to local integer representations
 *
 * $Id: vms_convert.cpp 859 2010-10-29 12:18:36Z FreddieAkeroyd $
 */
#include "stdafx.h"
#include "vms_convert.h"

/*
 * Byte swaps for int and short
 */


#if 0
inline unsigned swap_int(unsigned a)
{
    union { unsigned u; unsigned char c[4]; } temp;
    unsigned char ctemp;
    temp.u = a;
    ctemp = temp.c[0]; temp.c[0] = temp.c[3]; temp.c[3] = ctemp; 
    ctemp = temp.c[1]; temp.c[1] = temp.c[2]; temp.c[2] = ctemp; 
    return temp.u;
}
#endif

#define swap_int(a) ( ((a) << 24) | \
                      (((a) << 8) & 0x00ff0000) | \
                      (((a) >> 8) & 0x0000ff00) | \
                      ((unsigned long)(a) >>24) )

#define swap_short(a) ( ((a & 0xff) << 8) | ((unsigned short)(a) >> 8) )

/* VAXes are little endian */

unsigned short  local_to_vax_short(const unsigned short* s)
{
#if defined(WORDS_BIGENDIAN)
    return swap_short(*s);
#else 
    return *s;
#endif /* WORDS_BIGENDIAN */
}

unsigned short  vax_to_local_short(const unsigned short* s)
{
#if defined(WORDS_BIGENDIAN)
    return swap_short(*s);
#else
    return *s;
#endif /* WORDS_BIGENDIAN */
}

unsigned  local_to_vax_int(const fort_int* i)
{
#if defined(WORDS_BIGENDIAN)
    return swap_int(*(unsigned*)i);
#else
    return *i;
#endif /* WORDS_BIGENDIAN */
}

unsigned  vax_to_local_int(const fort_int* i)
{
#if defined(WORDS_BIGENDIAN)
    return swap_int(*(unsigned*)i);
#else
    return *i;
#endif /* WORDS_BIGENDIAN */
}

void  local_to_vax_shorts(unsigned short* sa, const int* n)
{
#if defined(WORDS_BIGENDIAN)
    int i;
    for(i=0; i<*n; i++)
    {
        sa[i] = swap_short(sa[i]);
    }
#endif /* WORDS_BIGENDIAN */
    return;
}

void  vax_to_local_shorts(unsigned short* sa, const int* n)
{
#if defined(WORDS_BIGENDIAN)
    int i;
    for(i=0; i<*n; i++)
    {
        sa[i] = swap_short(sa[i]);
    }
#endif /* WORDS_BIGENDIAN */
    return;
}

void  local_to_vax_ints(fort_int* ia, const fort_int* n)
{
#if defined(WORDS_BIGENDIAN)
    int i;
    unsigned *uia = (unsigned*)ia;
    for(i=0; i<*n; i++)
    {
        uia[i] = swap_int(uia[i]);
    }
#endif /* WORDS_BIGENDIAN */
    return;
}

void  vax_to_local_ints(fort_int* ia, const fort_int* n)
{
#if defined(WORDS_BIGENDIAN)
    int i;
    unsigned *uia = (unsigned*)ia;
    for(i=0; i<*n; i++)
    {
        uia[i] = swap_int(uia[i]);
    }
#endif /* WORDS_BIGENDIAN */
    return;
}


/*
 * determine a few things we need to know to write machine independent data 
 */
 
#ifndef __VMS
#define IEEEFP                  1
#endif /* __VMS */

#ifdef __VMS
/* set up codes for use of CVT$CONVERT_FLOAT */
#  if __IEEE_FLOAT
#    define IEEEFP              1
#    define VMS_FLOAT_NATIVE    CVT$K_IEEE_S
#    define VMS_DOUBLE_NATIVE   CVT$K_IEEE_T
#  elif __D_FLOAT
#    define VAXFP               1
#    define VMS_FLOAT_NATIVE    CVT$K_VAX_F
#    define VMS_DOUBLE_NATIVE   CVT$K_VAX_D
#  elif __G_FLOAT
#    define VAXFP               1
#    define VMS_FLOAT_NATIVE    CVT$K_VAX_F
#    define VMS_DOUBLE_NATIVE   CVT$K_VAX_G
#  else
#    error Cannot determine VMS floating point format
#  endif
#endif /* __VMS */

#if WORDS_BIGENDIAN

/* What IEEE single precision floating point looks like on local machine */
struct  ieee_single {
        unsigned int    sign    : 1;
        unsigned int    exp     : 8;
        unsigned int    mantissa: 23;
};

/* Vax single precision floating point */
struct  vax_single {
        unsigned int    mantissa2 : 16;
        unsigned int    sign      : 1;
        unsigned int    exp       : 8;
        unsigned int    mantissa1 : 7;
};

#else

/* What IEEE single precision floating point looks like on local machine */
struct  ieee_single {
        unsigned int    mantissa: 23;
        unsigned int    exp     : 8;
        unsigned int    sign    : 1;
};

/* Vax single precision floating point */
struct  vax_single {
        unsigned int    mantissa1 : 7;
        unsigned int    exp       : 8;
        unsigned int    sign      : 1;
        unsigned int    mantissa2 : 16;
};

#endif /* WORDS_BIGENDIAN */

#define VAX_SNG_BIAS    0x81
#define IEEE_SNG_BIAS   0x7f

static const struct sgl_limits_struct {
        struct vax_single s;
        struct ieee_single ieee;
} sgl_limits[2] = {
        {{ 0x7f, 0xff, 0x0, 0xffff },   /* Max Vax */
        { 0x0, 0xff, 0x0 }},            /* Max IEEE */
        {{ 0x0, 0x0, 0x0, 0x0 },        /* Min Vax */
        { 0x0, 0x0, 0x0 }}              /* Min IEEE */
};

#define mmax sgl_limits[0]
#define mmin sgl_limits[1]

#if WORDS_BIGENDIAN

/* What IEEE double precision floating point looks like */
struct  ieee_double {
        unsigned int    mantissa2 : 32;
        unsigned int    sign      : 1;
        unsigned int    exp       : 11;
        unsigned int    mantissa1 : 20;
};

/* Vax double precision floating point */
struct  vax_double {
        unsigned int    mantissa4 : 16;
        unsigned int    mantissa3 : 16;
        unsigned int    mantissa2 : 16;
        unsigned int    sign      : 1;
        unsigned int    exp       : 8;
        unsigned int    mantissa1 : 7;
};

#else

/* What IEEE double precision floating point looks like */
struct  ieee_double {
        unsigned int    mantissa1 : 20;
        unsigned int    exp       : 11;
        unsigned int    sign      : 1;
        unsigned int    mantissa2 : 32;
};

/* Vax double precision floating point */
struct  vax_double {
        unsigned int    mantissa1 : 7;
        unsigned int    exp       : 8;
        unsigned int    sign      : 1;
        unsigned int    mantissa2 : 16;
        unsigned int    mantissa3 : 16;
        unsigned int    mantissa4 : 16;
};

#endif /* WORDS_BIGENDIAN */


#define VAX_DBL_BIAS    0x81
#define IEEE_DBL_BIAS   0x3ff
#define MASK(nbits)     ((1 << nbits) - 1)

static struct dbl_limits {
        struct  vax_double d;
        struct  ieee_double ieee;
} dbl_limits[2] = {
        {{ 0x7f, 0xff, 0x0, 0xffff, 0xffff, 0xffff },   /* Max Vax */
        { 0x0, 0x7ff, 0x0, 0x0 }},                      /* Max IEEE */
        {{ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},               /* Min Vax */
        { 0x0, 0x0, 0x0, 0x0 }}                         /* Min IEEE */
};

/* VAX is little endian, so we may need to flip */
#if WORDS_BIGENDIAN
    static int maybe_flip_bytes(void* p, size_t n)
    {
        unsigned i;
        unsigned char c_tmp, *c_p = (unsigned char*)p;
        for(i=0; i<n/2; i++)
        {
            c_tmp = c_p[i];
            c_p[i] = c_p[n-i-1];
            c_p[n-i-1] = c_tmp;
        }
        return 0;
    }
#else
#   define maybe_flip_bytes(__p,__n)
#endif /* WORDS_BIGENDIAN */
    
/* convert VAX F FLOAT into a local IEEE single float */
static int vax_to_ieee_float(float* fp)
{
    struct ieee_single is;
    struct vax_single vs;
    struct sgl_limits_struct;
    maybe_flip_bytes(fp, sizeof(float));
        vs = *((struct vax_single *)fp);
                switch(vs.exp){
                case 0 :
                        /* all vax float with zero exponent map to zero */
                        is = mmin.ieee ;
                        break ;
                case 2 :
                case 1 :
                        /* These will map to subnormals */
                        is.exp = 0 ;
                        is.mantissa = (vs.mantissa1 << 16) | vs.mantissa2;
                        /* lose some precision */
                        is.mantissa >>= 3 - vs.exp ;
                        is.mantissa += (1 << (20 + vs.exp)) ;
                        break ;
                case 0xff : /* mmax.s.exp */
                        if( vs.mantissa2 == mmax.s.mantissa2
                                && vs.mantissa1 == mmax.s.mantissa1)
                        {
                                /* map largest vax float to ieee infinity */
                                is = mmax.ieee ;
                                break ;
                        } /* else, fall thru */
                default :
                        is.exp = vs.exp - VAX_SNG_BIAS + IEEE_SNG_BIAS;
                        is.mantissa = (vs.mantissa1 << 16) | vs.mantissa2;
                }

                is.sign = vs.sign;
        *fp = *((float*)&is);
        return 0;
}

/* convert a local IEEE single float to little endian VAX F FLOAT format */
static int ieee_to_vax_float(float* fp)
{
    struct ieee_single is;
    struct vax_single vs;
    struct sgl_limits_struct;
    is = *((struct ieee_single*)fp);
                switch(is.exp) {
                case 0 :
                        if(is.mantissa == mmin.ieee.mantissa)
                        {
                                vs = mmin.s ;
                        } else {
                                unsigned tmp = is.mantissa >> 20 ;
                                if(tmp >= 4) {
                                        vs.exp = 2 ;
                                } else if (tmp >= 2) {
                                        vs.exp = 1 ;
                                } else {
                                        vs = mmin.s ;
                                        break ;
                                } /* else */
                                tmp = is.mantissa - (1 << (20 + vs.exp )) ;
                                tmp <<= 3 - vs.exp ;
                                vs.mantissa2 = tmp ;
                                vs.mantissa1 = (tmp >> 16);
                        }
                        break ;
                case 0xfe :
                case 0xff :
                        vs = mmax.s ;
                        break ;
                default :
                        vs.exp = is.exp - IEEE_SNG_BIAS + VAX_SNG_BIAS;
                        vs.mantissa2 = is.mantissa;
                        vs.mantissa1 = (is.mantissa >> 16);
                }

                vs.sign = is.sign;
    *fp = *((float*)&vs);
    maybe_flip_bytes(fp, sizeof(float));        /* Make little endian */
    return 0;
}

void  vaxf_to_local(float *val, const int *n, int *errcode)
{
#if defined(VAXFP)
#include <cvtdef>
#include <cvt$routines>
#endif
    int i;
    *errcode=0;
#if defined(VAXFP)
        /* Do a null conversion to replace invalid values (prevents floating exceptions later on) */
        for(i=0; i<*n; i++)
        {
                if ( cvt$ftof(val+i, CVT$K_VAX_F, val+i, CVT$K_VAX_F, CVT$M_REPORT_ALL) != CVT$K_NORMAL )
                {
                        val[i] = 0.0;   /* Fix with a safe value when status shows an invalid real is being converted */
                }
        }
#elif defined(IEEEFP)
        for(i=0; i<*n; i++)
        {
                if (vax_to_ieee_float(i+val) != 0)
                {
                        *errcode=1;
                }
        }
#else
#error Unknown floating point format
#endif
    return;
}

void  local_to_vaxf(float *val, const int *n, int *errcode)
{
        int i;
        *errcode=0;
#if defined(VAXFP)
        /* nothing required */
#elif defined(IEEEFP)
        for(i=0; i<*n; i++)
        {
                if (ieee_to_vax_float(i+val) != 0)
                {
                        *errcode=1;
                }
        }
#else
#error Unknown floating point format
#endif
        return;
}

void  ieee_float_to_local(float *val, const int *n, int *errcode)
{
#if defined(IEEEFP)
        *errcode=0;
#elif defined(VAXFP)
        int i;
        *errcode=0;
        for(i=0; i<*n; i++)
        {
//                if (ieee_to_vax_float(i+val) != 0)
                if ( cvt$ftof(val+i, CVT$K_IEEE_S, val+i, VMS_FLOAT_NATIVE, 0) != CVT$K_NORMAL )
                {
                        *errcode=1;
                        val[i] = 0.0;
                }
        }
#else
#error Unknown floating point format
#endif
        return;
}

void  ieee_double_to_local(double *val, const int *n, int *errcode)
{
#if defined(IEEEFP)
        *errcode=0;
#elif defined(VAXFP)
#include <cvtdef>
#include <cvt$routines>
        int i;
        *errcode=0;
        for(i=0; i<*n; i++)
        {
                if ( cvt$ftof(val+i, CVT$K_IEEE_T, val+i, VMS_DOUBLE_NATIVE, CVT$M_REPORT_ALL) != CVT$K_NORMAL )
                {
                        val[i] = 0.0;
                        *errcode=1;
                }
        }
#else
#error Unknown floating point format
#endif
        return;
}

void  local_to_ieee_float(float *val, const int *n, int *errcode)
{
#if defined(IEEEFP)
        *errcode=0;
#elif defined(VAXFP)
#include <cvtdef>
#include <cvt$routines>
        int i;
        *errcode=0;
        for(i=0; i<*n; i++)
        {
                if ( cvt$ftof(val+i, VMS_FLOAT_NATIVE, val+i, CVT$K_IEEE_S, CVT$M_REPORT_ALL) != CVT$K_NORMAL )
                {
                        val[i] = 0.0;
                        *errcode=1;
                }
        }
#else
#error Unknown floating point format
#endif
        return;
}

void  local_to_ieee_double(double *val, const int *n, int *errcode)
{
#if defined(IEEEFP)
        *errcode=0;
#elif defined(VAXFP)
        int i;
        *errcode=0;
        for(i=0; i<*n; i++)
        {
                if ( cvt$ftof(val+i, VMS_DOUBLE_NATIVE, val+i, CVT$K_IEEE_T, CVT$M_REPORT_ALL) != CVT$K_NORMAL )
                {
                        val[i] = 0.0;
                        *errcode=1;
                }
        }
#else
#error Unknown floating point format
#endif
        return;
}

#if 0
static unsigned char flip_bits(unsigned char cc)
{
    static int init = 0;
    static unsigned char ct[256];
    if (!init)
    {
        unsigned _i,_j;
        for(_i=0; _i<256; _i++)
        {
            ct[_i] = 0;
            for(_j=0; _j<8; _j++)
            {
                if (_i & (1<<_j)) { ct[_i] |= (128 >> _j); }
            }
        }
        init = 1;
    }
    return ct[cc];
}
#endif