/* Do not edit this file. It is produced from the corresponding .m4 source */

/*

 *  Copyright 2018, University Corporation for Atmospheric Research

 *      See netcdf/COPYRIGHT file for copying and redistribution conditions.

 */

/* $Id: putget.m4 2783 2014-10-26 05:19:35Z wkliao $ */

#if HAVE_CONFIG_H

#include <config.h>

#endif

#include <string.h>

#include <stdlib.h>

#include <assert.h>

#include "netcdf.h"

#include "nc3dispatch.h"

#include "nc3internal.h"

#include "ncx.h"

#include "fbits.h"

#include "onstack.h"

#undef MIN  /* system may define MIN somewhere and complain */

#define MIN(mm,nn) (((mm) < (nn)) ? (mm) : (nn))

static int

readNCv(const NC3_INFO* ncp, const NC_var* varp, const size_t* start,

        const size_t nelems, void* value, const nc_type memtype);

static int

writeNCv(NC3_INFO* ncp, const NC_var* varp, const size_t* start,

         const size_t nelems, const void* value, const nc_type memtype);

/* #define ODEBUG 1 */

#if ODEBUG

#include <stdio.h>

/*

 * Print the values of an array of size_t

 */

void

arrayp(const char *label, size_t count, const size_t *array)

{

  (void) fprintf(stderr, "%s", label);

  (void) fputc('\t',stderr);

  for(; count > 0; count--, array++)

    (void) fprintf(stderr," %lu", (unsigned long)*array);

  (void) fputc('\n',stderr);

}

#endif /* ODEBUG */

/* Begin fill */

/*

 * This is tunable parameter.

 * It essentially controls the tradeoff between the number of times

 * memcpy() gets called to copy the external data to fill

 * a large buffer vs the number of times its called to

 * prepare the external data.

 */

#if _SX

/* NEC SX specific optimization */

#define NFILL 2048

#else

#define NFILL 16

#endif

/*

 * Next 6 type specific functions

 * Fill a some memory with the default special value.

 * Formerly

NC_arrayfill()

 */

static int

NC_fill_schar(

  void **xpp,

  size_t nelems)  /* how many */

{

  schar fillp[NFILL * sizeof(double)/X_SIZEOF_CHAR];

  assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));

  {

    schar *vp = fillp;  /* lower bound of area to be filled */

    const schar *const end = vp + nelems;

    while(vp < end)

    {

      *vp++ = NC_FILL_BYTE;

    }

  }

  return ncx_putn_schar_schar(xpp, nelems, fillp ,NULL);

}

static int

NC_fill_char(

  void **xpp,

  size_t nelems)  /* how many */

{

  char fillp[NFILL * sizeof(double)/X_SIZEOF_CHAR];

  assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));

  {

    char *vp = fillp; /* lower bound of area to be filled */

    const char *const end = vp + nelems;

    while(vp < end)

    {

      *vp++ = NC_FILL_CHAR;

    }

  }

  return ncx_putn_char_char(xpp, nelems, fillp );

}

static int

NC_fill_short(

  void **xpp,

  size_t nelems)  /* how many */

{

  short fillp[NFILL * sizeof(double)/X_SIZEOF_SHORT];

  assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));

  {

    short *vp = fillp;  /* lower bound of area to be filled */

    const short *const end = vp + nelems;

    while(vp < end)

    {

      *vp++ = NC_FILL_SHORT;

    }

  }

  return ncx_putn_short_short(xpp, nelems, fillp ,NULL);

}

#if (SIZEOF_INT >= X_SIZEOF_INT)

static int

NC_fill_int(

  void **xpp,

  size_t nelems)  /* how many */

{

  int fillp[NFILL * sizeof(double)/X_SIZEOF_INT];

  assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));

  {

    int *vp = fillp;  /* lower bound of area to be filled */

    const int *const end = vp + nelems;

    while(vp < end)

    {

      *vp++ = NC_FILL_INT;

    }

  }

  return ncx_putn_int_int(xpp, nelems, fillp ,NULL);

}

#elif SIZEOF_LONG == X_SIZEOF_INT

static int

NC_fill_int(

  void **xpp,

  size_t nelems)  /* how many */

