/* Copyright 2003-2018, University Corporation for Atmospheric

 * Research. See COPYRIGHT file for copying and redistribution

 * conditions.*/

/**

 * @file

 * @internal This file is part of netcdf-4, a netCDF-like interface

 * for HDF5, or a HDF5 backend for netCDF, depending on your point of

 * view. This file handles the NetCDF-4 variable functions.

 *

 * @author Ed Hartnett, Dennis Heimbigner, Ward Fisher

 */

#include "config.h"

#include <nc4internal.h>

#include "nc4dispatch.h"

#ifdef USE_HDF5

#include "hdf5internal.h"

#endif

#include <math.h>

/**

 * @internal This is called by nc_get_var_chunk_cache(). Get chunk

 * cache size for a variable.

 *

 * @param ncid File ID.

 * @param varid Variable ID.

 * @param sizep Gets size in bytes of cache.

 * @param nelemsp Gets number of element slots in cache.

 * @param preemptionp Gets cache swapping setting.

 *

 * @returns ::NC_NOERR No error.

 * @returns ::NC_EBADID Bad ncid.

 * @returns ::NC_ENOTVAR Invalid variable ID.

 * @returns ::NC_ENOTNC4 Not a netCDF-4 file.

 * @author Ed Hartnett

 */

int

NC4_get_var_chunk_cache(int ncid, int varid, size_t *sizep,

                        size_t *nelemsp, float *preemptionp)

{

    NC *nc;

    NC_GRP_INFO_T *grp;

    NC_FILE_INFO_T *h5;

    NC_VAR_INFO_T *var;

    int retval;

    /* Find info for this file and group, and set pointer to each. */

    if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))

        return retval;

    assert(nc && grp && h5);

    /* Find the var. */

    var = (NC_VAR_INFO_T*)ncindexith(grp->vars,varid);

    if(!var)

        return NC_ENOTVAR;

    assert(var && var->hdr.id == varid);

    /* Give the user what they want. */

    if (sizep)

        *sizep = var->chunk_cache_size;

    if (nelemsp)

        *nelemsp = var->chunk_cache_nelems;

    if (preemptionp)

        *preemptionp = var->chunk_cache_preemption;

    return NC_NOERR;

}

/**

 * @internal A wrapper for NC4_get_var_chunk_cache(), we need this

 * version for fortran.

 *

 * @param ncid File ID.

 * @param varid Variable ID.

 * @param sizep Gets size in MB of cache.

 * @param nelemsp Gets number of element slots in cache.

 * @param preemptionp Gets cache swapping setting.

 *

 * @returns ::NC_NOERR No error.

 * @returns ::NC_EBADID Bad ncid.

 * @returns ::NC_ENOTVAR Invalid variable ID.

 * @returns ::NC_ENOTNC4 Not a netCDF-4 file.

 * @author Ed Hartnett

 */

int

nc_get_var_chunk_cache_ints(int ncid, int varid, int *sizep,

                            int *nelemsp, int *preemptionp)

{

    size_t real_size, real_nelems;

    float real_preemption;

    int ret;

    if ((ret = NC4_get_var_chunk_cache(ncid, varid, &real_size,

                                       &real_nelems, &real_preemption)))

        return ret;

    if (sizep)

        *sizep = real_size / MEGABYTE;

    if (nelemsp)

        *nelemsp = (int)real_nelems;

    if(preemptionp)

        *preemptionp = (int)(real_preemption * 100);

    return NC_NOERR;

}

/**

 * @internal Get all the information about a variable. Pass NULL for

 * whatever you don't care about. This is the internal function called

 * by nc_inq_var(), nc_inq_var_deflate(), nc_inq_var_fletcher32(),

 * nc_inq_var_chunking(), nc_inq_var_chunking_ints(),

 * nc_inq_var_fill(), nc_inq_var_endian(), nc_inq_var_filter(), and

 * nc_inq_var_szip().

 *

 * @param ncid File ID.

 * @param varid Variable ID.

 * @param name Gets name.

 * @param xtypep Gets type.

 * @param ndimsp Gets number of dims.

 * @param dimidsp Gets array of dim IDs.

 * @param nattsp Gets number of attributes.

 * @param shufflep Gets shuffle setting.

 * @param deflatep Gets deflate setting.

 * @param deflate_levelp Gets deflate level.

 * @param fletcher32p Gets fletcher32 setting.

 * @param storagep Gets storage setting.

 * @param chunksizesp Gets chunksizes.

 * @param no_fill Gets fill mode.

 * @param fill_valuep Gets fill value.

 * @param endiannessp Gets one of ::NC_ENDIAN_BIG ::NC_ENDIAN_LITTLE

 * ::NC_ENDIAN_NATIVE

 * @param idp Pointer to memory to store filter id.

 * @param nparamsp Pointer to memory to store filter parameter count.

 * @param params Pointer to vector of unsigned integers into which

 * to store filter parameters.

 *

 * @returns ::NC_NOERR No error.

 * @returns ::NC_EBADID Bad ncid.

 * @returns ::NC_ENOTVAR Bad varid.

 * @returns ::NC_ENOMEM Out of memory.

 * @returns ::NC_EINVAL Invalid input.

 * @author Ed Hartnett, Dennis Heimbigner

 */

int

NC4_inq_var_all(int ncid, int varid, char *name, nc_type *xtypep,

                int *ndimsp, int *dimidsp, int *nattsp,

                int *shufflep, int *deflatep, int *deflate_levelp,

                int *fletcher32p, int *storagep, size_t *chunksizesp,

                int *no_fill, void *fill_valuep, int *endiannessp,

                unsigned int *idp, size_t *nparamsp, unsigned int *params)

{

    NC_GRP_INFO_T *grp;

    NC_FILE_INFO_T *h5;

    NC_VAR_INFO_T *var;

    int d;

    int retval;

    LOG((2, "%s: ncid 0x%x varid %d", __func__, ncid, varid));

    /* Find info for this file and group, and set pointer to each. */

    if ((retval = nc4_find_nc_grp_h5(ncid, NULL, &grp, &h5)))

        return retval;

    assert(grp && h5);

    /* If the varid is -1, find the global atts and call it a day. */

    if (varid == NC_GLOBAL && nattsp)

    {

        *nattsp = ncindexcount(grp->att);

        return NC_NOERR;

    }

    /* Find the var. */

    if (!(var = (NC_VAR_INFO_T *)ncindexith(grp->vars, varid)))

        return NC_ENOTVAR;

    assert(var && var->hdr.id == varid);

    /* Copy the data to the user's data buffers. */

    if (name)

        strcpy(name, var->hdr.name);

    if (xtypep)

        *xtypep = var->type_info->hdr.id;

    if (ndimsp)

        *ndimsp = var->ndims;

    if (dimidsp)

        for (d = 0; d < var->ndims; d++)

            dimidsp[d] = var->dimids[d];

    if (nattsp)

        *nattsp = ncindexcount(var->att);

    /* Did the user want the chunksizes? */

    if (var->storage == NC_CHUNKED && chunksizesp)

    {

        for (d = 0; d < var->ndims; d++)

        {

            chunksizesp[d] = var->chunksizes[d];

            LOG((4, "chunksizesp[%d]=%d", d, chunksizesp[d]));

        }

    }

    /* Did the user inquire about the storage? */

    if (storagep)

  *storagep = var->storage;

    /* Filter stuff. */

    if (shufflep)

        *shufflep = (int)var->shuffle;

    if (fletcher32p)

        *fletcher32p = (int)var->fletcher32;

    if (deflatep)

  return NC_EFILTER;

    if (idp) {

#if 0

        NC* nc = h5->controller;

  NC_FILTER_ACTION action;

  action.action = NCFILTER_INQ_FILTER;

  action.format = NC_FORMATX_NC_HDF5;

  action.id =  (idp)?*idp:0;

  action.nelems = (nparamsp)?*nparamsp:0;

  action.elems = params;

  if((retval = nc->dispatch->filter_actions(ncid,varid,&action)) == NC_NOERR) {

      if(idp) *idp = action.id;

      if(nparamsp) *nparamsp = action.nelems;

  }

  return retval;

#else

  return NC_EFILTER;

#endif

    }

    /* Fill value stuff. */

    if (no_fill)

        *no_fill = (int)var->no_fill;

    /* Don't do a thing with fill_valuep if no_fill mode is set for

     * this var, or if fill_valuep is NULL. */

    if (!var->no_fill && fill_valuep)

    {

        /* Do we have a fill value for this var? */

        if (var->fill_value)

        {

            if (var->type_info->nc_type_class == NC_STRING)

            {

                assert(*(char **)var->fill_value);

                /* This will allocate memory and copy the string. */

                if (!(*(char **)fill_valuep = strdup(*(char **)var->fill_value)))

                {

                    free(*(char **)fill_valuep);

                    return NC_ENOMEM;

                }

            }

            else

            {

                assert(var->type_info->size);

                memcpy(fill_valuep, var->fill_value, var->type_info->size);

            }

        }

        else

        {

            if (var->type_info->nc_type_class == NC_STRING)

            {

                if (!(*(char **)fill_valuep = calloc(1, sizeof(char *))))

                    return NC_ENOMEM;

                if ((retval = nc4_get_default_fill_value(var->type_info, (char **)fill_valuep)))

                {

                    free(*(char **)fill_valuep);

                    return retval;

                }

            }

            else

            {

                if ((retval = nc4_get_default_fill_value(var->type_info, fill_valuep)))

                    return retval;

            }

        }

    }

    /* Does the user want the endianness of this variable? */

    if (endiannessp)

        *endiannessp = var->type_info->endianness;

    return NC_NOERR;

}