{

  long fillp[NFILL * sizeof(double)/X_SIZEOF_INT];

  assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));

  {

    long *vp = fillp; /* lower bound of area to be filled */

    const long *const end = vp + nelems;

    while(vp < end)

    {

      *vp++ = NC_FILL_INT;

    }

  }

  return ncx_putn_int_long(xpp, nelems, fillp ,NULL);

}

#else

#error "NC_fill_int implementation"

#endif

static int

NC_fill_float(

  void **xpp,

  size_t nelems)  /* how many */

{

  float fillp[NFILL * sizeof(double)/X_SIZEOF_FLOAT];

  assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));

  {

    float *vp = fillp;  /* lower bound of area to be filled */

    const float *const end = vp + nelems;

    while(vp < end)

    {

      *vp++ = NC_FILL_FLOAT;

    }

  }

  return ncx_putn_float_float(xpp, nelems, fillp ,NULL);

}

static int

NC_fill_double(

  void **xpp,

  size_t nelems)  /* how many */

{

  double fillp[NFILL * sizeof(double)/X_SIZEOF_DOUBLE];

  assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));

  {

    double *vp = fillp; /* lower bound of area to be filled */

    const double *const end = vp + nelems;

    while(vp < end)

    {

      *vp++ = NC_FILL_DOUBLE;

    }

  }

  return ncx_putn_double_double(xpp, nelems, fillp ,NULL);

}

static int

NC_fill_uchar(

  void **xpp,

  size_t nelems)  /* how many */

{

  uchar fillp[NFILL * sizeof(double)/X_SIZEOF_UBYTE];

  assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));

  {

    uchar *vp = fillp;  /* lower bound of area to be filled */

    const uchar *const end = vp + nelems;

    while(vp < end)

    {

      *vp++ = NC_FILL_UBYTE;

    }

  }

  return ncx_putn_uchar_uchar(xpp, nelems, fillp ,NULL);

}

static int

NC_fill_ushort(

  void **xpp,

  size_t nelems)  /* how many */

{

  ushort fillp[NFILL * sizeof(double)/X_SIZEOF_USHORT];

  assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));

  {

    ushort *vp = fillp; /* lower bound of area to be filled */

    const ushort *const end = vp + nelems;

    while(vp < end)

    {

      *vp++ = NC_FILL_USHORT;

    }

  }

  return ncx_putn_ushort_ushort(xpp, nelems, fillp ,NULL);

}

static int

NC_fill_uint(

  void **xpp,

  size_t nelems)  /* how many */

{

  uint fillp[NFILL * sizeof(double)/X_SIZEOF_UINT];

  assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));

  {

    uint *vp = fillp; /* lower bound of area to be filled */

    const uint *const end = vp + nelems;

    while(vp < end)

    {

      *vp++ = NC_FILL_UINT;

    }

  }

  return ncx_putn_uint_uint(xpp, nelems, fillp ,NULL);

}

static int

NC_fill_longlong(

  void **xpp,

  size_t nelems)  /* how many */

{

  longlong fillp[NFILL * sizeof(double)/X_SIZEOF_LONGLONG];

  assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));

  {

    longlong *vp = fillp; /* lower bound of area to be filled */

    const longlong *const end = vp + nelems;

    while(vp < end)

    {

      *vp++ = NC_FILL_INT64;

    }

  }

  return ncx_putn_longlong_longlong(xpp, nelems, fillp ,NULL);

}

static int

NC_fill_ulonglong(

  void **xpp,

  size_t nelems)  /* how many */

{

  ulonglong fillp[NFILL * sizeof(double)/X_SIZEOF_ULONGLONG];

  assert(nelems <= sizeof(fillp)/sizeof(fillp[0]));

  {

    ulonglong *vp = fillp;  /* lower bound of area to be filled */

    const ulonglong *const end = vp + nelems;

    while(vp < end)

    {

      *vp++ = NC_FILL_UINT64;

    }

  }

  return ncx_putn_ulonglong_ulonglong(xpp, nelems, fillp ,NULL);

}

/*

 * Fill the external space for variable 'varp' values at 'recno' with

 * the appropriate value. If 'varp' is not a record variable, fill the

 * whole thing.  For the special case when 'varp' is the only record

 * variable and it is of type byte, char, or short, varsize should be

 * ncp->recsize, otherwise it should be varp->len.

 * Formerly

xdr_NC_fill()

 */