/**

 * @internal Inquire about chunking settings for a var. This is used

 * by the fortran API.

 *

 * @param ncid File ID.

 * @param varid Variable ID.

 * @param storagep Gets contiguous setting.

 * @param chunksizesp Gets chunksizes.

 *

 * @returns ::NC_NOERR No error.

 * @returns ::NC_EBADID Bad ncid.

 * @returns ::NC_ENOTVAR Invalid variable ID.

 * @returns ::NC_EINVAL Invalid input

 * @returns ::NC_ENOMEM Out of memory.

 * @author Ed Hartnett

 */

int

nc_inq_var_chunking_ints(int ncid, int varid, int *storagep, int *chunksizesp)

{

    NC_VAR_INFO_T *var;

    size_t *cs = NULL;

    int i, retval;

    /* Get pointer to the var. */

    if ((retval = nc4_find_grp_h5_var(ncid, varid, NULL, NULL, &var)))

        return retval;

    assert(var);

    /* Allocate space for the size_t copy of the chunksizes array. */

    if (var->ndims)

        if (!(cs = malloc(var->ndims * sizeof(size_t))))

            return NC_ENOMEM;

    /* Call the netcdf-4 version directly. */

    retval = NC4_inq_var_all(ncid, varid, NULL, NULL, NULL, NULL, NULL,

                             NULL, NULL, NULL, NULL, storagep, cs, NULL,

                             NULL, NULL, NULL, NULL, NULL);

    /* Copy from size_t array. */

    if (!retval && chunksizesp && var->storage == NC_CHUNKED)

    {

        for (i = 0; i < var->ndims; i++)

        {

            chunksizesp[i] = (int)cs[i];

            if (cs[i] > NC_MAX_INT)

                retval = NC_ERANGE;

        }

    }

    if (var->ndims)

        free(cs);

    return retval;

}

/**

 * @internal Find the ID of a variable, from the name. This function

 * is called by nc_inq_varid().

 *

 * @param ncid File ID.

 * @param name Name of the variable.

 * @param varidp Gets variable ID.

 * @returns ::NC_NOERR No error.

 * @returns ::NC_EBADID Bad ncid.

 * @returns ::NC_ENOTVAR Bad variable ID.

 */

int

NC4_inq_varid(int ncid, const char *name, int *varidp)

{

    NC *nc;

    NC_GRP_INFO_T *grp;

    NC_VAR_INFO_T *var;

    char norm_name[NC_MAX_NAME + 1];

    int retval;

    if (!name)

        return NC_EINVAL;

    if (!varidp)

        return NC_NOERR;

    LOG((2, "%s: ncid 0x%x name %s", __func__, ncid, name));

    /* Find info for this file and group, and set pointer to each. */

    if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, NULL)))

        return retval;

    /* Normalize name. */

    if ((retval = nc4_normalize_name(name, norm_name)))

        return retval;

    /* Find var of this name. */

    var = (NC_VAR_INFO_T*)ncindexlookup(grp->vars,norm_name);

    if(var)

    {

        *varidp = var->hdr.id;

        return NC_NOERR;

    }

    return NC_ENOTVAR;

}

/**

 * @internal

 *

 * This function will change the parallel access of a variable from

 * independent to collective.

 *

 * @param ncid File ID.

 * @param varid Variable ID.

 * @param par_access NC_COLLECTIVE or NC_INDEPENDENT.

 *

 * @returns ::NC_NOERR No error.

 * @returns ::NC_EBADID Invalid ncid passed.

 * @returns ::NC_ENOTVAR Invalid varid passed.

 * @returns ::NC_ENOPAR LFile was not opened with nc_open_par/nc_create_var.

 * @returns ::NC_EINVAL Invalid par_access specified.

 * @returns ::NC_NOERR for success

 * @author Ed Hartnett, Dennis Heimbigner

 */

int

NC4_var_par_access(int ncid, int varid, int par_access)

{

#ifndef USE_PARALLEL4

    NC_UNUSED(ncid);

    NC_UNUSED(varid);

    NC_UNUSED(par_access);

    return NC_ENOPAR;

#else

    NC *nc;

    NC_GRP_INFO_T *grp;

    NC_FILE_INFO_T *h5;

    NC_VAR_INFO_T *var;

    int retval;

    LOG((1, "%s: ncid 0x%x varid %d par_access %d", __func__, ncid,

         varid, par_access));

    if (par_access != NC_INDEPENDENT && par_access != NC_COLLECTIVE)

        return NC_EINVAL;

    /* Find info for this file and group, and set pointer to each. */

    if ((retval = nc4_find_nc_grp_h5(ncid, &nc, &grp, &h5)))

        return retval;

    /* This function only for files opened with nc_open_par or nc_create_par. */

    if (!h5->parallel)

        return NC_ENOPAR;

    /* Find the var, and set its preference. */

    var = (NC_VAR_INFO_T*)ncindexith(grp->vars,varid);

    if (!var) return NC_ENOTVAR;

    assert(var->hdr.id == varid);

    /* If zlib, shuffle, or fletcher32 filters are in use, then access

     * must be collective. Fail an attempt to set such a variable to

     * independent access. */

    if ((nclistlength(var->filters) > 0 || var->shuffle || var->fletcher32) &&

        par_access == NC_INDEPENDENT)

        return NC_EINVAL;

    if (par_access)

        var->parallel_access = NC_COLLECTIVE;

    else

        var->parallel_access = NC_INDEPENDENT;

    return NC_NOERR;

#endif /* USE_PARALLEL4 */

}

/**

 * @internal Copy data from one buffer to another, performing

 * appropriate data conversion.

 *

 * This function will copy data from one buffer to another, in

 * accordance with the types. Range errors will be noted, and the fill

 * value used (or the default fill value if none is supplied) for

 * values that overflow the type.

 *

 * @param src Pointer to source of data.

 * @param dest Pointer that gets data.

 * @param src_type Type ID of source data.

 * @param dest_type Type ID of destination data.

 * @param len Number of elements of data to copy.

 * @param range_error Pointer that gets 1 if there was a range error.

 * @param fill_value The fill value.

 * @param strict_nc3 Non-zero if strict model in effect.

 *

 * @returns NC_NOERR No error.

 * @returns NC_EBADTYPE Type not found.

 * @author Ed Hartnett, Dennis Heimbigner

 */

int

nc4_convert_type(const void *src, void *dest, const nc_type src_type,

                 const nc_type dest_type, const size_t len, int *range_error,

                 const void *fill_value, int strict_nc3)