int

fill_NC_var(NC3_INFO* ncp, const NC_var *varp, long long varsize, size_t recno)

{

  char xfillp[NFILL * X_SIZEOF_DOUBLE];

  const size_t step = varp->xsz;

  const size_t nelems = sizeof(xfillp)/step;

  const size_t xsz = varp->xsz * nelems;

  NC_attr **attrpp = NULL;

  off_t offset;

  long long remaining = varsize;

  void *xp;

  int status = NC_NOERR;

  /*

   * Set up fill value

   */

  attrpp = NC_findattr(&varp->attrs, _FillValue);

  if( attrpp != NULL )

  {

    /* User defined fill value */

    if( (*attrpp)->type != varp->type || (*attrpp)->nelems != 1 )

    {

      return NC_EBADTYPE;

    }

    else

    {

      /* Use the user defined value */

      char *cp = xfillp;

      const char *const end = &xfillp[sizeof(xfillp)];

      assert(step <= (*attrpp)->xsz);

      for( /*NADA*/; cp < end; cp += step)

      {

        (void) memcpy(cp, (*attrpp)->xvalue, step);

      }

    }

  }

  else

  {

    /* use the default */

    assert(xsz % X_ALIGN == 0);

    assert(xsz <= sizeof(xfillp));

    xp = xfillp;

    switch(varp->type){

    case NC_BYTE :

      status = NC_fill_schar(&xp, nelems);

      break;

    case NC_CHAR :

      status = NC_fill_char(&xp, nelems);

      break;

    case NC_SHORT :

      status = NC_fill_short(&xp, nelems);

      break;

    case NC_INT :

      status = NC_fill_int(&xp, nelems);

      break;

    case NC_FLOAT :

      status = NC_fill_float(&xp, nelems);

      break;

    case NC_DOUBLE :

      status = NC_fill_double(&xp, nelems);

      break;

                case NC_UBYTE :

                        status = NC_fill_uchar(&xp, nelems);

                        break;

                case NC_USHORT :

                        status = NC_fill_ushort(&xp, nelems);

                        break;

                case NC_UINT :

                        status = NC_fill_uint(&xp, nelems);

                        break;

                case NC_INT64 :

                        status = NC_fill_longlong(&xp, nelems);

                        break;

                case NC_UINT64 :

                        status = NC_fill_ulonglong(&xp, nelems);

                        break;

    default :

      assert("fill_NC_var invalid type" == 0);

      status = NC_EBADTYPE;

      break;

    }

    if(status != NC_NOERR)

      return status;

    assert(xp == xfillp + xsz);

  }

  /*

   * copyout:

   * xfillp now contains 'nelems' elements of the fill value

   * in external representation.

   */

  /*

   * Copy it out.

   */

  offset = varp->begin;

  if(IS_RECVAR(varp))

  {

    offset += (off_t)ncp->recsize * recno;

  }

  assert(remaining > 0);

  for(;;)

  {

    const size_t chunksz = MIN(remaining, ncp->chunk);

    size_t ii;

    status = ncio_get(ncp->nciop, offset, chunksz,

         RGN_WRITE, &xp);

    if(status != NC_NOERR)

    {

      return status;

    }

    /*

     * fill the chunksz buffer in units  of xsz

     */

    for(ii = 0; ii < chunksz/xsz; ii++)

    {

      (void) memcpy(xp, xfillp, xsz);

      xp = (char *)xp + xsz;

    }

    /*

     * Deal with any remainder

     */

    {

      const size_t rem = chunksz % xsz;

      if(rem != 0)

      {

        (void) memcpy(xp, xfillp, rem);

        /* xp = (char *)xp + xsz; */

      }

    }

    status = ncio_rel(ncp->nciop, offset, RGN_MODIFIED);

    if(status != NC_NOERR)

    {

      break;

    }

    remaining -= chunksz;

    if(remaining == 0)

      break;  /* normal loop exit */

    offset += chunksz;

  }

  return status;

}

/* End fill */

/*

 * Add a record containing the fill values.

 */

static int

NCfillrecord(NC3_INFO* ncp, const NC_var *const *varpp, size_t recno)

{

  size_t ii = 0;

  for(; ii < ncp->vars.nelems; ii++, varpp++)

  {

    if( !IS_RECVAR(*varpp) )

    {

      continue; /* skip non-record variables */

    }

    {

    const int status = fill_NC_var(ncp, *varpp, (*varpp)->len, recno);

    if(status != NC_NOERR)

      return status;

    }

  }

  return NC_NOERR;

}

/*

 * Add a record containing the fill values in the special case when

 * there is exactly one record variable, where we don't require each

 * record to be four-byte aligned (no record padding).

 */

static int

NCfillspecialrecord(NC3_INFO* ncp, const NC_var *varp, size_t recno)

{

    int status;

    assert(IS_RECVAR(varp));

    status = fill_NC_var(ncp, varp, ncp->recsize, recno);

    if(status != NC_NOERR)

  return status;

    return NC_NOERR;

}

/*

 * It is advantageous to

 * #define TOUCH_LAST

 * when using memory mapped io.

 */

#if TOUCH_LAST

/*

 * Grow the file to a size which can contain recno

 */

static int

NCtouchlast(NC3_INFO* ncp, const NC_var *const *varpp, size_t recno)

{

  int status = NC_NOERR;

  const NC_var *varp = NULL;

  {

  size_t ii = 0;

  for(; ii < ncp->vars.nelems; ii++, varpp++)

  {

    if( !IS_RECVAR(*varpp) )

    {

      continue; /* skip non-record variables */

    }

    varp = *varpp;

  }

  }

  assert(varp != NULL);

  assert( IS_RECVAR(varp) );

  {

    const off_t offset = varp->begin

        + (off_t)(recno-1) * (off_t)ncp->recsize

        + (off_t)(varp->len - varp->xsz);

    void *xp;

    status = ncio_get(ncp->nciop, offset, varp->xsz,

         RGN_WRITE, &xp);

    if(status != NC_NOERR)

      return status;

    (void)memset(xp, 0, varp->xsz);

    status = ncio_rel(ncp->nciop, offset, RGN_MODIFIED);

  }

  return status;

}

#endif /* TOUCH_LAST */

/*

 * Ensure that the netcdf file has 'numrecs' records,

 * add records and fill as necessary.

 */

static int

NCvnrecs(NC3_INFO* ncp, size_t numrecs)

{

  int status = NC_NOERR;

  if(numrecs > NC_get_numrecs(ncp))

  {

#if TOUCH_LAST

    status = NCtouchlast(ncp,

      (const NC_var *const*)ncp->vars.value,

      numrecs);

    if(status != NC_NOERR)

      goto common_return;

#endif /* TOUCH_LAST */

    set_NC_ndirty(ncp);

    if(!NC_dofill(ncp))

    {

      /* Simply set the new numrecs value */

      NC_set_numrecs(ncp, numrecs);

    }

    else

    {

        /* Treat two cases differently:

            - exactly one record variable (no padding)

                        - multiple record variables (each record padded

                          to 4-byte alignment)

        */

        NC_var **vpp = (NC_var **)ncp->vars.value;

        NC_var *const *const end = &vpp[ncp->vars.nelems];

        NC_var *recvarp = NULL; /* last record var */

        int numrecvars = 0;

        size_t cur_nrecs;

        /* determine how many record variables */

        for( /*NADA*/; vpp < end; vpp++) {

      if(IS_RECVAR(*vpp)) {

          recvarp = *vpp;

          numrecvars++;

      }

        }

        if (numrecvars != 1) { /* usual case */

      /* Fill each record out to numrecs */

      while((cur_nrecs = NC_get_numrecs(ncp)) < numrecs)

          {

        status = NCfillrecord(ncp,

          (const NC_var *const*)ncp->vars.value,

          cur_nrecs);

        if(status != NC_NOERR)

        {

          break;

        }

        NC_increase_numrecs(ncp, cur_nrecs +1);

      }

      if(status != NC_NOERR)

        goto common_return;

        } else { /* special case */

      /* Fill each record out to numrecs */

      while((cur_nrecs = NC_get_numrecs(ncp)) < numrecs)

          {

        status = NCfillspecialrecord(ncp,

          recvarp,

          cur_nrecs);

        if(status != NC_NOERR)

        {

          break;

        }

        NC_increase_numrecs(ncp, cur_nrecs +1);

      }

      if(status != NC_NOERR)

        goto common_return;

        }

    }

    if(NC_doNsync(ncp))

    {

      status = write_numrecs(ncp);

    }

  }

common_return:

  return status;

}