{

    char *cp, *cp1;

    float *fp, *fp1;

    double *dp, *dp1;

    int *ip, *ip1;

    short *sp, *sp1;

    signed char *bp, *bp1;

    unsigned char *ubp, *ubp1;

    unsigned short *usp, *usp1;

    unsigned int *uip, *uip1;

    long long *lip, *lip1;

    unsigned long long *ulip, *ulip1;

    size_t count = 0;

    *range_error = 0;

    LOG((3, "%s: len %d src_type %d dest_type %d", __func__, len, src_type,

         dest_type));

    /* OK, this is ugly. If you can think of anything better, I'm open

       to suggestions!

       Note that we don't use a default fill value for type

       NC_BYTE. This is because Lord Voldemort cast a nofilleramous spell

       at Harry Potter, but it bounced off his scar and hit the netcdf-4

       code.

    */

    switch (src_type)

    {

    case NC_CHAR:

        switch (dest_type)

        {

        case NC_CHAR:

            for (cp = (char *)src, cp1 = dest; count < len; count++)

                *cp1++ = *cp++;

            break;

        default:

            LOG((0, "%s: Unknown destination type.", __func__));

        }

        break;

    case NC_BYTE:

        switch (dest_type)

        {

        case NC_BYTE:

            for (bp = (signed char *)src, bp1 = dest; count < len; count++)

                *bp1++ = *bp++;

            break;

        case NC_UBYTE:

            for (bp = (signed char *)src, ubp = dest; count < len; count++)

            {

                if (*bp < 0)

                    (*range_error)++;

                *ubp++ = *bp++;

            }

            break;

        case NC_SHORT:

            for (bp = (signed char *)src, sp = dest; count < len; count++)

                *sp++ = *bp++;

            break;

        case NC_USHORT:

            for (bp = (signed char *)src, usp = dest; count < len; count++)

            {

                if (*bp < 0)

                    (*range_error)++;

                *usp++ = *bp++;

            }

            break;

        case NC_INT:

            for (bp = (signed char *)src, ip = dest; count < len; count++)

                *ip++ = *bp++;

            break;

        case NC_UINT:

            for (bp = (signed char *)src, uip = dest; count < len; count++)

            {

                if (*bp < 0)

                    (*range_error)++;

                *uip++ = *bp++;

            }

            break;

        case NC_INT64:

            for (bp = (signed char *)src, lip = dest; count < len; count++)

                *lip++ = *bp++;

            break;

        case NC_UINT64:

            for (bp = (signed char *)src, ulip = dest; count < len; count++)

            {

                if (*bp < 0)

                    (*range_error)++;

                *ulip++ = *bp++;

            }

            break;

        case NC_FLOAT:

            for (bp = (signed char *)src, fp = dest; count < len; count++)

                *fp++ = *bp++;

            break;

        case NC_DOUBLE:

            for (bp = (signed char *)src, dp = dest; count < len; count++)

                *dp++ = *bp++;

            break;

        default:

            LOG((0, "%s: unexpected dest type. src_type %d, dest_type %d",

                 __func__, src_type, dest_type));

            return NC_EBADTYPE;

        }

        break;

    case NC_UBYTE:

        switch (dest_type)

        {

        case NC_BYTE:

            for (ubp = (unsigned char *)src, bp = dest; count < len; count++)

            {

                if (!strict_nc3 && *ubp > X_SCHAR_MAX)

                    (*range_error)++;

                *bp++ = *ubp++;

            }

            break;

        case NC_SHORT:

            for (ubp = (unsigned char *)src, sp = dest; count < len; count++)

                *sp++ = *ubp++;

            break;

        case NC_UBYTE:

            for (ubp = (unsigned char *)src, ubp1 = dest; count < len; count++)

                *ubp1++ = *ubp++;

            break;

        case NC_USHORT:

            for (ubp = (unsigned char *)src, usp = dest; count < len; count++)

                *usp++ = *ubp++;

            break;

        case NC_INT:

            for (ubp = (unsigned char *)src, ip = dest; count < len; count++)

                *ip++ = *ubp++;

            break;

        case NC_UINT:

            for (ubp = (unsigned char *)src, uip = dest; count < len; count++)

                *uip++ = *ubp++;

            break;

        case NC_INT64:

            for (ubp = (unsigned char *)src, lip = dest; count < len; count++)

                *lip++ = *ubp++;

            break;

        case NC_UINT64:

            for (ubp = (unsigned char *)src, ulip = dest; count < len; count++)

                *ulip++ = *ubp++;

            break;

        case NC_FLOAT:

            for (ubp = (unsigned char *)src, fp = dest; count < len; count++)

                *fp++ = *ubp++;

            break;

        case NC_DOUBLE:

            for (ubp = (unsigned char *)src, dp = dest; count < len; count++)

                *dp++ = *ubp++;

            break;

        default:

            LOG((0, "%s: unexpected dest type. src_type %d, dest_type %d",

                 __func__, src_type, dest_type));

            return NC_EBADTYPE;

        }

        break;

    case NC_SHORT:

        switch (dest_type)

        {

        case NC_UBYTE:

            for (sp = (short *)src, ubp = dest; count < len; count++)

            {

                if (*sp > X_UCHAR_MAX || *sp < 0)

                    (*range_error)++;

                *ubp++ = *sp++;

            }

            break;

        case NC_BYTE:

            for (sp = (short *)src, bp = dest; count < len; count++)

            {

                if (*sp > X_SCHAR_MAX || *sp < X_SCHAR_MIN)

                    (*range_error)++;

                *bp++ = *sp++;

            }

            break;

        case NC_SHORT:

            for (sp = (short *)src, sp1 = dest; count < len; count++)

                *sp1++ = *sp++;

            break;

        case NC_USHORT:

            for (sp = (short *)src, usp = dest; count < len; count++)

            {

                if (*sp < 0)

                    (*range_error)++;

                *usp++ = *sp++;

            }

            break;

        case NC_INT:

            for (sp = (short *)src, ip = dest; count < len; count++)

                *ip++ = *sp++;

            break;

        case NC_UINT:

            for (sp = (short *)src, uip = dest; count < len; count++)

            {

                if (*sp < 0)

                    (*range_error)++;

                *uip++ = *sp++;

            }

            break;

        case NC_INT64:

            for (sp = (short *)src, lip = dest; count < len; count++)

                *lip++ = *sp++;

            break;

        case NC_UINT64:

            for (sp = (short *)src, ulip = dest; count < len; count++)

            {

                if (*sp < 0)

                    (*range_error)++;

                *ulip++ = *sp++;

            }

            break;

        case NC_FLOAT:

            for (sp = (short *)src, fp = dest; count < len; count++)

                *fp++ = *sp++;

            break;

        case NC_DOUBLE:

            for (sp = (short *)src, dp = dest; count < len; count++)

                *dp++ = *sp++;

            break;

        default:

            LOG((0, "%s: unexpected dest type. src_type %d, dest_type %d",

                 __func__, src_type, dest_type));

            return NC_EBADTYPE;

        }

        break;

    case NC_USHORT:

        switch (dest_type)

        {

        case NC_UBYTE:

            for (usp = (unsigned short *)src, ubp = dest; count < len; count++)

            {

                if (*usp > X_UCHAR_MAX)

                    (*range_error)++;

                *ubp++ = *usp++;

            }

            break;

        case NC_BYTE:

            for (usp = (unsigned short *)src, bp = dest; count < len; count++)

            {

                if (*usp > X_SCHAR_MAX)

                    (*range_error)++;

                *bp++ = *usp++;

            }

            break;

        case NC_SHORT:

            for (usp = (unsigned short *)src, sp = dest; count < len; count++)

            {

                if (*usp > X_SHORT_MAX)

                    (*range_error)++;

                *sp++ = *usp++;

            }

            break;

        case NC_USHORT:

            for (usp = (unsigned short *)src, usp1 = dest; count < len; count++)

                *usp1++ = *usp++;

            break;

        case NC_INT:

            for (usp = (unsigned short *)src, ip = dest; count < len; count++)

                *ip++ = *usp++;

            break;

        case NC_UINT:

            for (usp = (unsigned short *)src, uip = dest; count < len; count++)

                *uip++ = *usp++;

            break;

        case NC_INT64:

            for (usp = (unsigned short *)src, lip = dest; count < len; count++)

                *lip++ = *usp++;

            break;

        case NC_UINT64:

            for (usp = (unsigned short *)src, ulip = dest; count < len; count++)

                *ulip++ = *usp++;

            break;

        case NC_FLOAT:

            for (usp = (unsigned short *)src, fp = dest; count < len; count++)

                *fp++ = *usp++;

            break;

        case NC_DOUBLE:

            for (usp = (unsigned short *)src, dp = dest; count < len; count++)

                *dp++ = *usp++;

            break;

        default:

            LOG((0, "%s: unexpected dest type. src_type %d, dest_type %d",

                 __func__, src_type, dest_type));

            return NC_EBADTYPE;

        }

        break;

    case NC_INT:

        switch (dest_type)

        {

        case NC_UBYTE:

            for (ip = (int *)src, ubp = dest; count < len; count++)

            {

                if (*ip > X_UCHAR_MAX || *ip < 0)

                    (*range_error)++;

                *ubp++ = *ip++;

            }

            break;

        case NC_BYTE:

            for (ip = (int *)src, bp = dest; count < len; count++)

            {

                if (*ip > X_SCHAR_MAX || *ip < X_SCHAR_MIN)

                    (*range_error)++;

                *bp++ = *ip++;

            }

            break;

        case NC_SHORT:

            for (ip = (int *)src, sp = dest; count < len; count++)

            {

                if (*ip > X_SHORT_MAX || *ip < X_SHORT_MIN)

                    (*range_error)++;

                *sp++ = *ip++;

            }

            break;

        case NC_USHORT:

            for (ip = (int *)src, usp = dest; count < len; count++)

            {

                if (*ip > X_USHORT_MAX || *ip < 0)

                    (*range_error)++;

                *usp++ = *ip++;

            }

            break;

        case NC_INT: /* src is int */

            for (ip = (int *)src, ip1 = dest; count < len; count++)

            {

                if (*ip > X_INT_MAX || *ip < X_INT_MIN)

                    (*range_error)++;

                *ip1++ = *ip++;

            }

            break;

        case NC_UINT:

            for (ip = (int *)src, uip = dest; count < len; count++)

            {

                if (*ip > X_UINT_MAX || *ip < 0)

                    (*range_error)++;

                *uip++ = *ip++;

            }

            break;

        case NC_INT64:

            for (ip = (int *)src, lip = dest; count < len; count++)

                *lip++ = *ip++;

            break;

        case NC_UINT64:

            for (ip = (int *)src, ulip = dest; count < len; count++)

            {

                if (*ip < 0)

                    (*range_error)++;

                *ulip++ = *ip++;

            }

            break;

        case NC_FLOAT:

            for (ip = (int *)src, fp = dest; count < len; count++)

                *fp++ = *ip++;

            break;

        case NC_DOUBLE:

            for (ip = (int *)src, dp = dest; count < len; count++)

                *dp++ = *ip++;

            break;

        default:

            LOG((0, "%s: unexpected dest type. src_type %d, dest_type %d",

                 __func__, src_type, dest_type));

            return NC_EBADTYPE;

        }

        break;

    case NC_UINT:

        switch (dest_type)

        {

        case NC_UBYTE:

            for (uip = (unsigned int *)src, ubp = dest; count < len; count++)

            {

                if (*uip > X_UCHAR_MAX)

                    (*range_error)++;

                *ubp++ = *uip++;

            }

            break;

        case NC_BYTE:

            for (uip = (unsigned int *)src, bp = dest; count < len; count++)

            {

                if (*uip > X_SCHAR_MAX)

                    (*range_error)++;

                *bp++ = *uip++;

            }

            break;

        case NC_SHORT:

            for (uip = (unsigned int *)src, sp = dest; count < len; count++)

            {

                if (*uip > X_SHORT_MAX)

                    (*range_error)++;

                *sp++ = *uip++;

            }

            break;

        case NC_USHORT:

            for (uip = (unsigned int *)src, usp = dest; count < len; count++)

            {

                if (*uip > X_USHORT_MAX)

                    (*range_error)++;

                *usp++ = *uip++;

            }

            break;

        case NC_INT:

            for (uip = (unsigned int *)src, ip = dest; count < len; count++)

            {

                if (*uip > X_INT_MAX)

                    (*range_error)++;

                *ip++ = *uip++;

            }

            break;

        case NC_UINT:

            for (uip = (unsigned int *)src, uip1 = dest; count < len; count++)