/*

 * Check whether 'coord' values are valid for the variable.

 */

static int

NCcoordck(NC3_INFO* ncp, const NC_var *varp, const size_t *coord)

{

  const size_t *ip;

  size_t *up;

  if(varp->ndims == 0)

    return NC_NOERR; /* 'scalar' variable */

  if(IS_RECVAR(varp))

  {

    if(*coord > X_UINT_MAX) /* rkr: bug fix from previous X_INT_MAX */

      return NC_EINVALCOORDS; /* sanity check */

    if(NC_readonly(ncp) && *coord > NC_get_numrecs(ncp))

    {

      if(!NC_doNsync(ncp))

        return NC_EINVALCOORDS;

      /* else */

      {

        /* Update from disk and check again */

        const int status = read_numrecs(ncp);

        if(status != NC_NOERR)

          return status;

        if(*coord > NC_get_numrecs(ncp))

          return NC_EINVALCOORDS;

      }

    }

    ip = coord + 1;

    up = varp->shape + 1;

  }

  else

  {

    ip = coord;

    up = varp->shape;

  }

#ifdef CDEBUG

fprintf(stderr,"  NCcoordck: coord %ld, count %d, ip %ld\n",

    coord, varp->ndims, ip );

#endif /* CDEBUG */

  for(; ip < coord + varp->ndims; ip++, up++)

  {

#ifdef CDEBUG

fprintf(stderr,"  NCcoordck: ip %p, *ip %ld, up %p, *up %lu\n",

      ip, *ip, up, *up );

#endif /* CDEBUG */

    /* cast needed for braindead systems with signed size_t */

    if((unsigned long) *ip > (unsigned long) *up )

      return NC_EINVALCOORDS;

  }

  return NC_NOERR;

}

/*

 * Check whether 'edges' are valid for the variable and 'start'

 */

/*ARGSUSED*/

static int

NCedgeck(const NC3_INFO* ncp, const NC_var *varp,

   const size_t *start, const size_t *edges)

{

  const size_t *const end = start + varp->ndims;

  const size_t *shp = varp->shape;

  if(varp->ndims == 0)

    return NC_NOERR; /* 'scalar' variable */

  if(IS_RECVAR(varp))

  {

    if (NC_readonly(ncp) &&

                    (start[0] == NC_get_numrecs(ncp) && edges[0] > 0))

      return(NC_EINVALCOORDS);

    start++;

    edges++;

    shp++;

  }

  for(; start < end; start++, edges++, shp++)

  {

    if ((unsigned long) *start == *shp && *edges > 0)

      return(NC_EINVALCOORDS);

    /* cast needed for braindead systems with signed size_t */

    if((unsigned long) *edges > *shp ||

      (unsigned long) *start + (unsigned long) *edges > *shp)

    {

      return(NC_EEDGE);

    }

  }

  return NC_NOERR;

}

/*

 * Translate the (variable, coord) pair into a seek index

 */

static off_t

NC_varoffset(const NC3_INFO* ncp, const NC_var *varp, const size_t *coord)

{

  if(varp->ndims == 0) /* 'scalar' variable */

    return varp->begin;

  if(varp->ndims == 1)

  {

    if(IS_RECVAR(varp))

      return varp->begin +

         (off_t)(*coord) * (off_t)ncp->recsize;

    /* else */

    return varp->begin + (off_t)(*coord) * (off_t)varp->xsz;

  }

  /* else */

  {

    off_t lcoord = (off_t)coord[varp->ndims -1];

    off_t *up = varp->dsizes +1;

    const size_t *ip = coord;

    const off_t *const end = varp->dsizes + varp->ndims;

    if(IS_RECVAR(varp))

      up++, ip++;

    for(; up < end; up++, ip++)

      lcoord += (off_t)(*up) * (off_t)(*ip);

    lcoord *= varp->xsz;

    if(IS_RECVAR(varp))

      lcoord += (off_t)(*coord) * ncp->recsize;

    lcoord += varp->begin;

    return lcoord;

  }

}

static int

putNCvx_char_char(NC3_INFO* ncp, const NC_var *varp,

     const size_t *start, size_t nelems, const char *value)

{

  off_t offset = NC_varoffset(ncp, varp, start);

  size_t remaining = varp->xsz * nelems;

  int status = NC_NOERR;

  void *xp;

        void *fillp=NULL;

  if(nelems == 0)

    return NC_NOERR;

  assert(value != NULL);

#ifdef ERANGE_FILL

        fillp = malloc(varp->xsz);

        status = NC3_inq_var_fill(varp, fillp);

#endif

  for(;;)

  {

    size_t extent = MIN(remaining, ncp->chunk);

    size_t nput = ncx_howmany(varp->type, extent);

    int lstatus = ncio_get(ncp->nciop, offset, extent,

         RGN_WRITE, &xp);

    if(lstatus != NC_NOERR)

      return lstatus;

    lstatus = ncx_putn_char_char(&xp, nput, value );

    if(lstatus != NC_NOERR && status == NC_NOERR)

    {

      /* not fatal to the loop */

      status = lstatus;

    }

    (void) ncio_rel(ncp->nciop, offset,

         RGN_MODIFIED);

    remaining -= extent;

    if(remaining == 0)

      break; /* normal loop exit */

    offset += (off_t)extent;

    value += nput;

  }

#ifdef ERANGE_FILL

        free(fillp);

#endif

  return status;

}

static int

putNCvx_schar_schar(NC3_INFO* ncp, const NC_var *varp,

     const size_t *start, size_t nelems, const schar *value)

{

  off_t offset = NC_varoffset(ncp, varp, start);

  size_t remaining = varp->xsz * nelems;

  int status = NC_NOERR;

  void *xp;

        void *fillp=NULL;

  if(nelems == 0)

    return NC_NOERR;

  assert(value != NULL);

#ifdef ERANGE_FILL

        fillp = malloc(varp->xsz);

        status = NC3_inq_var_fill(varp, fillp);

#endif

  for(;;)

  {

    size_t extent = MIN(remaining, ncp->chunk);

    size_t nput = ncx_howmany(varp->type, extent);

    int lstatus = ncio_get(ncp->nciop, offset, extent,

         RGN_WRITE, &xp);

    if(lstatus != NC_NOERR)

      return lstatus;

    lstatus = ncx_putn_schar_schar(&xp, nput, value ,fillp);

    if(lstatus != NC_NOERR && status == NC_NOERR)

    {

      /* not fatal to the loop */

      status = lstatus;

    }

    (void) ncio_rel(ncp->nciop, offset,

         RGN_MODIFIED);

    remaining -= extent;

    if(remaining == 0)

      break; /* normal loop exit */

    offset += (off_t)extent;

    value += nput;

  }

#ifdef ERANGE_FILL

        free(fillp);

#endif

  return status;

}

static int

putNCvx_schar_uchar(NC3_INFO* ncp, const NC_var *varp,

     const size_t *start, size_t nelems, const uchar *value)

{

  off_t offset = NC_varoffset(ncp, varp, start);

  size_t remaining = varp->xsz * nelems;

  int status = NC_NOERR;

  void *xp;

        void *fillp=NULL;

  if(nelems == 0)

    return NC_NOERR;

  assert(value != NULL);

#ifdef ERANGE_FILL

        fillp = malloc(varp->xsz);

        status = NC3_inq_var_fill(varp, fillp);

#endif

  for(;;)

  {

    size_t extent = MIN(remaining, ncp->chunk);

    size_t nput = ncx_howmany(varp->type, extent);

    int lstatus = ncio_get(ncp->nciop, offset, extent,

         RGN_WRITE, &xp);

    if(lstatus != NC_NOERR)

      return lstatus;

    lstatus = ncx_putn_schar_uchar(&xp, nput, value ,fillp);

    if(lstatus != NC_NOERR && status == NC_NOERR)

    {

      /* not fatal to the loop */

      status = lstatus;

    }

    (void) ncio_rel(ncp->nciop, offset,

         RGN_MODIFIED);

    remaining -= extent;

    if(remaining == 0)

      break; /* normal loop exit */

    offset += (off_t)extent;

    value += nput;

  }

#ifdef ERANGE_FILL

        free(fillp);

#endif

  return status;

}

static int