attr.c#163 assert(ncap->value != NULL);
#166 NC_attr **app = ncap->value;
#191 assert(ncap->value != NULL);
#195 free(ncap->value);
#196 ncap->value = NULL;
#212 ncap->value = (NC_attr **) malloc(sz);
#213 if(ncap->value == NULL)
#216 (void) memset(ncap->value, 0, sz);
#222 NC_attr **app = ncap->value;
#223 const NC_attr **drpp = (const NC_attr **)ref->value;
#267 ncap->value = vp;
#272 vp = (NC_attr **) realloc(ncap->value,
#277 ncap->value = vp;
#283 ncap->value[ncap->nelems] = newelemp;
#298 assert(ncap->value != NULL);
#300 return ncap->value[elem];
#321 vpp = (NC_var **)ncp->vars.value;
#348 attrpp = (NC_attr **) ncap->value;
#459 *attnump = (int)(attrpp - ncap->value);
#592 attrpp = (NC_attr **) ncap->value;
#1385 const void *value,
#1423    if(nelems != 0 && value == NULL)
#1444                status = dispatchput(&xpnelems, (const void*)valuetypememtype);
#1476        status = dispatchput(&xpnelems, (const void*)valuetypememtype);
#1502 void *value,
#1524        return ncx_pad_getn_text(&xpattrp->nelems , (char *)value);
#1526        return ncx_pad_getn_Ischar(&xp,attrp->nelems,(schar*)value,attrp->type);
#1528        return ncx_pad_getn_Ishort(&xp,attrp->nelems,(short*)value,attrp->type);
#1530          return ncx_pad_getn_Iint(&xp,attrp->nelems,(int*)value,attrp->type);
#1532        return ncx_pad_getn_Ifloat(&xp,attrp->nelems,(float*)value,attrp->type);
#1534        return ncx_pad_getn_Idouble(&xp,attrp->nelems,(double*)value,attrp->type);
#1536          return ncx_pad_getn_Ilonglong(&xp,attrp->nelems,(longlong*)value,attrp->type);
#1538        return ncx_pad_getn_Iuchar(&xpattrp->nelems , (uchar *)valueattrp->type);
#1540          return ncx_pad_getn_Iushort(&xp,attrp->nelems,(ushort*)value,attrp->type);
#1542          return ncx_pad_getn_Iuint(&xp,attrp->nelems,(uint*)value,attrp->type);
#1544          return ncx_pad_getn_Iulonglong(&xp,attrp->nelems,(ulonglong*)value,attrp->type);
bindata.c#40        bytes=makebytestring(con->value.opaquev.stringv,&len);
#45        bbAppendn(buf,&con->value.charv,sizeof(con->value.charv));
#48        bbAppendn(buf,(void*)&con->value.int8v,sizeof(con->value.int8v));
#51        bbAppendn(buf,(void*)&con->value.int16v,sizeof(con->value.int16v));
#54        bbAppendn(buf,(void*)&con->value.int32v,sizeof(con->value.int32v));
#57        bbAppendn(buf,(void*)&con->value.floatv,sizeof(con->value.floatv));
#60        bbAppendn(buf,(void*)&con->value.doublev,sizeof(con->value.doublev));
#63        bbAppendn(buf,(void*)&con->value.uint8v,sizeof(con->value.uint8v));
#66        bbAppendn(buf,(void*)&con->value.uint16v,sizeof(con->value.uint16v));
#69        bbAppendn(buf,(void*)&con->value.uint32v,sizeof(con->value.uint32v));
#73        si64.i64 = con->value.int64v;
#78        su64.i64 = con->value.uint64v;
#84        int len = (size_t)con->value.stringv.len;
#85 if(len == 0 && con->value.stringv.stringv == NULL) {
#90     memcpy(ptr,con->value.stringv.stringv,len);
cdata.c#38 if(con->value.charv == '\'')
#41     bbprintf(codetmp,"'%s'",cescapifychar(con->value.charv,'\''));
#44 bbprintf(codetmp,"%hhd",con->value.int8v);
#47 bbprintf(codetmp,"%hd",con->value.int16v);
#50 bbprintf(codetmp,"%d",con->value.int32v);
#54 if(isnan(con->value.floatv))
#57     bbprintf(codetmp,"%f",con->value.floatv);
#61 if(isnan(con->value.doublev))
#64     bbprintf(codetmp,"%lf",con->value.doublev);
#67        bbprintf(codetmp,"%hhuU",con->value.uint8v);
#70 bbprintf(codetmp,"%huU",con->value.uint16v);
#73 bbprintf(codetmp,"%uU",con->value.uint32v);
#76 bbprintf(codetmp,"%lldLL",con->value.int64v);
#79 bbprintf(codetmp,"%lluULL",con->value.uint64v);
#82 bbprintf(codetmp,"%s",cname(con->value.enumv));
#86 if(con->value.stringv.len == 0 && con->value.stringv.stringv == NULL) {
#89     char* escaped = escapify(con->value.stringv.stringv,
#90  '"',con->value.stringv.len);
#100 bslen=(4*con->value.opaquev.len);
#103 p = con->value.opaquev.stringv;
cvt.c#39     dst->value = src->value;
#42     econst = src->value.enumv;
#53        bytes = makebytestring(src->value.opaquev.stringv,&bytelen);
#59    tmp.charv  = src->value.charv;
#62    tmp.int8v  = (unsigned char)src->value.charv;
#65    tmp.uint8v = (unsigned char)src->value.charv;
#68    tmp.uint16v = (unsigned short)src->value.charv;
#71    tmp.uint32v = (unsigned int)src->value.charv;
#74    tmp.uint64v  = (unsigned long long)src->value.charv;
#77    tmp.int16v = (short)src->value.charv;
#80    tmp.int32v = (int)src->value.charv;
#83    tmp.int64v  = (long long)src->value.charv;
#86    tmp.floatv = (float)src->value.charv;
#89    tmp.doublev = (double)src->value.charv;
#93    tmp.charv = (char)src->value.uint8v;
#96    tmp.uint8v = (unsigned char)src->value.uint8v;
#99    tmp.uint8v = (unsigned char)src->value.uint8v;
#102    tmp.uint16v = (unsigned short)src->value.uint8v;
#105    tmp.uint32v = (unsigned int)src->value.uint8v;
#108    tmp.uint64v  = (unsigned long long)src->value.uint8v;
#111    tmp.int16v = (short)src->value.uint8v;
#114    tmp.int32v = (int)src->value.uint8v;
#117    tmp.int64v  = (long long)src->value.uint8v;
#120    tmp.floatv = (float)src->value.uint8v;
#123    tmp.doublev = (double)src->value.uint8v;
#127    tmp.charv = (char)src->value.uint8v;
#130    tmp.uint8v = (unsigned char)src->value.uint8v;
#133    tmp.uint8v = (unsigned char)src->value.uint8v;
#136    tmp.uint16v = (unsigned short)src->value.uint8v;
#139    tmp.uint32v = (unsigned int)src->value.uint8v;
#142    tmp.uint64v  = (unsigned long long)src->value.uint8v;
#145    tmp.int16v = (short)src->value.uint8v;
#148    tmp.int32v = (int)src->value.uint8v;
#151    tmp.int64v  = (long long)src->value.uint8v;
#154    tmp.floatv = (float)src->value.uint8v;
#157    tmp.doublev = (double)src->value.uint8v;
#161    tmp.uint8v = (unsigned char)src->value.uint16v;
#164    tmp.uint8v = (unsigned char)src->value.uint16v;
#167    tmp.uint16v = (unsigned short)src->value.uint16v;
#170    tmp.uint32v = (unsigned int)src->value.uint16v;
#173    tmp.uint64v  = (unsigned long long)src->value.uint16v;
#176    tmp.int16v = (short)src->value.uint16v;
#179    tmp.int32v = (int)src->value.uint16v;
#182    tmp.int64v  = (long long)src->value.uint16v;
#185    tmp.floatv = (float)src->value.uint16v;
#188    tmp.doublev = (double)src->value.uint16v;
#192    tmp.uint8v = (unsigned char)src->value.uint32v;
#195    tmp.uint8v = (unsigned char)src->value.uint32v;
#198    tmp.uint16v = (unsigned short)src->value.uint32v;
#201    tmp.uint32v = (unsigned int)src->value.uint32v;
#204    tmp.uint64v  = (unsigned long long)src->value.uint32v;
#207    tmp.int16v = (short)src->value.uint32v;
#210    tmp.int32v = (int)src->value.uint32v;
#213    tmp.int64v  = (long long)src->value.uint32v;
#216    tmp.floatv = (float)src->value.uint32v;
#219    tmp.doublev = (double)src->value.uint32v;
#223    tmp.uint8v = (unsigned char)src->value.uint64v;
#226    tmp.uint8v = (unsigned char)src->value.uint64v;
#229    tmp.uint16v = (unsigned short)src->value.uint64v;
#232    tmp.uint32v = (unsigned int)src->value.uint64v;
#235    tmp.uint64v  = (unsigned long long)src->value.uint64v;
#238    tmp.int16v = (short)src->value.uint64v;
#241    tmp.int32v = (int)src->value.uint64v;
#244    tmp.int64v  = (long long)src->value.uint64v;
#247    tmp.floatv = (float)src->value.uint64v;
#250    tmp.doublev = (double)src->value.uint64v;
#254    tmp.uint8v = (unsigned char)src->value.int16v;
#257    tmp.uint8v = (unsigned char)src->value.int16v;
#260    tmp.uint16v = (unsigned short)src->value.int16v;
#263    tmp.uint32v = (unsigned int)src->value.int16v;
#266    tmp.uint64v  = (unsigned long long)src->value.int16v;
#269    tmp.int16v = (short)src->value.int16v;
#272    tmp.int32v = (int)src->value.int16v;
#275    tmp.int64v  = (long long)src->value.int16v;
#278    tmp.floatv = (float)src->value.int16v;
#281    tmp.doublev = (double)src->value.int16v;
#285    tmp.uint8v = (unsigned char)src->value.int32v;
#288    tmp.uint8v = (unsigned char)src->value.int32v;
#291    tmp.uint16v = (unsigned short)src->value.int32v;
#294    tmp.uint32v = (unsigned int)src->value.int32v;
#297    tmp.uint64v  = (unsigned long long)src->value.int32v;
#300    tmp.int16v = (short)src->value.int32v;
#303    tmp.int32v = (int)src->value.int32v;
#306    tmp.int64v  = (long long)src->value.int32v;
#309    tmp.floatv = (float)src->value.int32v;
#312    tmp.doublev = (double)src->value.int32v;
#316    tmp.uint8v = (unsigned char)src->value.int64v;
#319    tmp.uint8v = (unsigned char)src->value.int64v;
#322    tmp.uint16v = (unsigned short)src->value.int64v;
#325    tmp.uint32v = (unsigned int)src->value.int64v;
#328    tmp.uint64v  = (unsigned long long)src->value.int64v;
#331    tmp.int16v = (short)src->value.int64v;
#334    tmp.int32v = (int)src->value.int64v;
#337    tmp.int64v  = (long long)src->value.int64v;
#340    tmp.floatv = (float)src->value.int64v;
#343    tmp.doublev = (double)src->value.int64v;
#347    tmp.uint8v = (unsigned char)src->value.floatv;
#350    tmp.uint8v = (unsigned char)src->value.floatv;
#353    tmp.uint16v = (unsigned short)src->value.floatv;
#356    tmp.uint32v = (unsigned int)src->value.floatv;
#359    tmp.uint64v  = (unsigned long long)src->value.floatv;
#362    tmp.int16v = (short)src->value.floatv;
#365    tmp.int32v = (int)src->value.floatv;
#368    tmp.int64v  = (long long)src->value.floatv;
#371    tmp.floatv = src->value.floatv;
#374    tmp.doublev = (isnan(src->value.floatv)?NAN:(double)src->value.floatv);
#377    tmp.uint8v = (unsigned char)src->value.doublev;
#380    tmp.uint8v = (unsigned char)src->value.doublev;
#383    tmp.uint16v = (unsigned short)src->value.doublev;
#386    tmp.uint32v = (unsigned int)src->value.doublev;
#389    tmp.uint64v  = (unsigned long long)src->value.doublev;
#392    tmp.int16v = (short)src->value.doublev;
#395    tmp.int32v = (int)src->value.doublev;
#398    tmp.int64v  = (long long)src->value.doublev;
#401    tmp.floatv = (isnan(src->value.doublev)?NANF:(float)src->value.doublev);
#404    tmp.doublev = (double)src->value.doublev;
#409    sscanf(src->value.stringv.stringv,"%hhd",&tmp.int8v); break;
#411    sscanf(src->value.stringv.stringv,"%hhu",&tmp.uint8v); break;
#413    sscanf(src->value.stringv.stringv,"%hu",&tmp.uint16v); break;
#415    sscanf(src->value.stringv.stringv,"%u",&tmp.uint32v); break;
#417    sscanf(src->value.stringv.stringv,"%llu",&tmp.uint64v); break;
#419    sscanf(src->value.stringv.stringv,"%hd",&tmp.int16v); break;
#421    sscanf(src->value.stringv.stringv,"%d",&tmp.int32v); break;
#423    sscanf(src->value.stringv.stringv,"%lld",&tmp.int64v); break;
#425    sscanf(src->value.stringv.stringv,"%g",&tmp.floatv); break;
#427    sscanf(src->value.stringv.stringv,"%lg",&tmp.doublev); break;
#429     tmp.charv = src->value.stringv.stringv[0];
#433    tmp.stringv.len = src->value.stringv.len;
#434    tmp.stringv.stringv = (char*)malloc(src->value.stringv.len+1);
#436           (void*)src->value.stringv.stringv,
#443    sprintf(stmp,"%c",src->value.charv);
#448    sprintf(stmp,"%hhd",src->value.uint8v);
#453    sprintf(stmp,"%hhu",src->value.uint8v);
#458    sprintf(stmp,"%hu",src->value.uint16v);
#463    sprintf(stmp,"%u",src->value.uint32v);
#468    sprintf(stmp,"%llu",src->value.uint64v);
#473    sprintf(stmp,"%hd",src->value.int16v);
#478    sprintf(stmp,"%d",src->value.int32v);
#483    sprintf(stmp,"%lld",src->value.int64v);
#488    sprintf(stmp,"%.8g",src->value.floatv);
#493    sprintf(stmp,"%.8g",src->value.doublev);
#543    tmp.opaquev.stringv = (char*)malloc(src->value.opaquev.len+1);
#544    memcpy(tmp.opaquev.stringv,src->value.opaquev.stringv,src->value.opaquev.len);
#545    tmp.opaquev.len = src->value.opaquev.len;
#567    dst->value = tmp;
#577        if(prim->value.stringv.len == len) {
#579        } else if(prim->value.stringv.len > len) { /* truncate*/
#580     prim->value.stringv.stringv[len] = '\0';
#581     prim->value.stringv.len = len;
#587     memcpy(s,prim->value.stringv.stringv,prim->value.stringv.len);
#588     efree(prim->value.stringv.stringv);
#589     prim->value.stringv.stringv = s;
#590            prim->value.stringv.len = len;
#596        if(prim->value.opaquev.len == len) {
#598        } else if(prim->value.opaquev.len > len) { /* truncate*/
#599     prim->value.opaquev.stringv[len] = '\0';
#600     prim->value.opaquev.len = len;
#605     memcpy(s,prim->value.opaquev.stringv,prim->value.opaquev.len);
#607     efree(prim->value.opaquev.stringv);
#608     prim->value.opaquev.stringv=s;
#609     prim->value.opaquev.len = len;
#623    slen = str->value.stringv.len;
#625    s = str->value.stringv.stringv;
#630        con.value.charv = s[i];
dapcvt.c#18    char* value = value0;
#55    vs##p = (ts *)value;\
#188        value += nctypesizeof(srctype);
dapparse.c#18static int check_int32(char* val, long* value);
#140    long value;
#142    if(!check_int32(size,&value)) {
#150    dim->dim.declsize = value;
#169dap_attrvalue(DAPparsestatestateObject valuelistObject valueObject etype)
#174    if(value == NULLvalue = "";
#175    oclistpush(alist,(void*)strdup(value));
#391check_int32(char* val, long* value)
#398    if(value != NULL) *value = iv;
dapparselex.h#66extern Object dap_attribute(DAPparsestate*,Object nameObject valueObject etype);
#68extern Object dap_attrvalue(DAPparsestate*,Object valuelistObject valueObject etype);
daputil.c#272    const char* value;
#275    if(!ncurilookup(nccomm->oc.url,key,&value))
#277    return value;
#288    const char* value;
#292    if(!ncurilookup(nccomm->oc.url,key,&value))
#295    p = strstr(value,subkey);
data.c#128    con.value.compoundv = list;
#203    srcpushlist(src,con->value.compoundv);
#244    ds->data[ds->index].value.compoundv = list;
#277 s = (char*)emalloc(newcon.value.stringv.len+1);
#278 memcpy(s,newcon.value.stringv.stringv,newcon.value.stringv.len);
#279 s[newcon.value.stringv.len] = '\0';
#280 newcon.value.stringv.stringv = s;
#283 s = (char*)emalloc(newcon.value.opaquev.len+1);
#284 memcpy(s,newcon.value.opaquev.stringv,newcon.value.opaquev.len);
#285 s[newcon.value.opaquev.len] = '\0';
#286 newcon.value.opaquev.stringv = s;
#450        alignment = nctypealignment(prim->value.enumv->typ.typecode);
#653    c->value.compoundv = builddatalist(0);
#664    c->value.stringv.len = 0;
#665    c->value.stringv.stringv = NULL;
#741  d.value.compoundv = dl;
data.h#54    Constvalue    value;
#134#define   compoundfor(con) ((con)==NULL?NULL:(con)->value.compoundv)
dattget.c#44nc_get_att(int ncid, int varid, const char *name, void *value)
#58   return ncp->dispatch->get_att(ncidvaridnamevaluextype);
#137nc_get_att_text(int ncid, int varid, const char *name, char *value)
#143   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_CHAR);
#147nc_get_att_schar(int ncid, int varid, const char *name, signed char *value)
#153   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_BYTE);
#157nc_get_att_uchar(int ncid, int varid, const char *name, unsigned char *value)
#163   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_UBYTE);
#167nc_get_att_short(int ncid, int varid, const char *name, short *value)
#173   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_SHORT);
#177nc_get_att_int(int ncid, int varid, const char *name, int *value)
#183   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_INT);
#187nc_get_att_long(int ncid, int varid, const char *name, long *value)
#193   return ncp->dispatch->get_att(ncidvaridname, (void *)valuelongtype);
#197nc_get_att_float(int ncid, int varid, const char *name, float *value)
#203   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_FLOAT);
#207nc_get_att_double(int ncid, int varid, const char *name, double *value)
#213   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_DOUBLE);
#217nc_get_att_ubyte(int ncid, int varid, const char *name, unsigned char *value)
#223   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_UBYTE);
#227nc_get_att_ushort(int ncid, int varid, const char *name, unsigned short *value)
#233   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_USHORT);
#237nc_get_att_uint(int ncid, int varid, const char *name, unsigned int *value)
#243   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_UINT);
#247nc_get_att_longlong(int ncid, int varid, const char *name, long long *value)
#253   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_INT64);
#257nc_get_att_ulonglong(int ncid, int varid, const char *name, unsigned long long *value)
#263   return ncp->dispatch->get_att(ncidvaridname, (void *)valueNC_UINT64);
#341nc_get_att_string(int ncid, int varid, const char *name, char **value)
#347    return ncp->dispatch->get_att(ncid,varid,name,(void*)valueNC_STRING);
dattput.c#51   size_t len, const char** value)
#57   len, (void*)valueNC_STRING);
#139 size_t len, const char *value)
#145  (void *)valueNC_CHAR);
#230    size_t len, const void *value)
#236  valuextype);
#241  nc_type xtype, size_t len, const signed char *value)
#247  (void *)valueNC_BYTE);
#252  nc_type xtype, size_t len, const unsigned char *value)
#258  (void *)valueNC_UBYTE);
#263  nc_type xtype, size_t len, const short *value)
#269  (void *)valueNC_SHORT);
#274        nc_type xtype, size_t len, const int *value)
#280  (void *)valueNC_INT);
#285 nc_type xtype, size_t len, const long *value)
#291  (void *)valuelongtype);
#296  nc_type xtype, size_t len, const float *value)
#302  (void *)valueNC_FLOAT);
#307   nc_type xtype, size_t len, const double *value)
#313  (void *)valueNC_DOUBLE);
#318  nc_type xtype, size_t len, const unsigned char *value)
#324  (void *)valueNC_UBYTE);
#329   nc_type xtype, size_t len, const unsigned short *value)
#335  (void *)valueNC_USHORT);
#340 nc_type xtype, size_t len, const unsigned int *value)
#346  (void *)valueNC_UINT);
#352     const long long *value)
#358  (void *)valueNC_INT64);
#364      const unsigned long long *value)
#370  (void *)valueNC_UINT64);
dceconstraints.c#664 DCEconstantvalue = (DCEconstant*)node;
#665        switch (value->discrim) {
#667     ncbytescat(buf,value->text);
#670            snprintf(tmp,sizeof(tmp),"%lld",value->intvalue);
#674            snprintf(tmp,sizeof(tmp),"%g",value->floatvalue);
#682 DCEvaluevalue = (DCEvalue*)node;
#683        switch (value->discrim) {
#685         dcetobuffer((DCEnode*)value->constant,buf);
#688         dcetobuffer((DCEnode*)value->var,buf);
#691         dcetobuffer((DCEnode*)value->fcn,buf);
#797 DCEvaluevalue = (DCEvalue*)node;
#798 if(value->discrim == CES_VAR)
#799     ceallnodesr((DCEnode*)value->var,allnodes,which);
#800 else if(value->discrim == CES_FCN)
#801     ceallnodesr((DCEnode*)value->fcn,allnodes,which);
#803     ceallnodesr((DCEnode*)value->constant,allnodes,which);
#1106 DCEconstantvalue = (DCEconstant*)node;
#1108 ncbytescat(buf,dcesortname(value->discrim));
#1110        switch (value->discrim) {
#1113     ncbytescat(buf,value->text);
#1117            snprintf(tmp,sizeof(tmp),"%lld",value->intvalue);
#1121            snprintf(tmp,sizeof(tmp),"%g",value->floatvalue);
#1129 DCEvaluevalue = (DCEvalue*)node;
#1131 ncbytescat(buf,dcesortname(value->discrim));
#1132        switch (value->discrim) {
#1134         dcedumpraw((DCEnode*)value->constant,buf);
#1137         dcedumpraw((DCEnode*)value->var,buf);
#1140         dcedumpraw((DCEnode*)value->fcn,buf);
dceparse.c#256value(DCEparsestatestateObject val)
dceparselex.h#78extern Object value(DCEparsestatestateObject value);
dcetab.c#1428    {(yyval)=value(parsestate,(yyvsp[0]));}
#1434    {(yyval)=value(parsestate,(yyvsp[0]));}
#1440    {(yyval)=value(parsestate,(yyvsp[0]));}
denum.c#72        const void *value)
#78       value);
#141    void *value)
#146    return ncp->dispatch->inq_enum_member(ncidxtypeidxnamevalue);
#168nc_inq_enum_ident(int ncidnc_type xtype, long long value,
#174    return ncp->dispatch->inq_enum_ident(ncid,xtype,value,identifier);
dim.c#100 NC_dim **loc = ncap->value;
#139      loc = (NC_dim **) ncap->value;
#149   *dimpp = ncap->value[dimid];
#172 assert(ncap->value != NULL);
#175 NC_dim **dpp = ncap->value;
#203 assert(ncap->value != NULL);
#207 free(ncap->value);
#208 ncap->value = NULL;
#224 ncap->value = (NC_dim **) malloc(sz);
#225 if(ncap->value == NULL)
#227 (void) memset(ncap->value, 0, sz);
#233 NC_dim **dpp = ncap->value;
#234 const NC_dim **drpp = (const NC_dim **)ref->value;
#277 ncap->value = vp;
#283 vp = (NC_dim **) realloc(ncap->value,
#287 ncap->value = vp;
#294 ncap->value[ncap->nelems] = newelemp;
#309 assert(ncap->value != NULL);
#311 return ncap->value[elem];
dinternal.c#40NCDISPATCH_get_att(int ncid, int varid, const char* name, void* valuenc_type t)
#45   return ncp->dispatch->get_att(ncid,varid,name,value,t);
dump.c#63     bufdump(dp->value.compoundv,buf);
#68     bufdump(dp->value.compoundv,buf);
#73     bufdump(dp->value.compoundv,buf);
#98 escapifychar(ci->value.charv,tmp,'\'');
#103 sprintf(tmp,"%hhd",ci->value.int8v);
#107 sprintf(tmp,"%hd",ci->value.int16v);
#111 sprintf(tmp,"%d",ci->value.int32v);
#115 sprintf(tmp,"%g",ci->value.floatv);
#119 sprintf(tmp,"%lg",ci->value.doublev);
#123 sprintf(tmp,"%hhu",ci->value.int8v);
#127 sprintf(tmp,"%hu",ci->value.uint16v);
#131 sprintf(tmp,"%u",ci->value.uint32v);
#135 sprintf(tmp,"%lld",ci->value.int64v);
#139 sprintf(tmp,"%llu",ci->value.uint64v);
#143 sprintf(tmp,"%s",ci->value.enumv->fqn);
#148 bbCat(buf,ci->value.stringv.stringv);
#153 bbCat(buf,ci->value.opaquev.stringv);
#193 Datalistdl = con->value.compoundv;
#201 if(con->value.stringv.len > 0 && con->value.stringv.stringv != NULL)
#202     fprintf(stderr,"\"%s\"",con->value.stringv.stringv);
#207 if(con->value.opaquev.len > 0 && con->value.opaquev.stringv != NULL)
#208     fprintf(stderr,"0x%s",con->value.opaquev.stringv);
#213 fprintf(stderr,"%s",(con->value.enumv==NULL?"?":con->value.enumv->name));
#219 fprintf(stderr,"'%c'",con->value.charv);
#222 fprintf(stderr,"%hhd",con->value.int8v);
#225 fprintf(stderr,"%hhu",con->value.uint8v);
#228 fprintf(stderr,"%hd",con->value.int16v);
#231 fprintf(stderr,"%hu",con->value.uint16v);
#234 fprintf(stderr,"%d",con->value.int32v);
#237 fprintf(stderr,"%u",con->value.uint32v);
#240 fprintf(stderr,"%lld",con->value.int64v);
#243 fprintf(stderr,"%llu",con->value.uint64v);
#246 fprintf(stderr,"%g",con->value.floatv);
#249 fprintf(stderr,"%g",con->value.doublev);
dv2i.c#682    const void* value
#689 const int status = nc_put_var1(ncidvaridcoordpvalue);
#706    void* value
#713 const int status = nc_get_var1(ncidvaridcoordpvalue);
#731    const void* value
#740 const int status = nc_put_vara(ncidvaridstpcntpvalue);
#759    void* value
#768 const int status = nc_get_vara(ncidvaridstpcntpvalue);
#788    const void* value
#792 return ncvarput(ncidvaridstartcountvalue);
#804 const int status = nc_put_vars(ncidvaridstpcntpstrdpvalue);
#826    void* value
#830 return ncvarget(ncidvaridstartcountvalue);
#841 const int status = nc_get_vars(ncidvaridstpcntpstrdpvalue);
#864    const void* value
#869 return ncvarputs(ncidvaridstartcountstridevalue);
#896  stpcntpstrdpimpvalue);
#921    void* value
#926 return ncvargets(ncidvaridstartcountstridevalue);
#953 stpcntpstrdpimpvalue);
#994    const void* value
#997 const int status = nc_put_att(ncidvaridnamedatatypelenvalue);
#1039    void* value
#1042 const int status = nc_get_att(ncidvaridnamevalue);
dvarget.c#83            void *valuenc_type memtype)
#99      stat = ncp->dispatch->get_vara(ncid,varid,start,shape,value,memtype);
#101      stat =  ncp->dispatch->get_vara(ncid,varid,start,edges,value,memtype);
#109NC_get_var(int ncid, int varid, void *valuenc_type memtype)
#117   return NC_get_vara(ncidvaridNC_coord_zeroshapevaluememtype);
#146   char* value = (char*)value0;
#198      return NC_get_vara(ncidvaridstartedge1valuememtype);
#231      return NC_get_vara(ncidvaridmystartmyedgesvaluememtype);
#235   memptr = value;
#262NC_get_var1(int ncid, int varid, const size_t *coord, void* value,
#265   return NC_get_vara(ncidvaridcoordNC_coord_onevaluememtype);
#281   char* value = (char*)value0;
#320      return NC_get_vara(ncidvaridstartedge1valuememtype);
#363      return NC_get_vara(ncidvaridstartedgesvaluememtype);
#479    valuememtype);
#492  value += (((int)mymap[idim]) * memtypelen);
#497     value -= l;
#515     const size_t *edges, const ptrdiff_t *stride, void *value,
#525   return ncp->dispatch->get_vars(ncid,varid,start,edges,stride,value,memtype);
#535     void *valuenc_type memtype)
#544   return ncp->dispatch->get_varm(ncid,varid,start,edges,stride,map,value,memtype);
dvarput.c#65     const size_t *edges, const void *valuenc_type memtype)
#77      return ncp->dispatch->put_vara(ncidvaridstartshapevaluememtype);
#79      return ncp->dispatch->put_vara(ncidvaridstartedgesvaluememtype);
#86NC_put_var(int ncid, int varid, const void *valuenc_type memtype)
#94   return NC_put_vara(ncidvaridNC_coord_zeroshapevaluememtype);
#101NC_put_var1(int ncid, int varid, const size_t *coord, const void* value,
#104   return NC_put_vara(ncidvaridcoordNC_coord_onevaluememtype);
#132   const char* value = (const char*)value0;
#140   const char* memptr = value;
#237      return NC_put_vara(ncidvaridmystartmyedgesvaluememtype);
#287   const char* value = (char*)value0;
#328      return NC_put_vara(ncidvaridstartedge1valuememtype);
#369  return NC_put_vara(ncidvaridstartedgesvaluememtype);
#459    valuememtype);
#473  value += (mymap[idim] * memtypelen);
#478     value -= l;
#497     const void *valuenc_type memtype)
#506   return ncp->dispatch->put_vars(ncid,varid,start,edges,stride,value,memtype);
#515     const void *valuenc_type memtype)
#524   return ncp->dispatch->put_varm(ncid,varid,start,edges,stride,map,value,memtype);
f77data.c#38 if(ci->value.charv == '\'')
#41     sprintf(tmp,"'%c'",ci->value.charv);
#44 sprintf(tmp,"%hhd",ci->value.int8v);
#47 sprintf(tmp,"%hd",ci->value.int16v);
#50 sprintf(tmp,"%d",ci->value.int32v);
#53 sprintf(tmp,"%.8g",ci->value.floatv);
#58 sprintf(tmp,"%.16g",ci->value.doublev);
#64     bbAppendn(buf,ci->value.stringv.stringv,ci->value.stringv.len);
genchar.c#161        bbAppend(databuf,con->value.charv);
#164        bbAppend(databuf,con->value.int8v);
#167        bbAppend(databuf,con->value.uint8v);
#170        constsize = con->value.stringv.len;
#171        bbAppendn(databuf,con->value.stringv.stringv,
#172                         con->value.stringv.len);
#192            fillchar = ccon->value.charv;
#194            if(ccon->value.stringv.len > 0) {
#195                fillchar = ccon->value.stringv.stringv[0];
#266     accum[len] = con->value.charv;
#345    con->value.stringv.len = len;
#347    con->value.stringv.stringv = (char*)malloc(len+1);
#348    memcpy((void*)con->value.stringv.stringv,(void*)str,len);
#349    con->value.stringv.stringv[len] = '\0';
generate.c#330        data = con->value.compoundv;
#364        data = con->value.compoundv;
#412        data = con->value.compoundv;
#446    if(prim->value.opaquev.len == nnibs) {
#448    } else if(prim->value.opaquev.len > nnibs) { /* truncate*/
#449        prim->value.opaquev.stringv[nnibs] = '\0';
#450        prim->value.opaquev.len = nnibs;
#455        memcpy(s,prim->value.opaquev.stringv,prim->value.opaquev.len);
#457        efree(prim->value.opaquev.stringv);
#458        prim->value.opaquev.stringv=s;
#459        prim->value.opaquev.len = nnibs;
#510            Symbolec = prim->value.enumv;
getfill.c#152nc_getfill(NCConstantvalue)
#154    switch(value->nctype) {
#155      case NC_CHARvalue->value.charv = NC_FILL_CHAR; break;
#156      case NC_BYTEvalue->value.int8v = NC_FILL_BYTE; break;
#157      case NC_SHORTvalue->value.int16v = NC_FILL_SHORT; break;
#158      case NC_INTvalue->value.int32v = NC_FILL_INT; break;
#159      case NC_FLOATvalue->value.floatv = NC_FILL_FLOAT; break;
#160      case NC_DOUBLEvalue->value.doublev = NC_FILL_DOUBLE; break;
#161      case NC_UBYTEvalue->value.uint8v = NC_FILL_UBYTE; break;
#162      case NC_USHORTvalue->value.uint16v = NC_FILL_USHORT; break;
#163      case NC_UINTvalue->value.uint32v = NC_FILL_UINT; break;
#164      case NC_INT64value->value.int64v = NC_FILL_INT64; break;
#165      case NC_UINT64value->value.uint64v = NC_FILL_UINT64; break;
#167        value->value.stringv.stringv = nulldup(NC_FILL_STRING);
#168        value->value.stringv.len = (int)strlen(NC_FILL_STRING);
#170 if(value->value.stringv.len == 0)
#171     value->value.stringv.len = 1;
#174        value->value.opaquev.len = 2;
#175        value->value.opaquev.stringv = nulldup("00");
#178 derror("nc_getfill: unrecognized type: %d",value->nctype);
getvara.c#771    char value[16];
#791 char* mem = (requireconversion?value:memory->next);
#792 ASSERT(externtypesize <= sizeof(value));
#798            ncstat = dapconvert(xnode->etype,xgetvar->dsttype,memory->next,value,1);
#850         char value[16]; /* Big enough to hold any numeric value */
#851         ocstat = oc_data_readn(conn,currentcontent,odom->index,1,interntypesize,value);
#853         ncstat = dapconvert(xnode->etype,xgetvar->dsttype,memory->next,value,1);
#868         char value[16]; /* Big enough to hold any numeric value */
#869         ocstat = oc_data_readn(conn,currentcontent,odom->index,1,interntypesize,value);
#871         ncstat = dapconvert(xnode->etype,xgetvar->dsttype,memory->next,value,1);
#960 char* value = NULL;
#961 ocstat = oc_data_readscalar(conn,currentcontent,sizeof(value),&value);
#963 nclistpush(strings,(void*)value);
#968     char* value = NULL;
#969     ocstat = oc_data_readn(conn,currentcontent,odom->index,1,sizeof(value),&value);
#972     nclistpush(strings,(void*)value);
jdata.c#38 if(con->value.charv == '\'')
#41     bbprintf(codetmp,"'%c'",con->value.charv);
#44 bbprintf(codetmp,"%hhd",con->value.int8v);
#47 bbprintf(codetmp,"%hd",con->value.int16v);
#50 bbprintf(codetmp,"%d",con->value.int32v);
#54 if(isnan(con->value.floatv))
#57     bbprintf(codetmp,"%f",con->value.floatv);
#61 if(isnan(con->value.doublev))
#64     bbprintf(codetmp,"%lf",con->value.doublev);
#67        bbprintf(codetmp,"%hhu",con->value.uint8v);
#70 bbprintf(codetmp,"%hu",con->value.uint16v);
#73 bbprintf(codetmp,"%uU",con->value.uint32v);
#76 bbprintf(codetmp,"%lldLL",con->value.int64v);
#79 bbprintf(codetmp,"%lluLLU",con->value.uint64v);
#82 char* escaped = escapify(con->value.stringv.stringv,
#83  '"',con->value.stringv.len);
nc3dispatch.c#438NC3_inq_enum_ident(int ncidnc_type xtype, long long value, char *identifier)
#445    void *value)
#452        const void *value)
nc3dispatch.h#146NC3_get_att(int ncid, int varid, const char *name, void *valuenc_type);
#150    size_t len, const void *valuenc_type);
#173             const void *valuenc_type);
#178             void *valuenc_type);
nc3internal.c#199 vpp = ncp->vars.value;
#221            if (!IS_RECVAR(ncp->old->vars.value[j]))
#226            if ((*vpp)->begin < ncp->old->vars.value[j]->begin) {
#230              (*vpp)->begin = ncp->old->vars.value[j]->begin;
#270 vpp = (NC_var **)ncp->vars.value;
#291                        if (IS_RECVAR(ncp->old->vars.value[j]))
#294                        if ((*vpp)->begin < ncp->old->vars.value[j]->begin)
#296                            (*vpp)->begin = ncp->old->vars.value[j]->begin;
#490 varpp = ncp->vars.value;
#513 NC_var ** const gnu_varpp = (NC_var **)gnu->vars.value;
#557 NC_var ** const gnu_varpp = (NC_var **)gnu->vars.value;
#590 NC_var **gnu_varpp = (NC_var **)gnu->vars.value;
#591 NC_var **old_varpp = (NC_var **)old->vars.value;
#646 NC_var **gnu_varpp = (NC_var **)gnu->vars.value;
#647 NC_var **old_varpp = (NC_var **)old->vars.value;
#713    vpp = ncp->vars.value;
#741 vpp = ncp->vars.value;
#891 NC_var **vpp = (NC_var **)ncp->vars.value;
nc3internal.h#92 NC_dim **value;
#139 NC_attr **value;
#197  NC_var **value;
nc4attr.c#952            size_t nelems, const void *valuenc_type memtype)
#954   return nc4_put_att_tc(ncidvaridnamextypememtype, 0, nelemsvalue);
#958NC4_get_att(int ncid, int varid, const char *name, void *valuenc_type memtype)
#960   return nc4_get_att_tc(ncidvaridnamememtype, 0, value);
nc4dispatch.h#117NC4_get_att(int ncid, int varid, const char *name, void *valuenc_type);
#121    size_t len, const void *valuenc_type);
#147             const void *valuenc_type);
#152             void *valuenc_type);
nc4file.c#1409            void *value;
#1441            if (!(value = calloc(1, type_size)))
#1464               if (H5Tget_member_value(hdf_typeidivalue) < 0)
#1472                                                 member_namevalue)))
#1488        if(value) free(value);
nc4hdf.c#1925        if (H5Tenum_insert(type->hdf_typeidenum_m->nameenum_m->value) < 0)
nc4info.c#68      char* value = NULL;
#73      value = p = q;
#77      if(value != NULL) {
#79          int v = atoi(value);
#83          strncpy(ncprops->netcdfver,value,sizeof(ncprops->netcdfver)-1);
#85          strncpy(ncprops->hdf5ver,value,sizeof(ncprops->hdf5ver)-1);
nc4internal.c#881     const char *name, const void *value)
#886   assert(name && size > 0 && value);
#892   if (!(member->value = malloc(size))) {
#897      free(member->value);
#903   memcpy(member->valuevaluesize);
#979                  free(enum_member->value);
nc4internal.h#211   void *value;
#404 const char *name, const void *value);
nc4type.c#565NC4_inq_enum_ident(int ncidnc_type xtype, long long value, char *identifier)
#574   LOG((3, "nc_inq_enum_ident: xtype %d value %d\n", xtypevalue));
#595     ll_val = *(char *)enum_member->value;
#598     ll_val = *(unsigned char *)enum_member->value;
#601     ll_val = *(short *)enum_member->value;
#604     ll_val = *(unsigned short *)enum_member->value;
#607     ll_val = *(int *)enum_member->value;
#610     ll_val = *(unsigned int *)enum_member->value;
#614     ll_val = *(long long *)enum_member->value;
#620      if (ll_val == value)
#641    void *value)
#675   if (value)
#676      memcpy(valueenum_member->valuetype->size);
#685        const void *value)
#693 typeid1identifiervalue));
#718      norm_namevalue)))
nc_hashmap.c#74      NC_dim *elem = ncap->value[table[size].data-1];
#99      NC_var *elem = ncap->value[table[size].data-1];
#149     strncmp(namencap->value[entry.data-1]->name->cp,
#150     ncap->value[entry.data-1]->name->nchars) == 0)
#196     strncmp(namencap->value[entry.data-1]->name->cp,
#197     ncap->value[entry.data-1]->name->nchars) == 0)
#237   strncmp(namencap->value[entry.data-1]->name->cp,
#238   ncap->value[entry.data-1]->name->nchars) == 0)
#274   strncmp(namencap->value[entry.data-1]->name->cp,
#275   ncap->value[entry.data-1]->name->nchars) == 0)
#312   strncmp(namencap->value[entry.data-1]->name->cp,
#313   ncap->value[entry.data-1]->name->nchars) == 0)
#346   strncmp(namencap->value[entry.data-1]->name->cp,
#347   ncap->value[entry.data-1]->name->nchars) == 0)
ncd2dispatch.c#82            void *value,
#91            void *valuenc_type memtype);
#259            const void *value,
#268            void *value,
#271    int stat = nc3d_getvarx(ncidvaridstartedgesnc_ptrdiffvector1value,memtype);
#286            void *valuenc_type memtype)
#288    int stat = nc3d_getvarx(ncidvaridstartedgesstridevaluememtype);
#302    const char* value;
#424    if((value = dapparamvalue(dapcomm,"log")) != NULL) {
#426        if(nclogopen(value))
#429        if(nclogopen(value))
#1215    const char* value;
#1224    value = oc_clientparam_get(conn,"cachelimit");
#1225    limit = getlimitnumber(value);
#1229    value = oc_clientparam_get(conn,"fetchlimit");
#1230    limit = getlimitnumber(value);
#1234    value = oc_clientparam_get(conn,"smallsizelimit");
#1235    limit = getlimitnumber(value);
#1246    value = oc_clientparam_get(conn,"cachecount");
#1247    limit = getlimitnumber(value);
#1255    value = oc_clientparam_get(conn,"limit");
#1256    if(value != NULL && strlen(value) != 0) {
#1257        if(sscanf(value,"%d",&len) && len > 0) dfaltseqlim = len;
#1262    value = oc_clientparam_get(conn,"stringlength");
#1263    if(value != NULL && strlen(value) != 0) {
#1264        if(sscanf(value,"%d",&len) && len > 0) dfaltstrlen = len;
#1277 value = oc_clientparam_get(conn,tmpname);
#1278        if(value != NULL && strlen(value) != 0) {
#1279            if(sscanf(value,"%d",&len) && len > 0) var->maxstringlength = len;
#1294 value = oc_clientparam_get(conn,tmpname);
#1295        if(value != NULL && strlen(value) != 0) {
#1296            if(sscanf(value,"%d",&len) && len > 0)
#1303    value = oc_clientparam_get(conn,"fetch");
#1304    if(value != NULL && strlen(value) > 0) {
#1305 if(value[0] == 'd' || value[0] == 'D') {
#1311    value = oc_clientparam_get(conn,"wholevar");
#1312    if(value != NULL) {
#2226    size_t len, const void* valuenc_type t)
#2374NCD2_get_att(int ncid, int varid, const char* name, void* valuenc_type t)
#2379    ret = NCDISPATCH_get_att(getnc3id(drno), varidnamevaluet);
ncd2dispatch.h#119NCD2_get_att(int ncid, int varid, const char *name, void *valuenc_type);
#123    size_t len, const void *valuenc_type);
ncdispatch.h#406NCDISPATCH_get_att(int ncid, int varid, const char* name, void* valuenc_type t);
ncdump.c#882    int64_t value;
#888    value = *((char *)data + i);
#891    value = *((unsigned char *)data + i);
#894    value = *((short *)data + i);
#897    value = *((unsigned short *)data + i);
#900    value = *((int *)data + i);
#903    value = *((unsigned int *)data + i);
#906    value = *((int64_t *)data + i);
#909    value = *((uint64_t *)data + i);
#914        NC_CHECKnc_inq_enum_ident(ncidatt.typevalue,
ncgeny.c#3089 case NC_CHARcon.value.charv = char_val; break;
#3090        case NC_BYTEcon.value.int8v = byte_val; break;
#3091        case NC_SHORTcon.value.int16v = int16_val; break;
#3092        case NC_INTcon.value.int32v = int32_val; break;
#3094     con.value.floatv = float_val;
#3097     con.value.doublev = double_val;
#3102     con.value.stringv.len = len;
#3103     con.value.stringv.stringv = bbDup(lextext);
#3109        case NC_UBYTEcon.value.uint8v = ubyte_val; break;
#3110        case NC_USHORTcon.value.uint16v = uint16_val; break;
#3111        case NC_UINTcon.value.uint32v = uint32_val; break;
#3112        case NC_INT64con.value.int64v = int64_val; break;
#3113        case NC_UINT64con.value.uint64v = uint64_val; break;
#3123     con.value.opaquev.stringv = s;
#3124     con.value.opaquev.len = len;
#3137     con.value.stringv.stringv = NULL;
#3138     con.value.stringv.len = 0;
#3155    con.value.enumv = refsym;
#3203 char* sdata = con->value.stringv.stringv;
#3211    } else if(con->value.int32v < 0 || con->value.int32v > 1)
#3213    return con->value.int32v;
#3275     sdata = iconst.value.stringv.stringv;
#3284     idata = iconst.value.int32v;
#3390                        special->_ChunkSizes[i] = (size_t)iconst.value.int32v;
#3442    case NC_BYTE: return (long long)(con.value.int8v);
#3443    case NC_SHORT: return (long long)(con.value.int16v);
#3444    case NC_INT: return (long long)(con.value.int32v);
#3445    case NC_UBYTE: return (long long)(con.value.uint8v);
#3446    case NC_USHORT: return (long long)(con.value.uint16v);
#3447    case NC_UINT: return (long long)(con.value.uint32v);
#3448    case NC_INT64: return (long long)(con.value.int64v);
#3464         if(containsfills(con->value.compoundv)) return 1;
#3526        result.value.doublev = 0;
#3547     timekind = arglist->data[0].value.stringv.stringv;
#3548            timevalue = arglist->data[1].value.stringv.stringv;
#3550            timevalue = arglist->data[0].value.stringv.stringv;
#3564     Cdh2e(&cdtime,&result.value.doublev);
nchashmap.c#61nchashinsert(NChashmaphmnchashid hash, void* value)
#77    nclistpush(seq,value);
#85nchashreplace(NChashmaphmnchashid hash, void* value)
#98 if(hash==(nchashid)(*list)) {list[1] = value; return TRUE;}
#101    nclistpush(seq,value);
#138    void* value;
#139    if(!nchashlookup(hm,hash,&value)) return NULL;
#140    return value;
nchashmap.h#34externC int nchashinsert(NChashmap*, nchashid nchash, void* value);
#38externC int nchashreplace(NChashmap*, nchashid nchash, void* value);
ncpdispatch.c#1418NCP_inq_enum_ident(int ncidnc_type xtype, long long value, char *identifier)
#1425    void *value)
#1432        const void *value)
nctime.c#545cdFromHours(double valuecdUnitTime unit){
#550 result = value * 3600.0;
#553 result = value * 60.0;
#556 result = value;
#559 result = value/24.0;
#562 result = value/168.0;
#890cdCompAdd(cdCompTime comptime, double valuecdCalenType calendarcdCompTime *result){
#895 reltime += value;
#903cdCompAddMixed(cdCompTime ct, double valuecdCompTime *result){
#911 if (value <= xj){
#912 cdCompAdd(ctvaluecdJulianresult);
#915 cdCompAdd(ZBvalue-xjcdStandardresult);
#920 if (value > xg){
#921 cdCompAdd(ctvaluecdStandardresult);
#924 cdCompAdd(ZAvalue-xgcdJulianresult);
#932cdToHours(double valuecdUnitTime unit){
#938 result = value/3600.0;
#941 result = value/60.0;
#944 result = value;
#947 result = 24.0 * value;
#950 result = 168.0 * value;
ncuri.c#654  char* value = NULL;
#666    value = uri->paramlist[(2*i)+1];
#667    if(resultp) *resultp = value;
netcdf.h#738        const void *value);
#750    void *value);
#755nc_inq_enum_ident(int ncidnc_type xtype, long long value, char *identifier);
oc.c#1683oc_typeprint(OCtype etype, void* value, size_t bufsize, char* buffer)
#1685    return OCTHROW(octypeprint(etype,value,bufsize,buffer));
#1759oc_clientparam_insert(OCobject link, const char* param, const char* value)
#1765    state->clientparams = dapparaminsert(state->clientparams,param,value);
#1775oc_clientparam_replace(OCobject link, const char* param, const char* value)
#1781    return dapparamreplace(state->clientparams,param,value);
#2051oc_set_curlopt(OClink link, const char* option, void* value)
#2061    return OCTHROW(ocset_curlopt(state,f->flag,value));
oc.h#489extern OCerror oc_typeprint(OCtype, void* value, size_t bufsize, char* buf);
#564extern OCerror oc_set_curlopt(OClink link, const char* option, void* value);
occlientparams.c#40    const char* value = NULL;
#42    if(!ocurilookup(state->uri,key,&value))
#43 value = NULL;
#44    return value;
#96ocparaminsert(OClistparams, const char* clientparam, const char* value)
#106    oclistpush(params,(ocelem)nulldup(value));
#117ocparamreplace(OClistparams, const char* clientparam, const char* value)
#124     oclistinsert(params,i+1,(ocelem)nulldup(value));
#128    ocparaminsert(params,clientparam,value);
occonstraints.h#33    char* value;
occurlfunctions.c#22#define CHECK(state,flag,value) {if(check(state,flag,(void*)value) != OC_NOERR) {goto done;}}
#26static void* cvt(char* value, enum OCCURLFLAGTYPE type);
#29check(OCstatestate, int flag, void* value)
#31    OCerror stat = ocset_curlopt(state,flag,value);
#33    long l = (long)value;
#39 char* s = (char*)value;
#50showopt(int flag, void* value)
#57     OCDBG2("%s=%ld",f->name,(long)value);
#61     char* s = (char*)value;
#77ocset_curlopt(OCstatestate, int flag, void* value)
#81    cstat = OCCURLERR(state,curl_easy_setopt(state->curl,flag,value));
#272        stat = ocset_curlopt(state,ocflag->flag,cvt(triple->value,ocflag->type));
#280cvt(char* value, enum OCCURLFLAGTYPE type)
#285 const char* p = value;
#293 return (void*)value;
#295 return (void*)value;
#349ocset_curlstate(OCstatestate, int flag, void* value)
#357 state->creds.userpwd = strdup((char*)value);
#362 state->curlflags.cookiejar = strdup((char*)value);
#367 state->curlflags.netrc = strdup((char*)value);
#371 state->curlflags.verbose = (long)value;
#375 state->curlflags.timeout = (long)value;
#380        state->curlflags.useragent = strdup((char*)value);
#405 if(!ocparseproxy(state,(char*)value))
#411 state->ssl.certificate = strdup((char*)value);
#415 state->ssl.key = strdup((char*)value);
#419 state->ssl.keypasswd = strdup((char*)value);
#422      state->ssl.verifypeer = (long)value;
#425      state->ssl.verifyhost = (long)value;
#429      state->ssl.cainfo = strdup((char*)value);
#433 state->ssl.capath = strdup((char*)value);
occurlfunctions.h#12extern OCerror ocset_curlopt(OCstatestate, int flag, void* value);
#21extern OCerror ocset_curlstate(OCstatestate, int flag, void* value);
ocdump.c#145     char* value = (char*)oclistget(node->att.values,n);
#147     fprintf(stdout," %s",value);
ocinternal.h#145    int value;
#154        char value[MAXRCLINESIZE];
ocnode.c#198     char* value = (char*)oclistpop(node->att.values);
#199     ocfree(value);
#654 char* value = strings[i];
#655        converttype(etype,value,memp);
#662converttype(OCtype etype, char* value, char* memory)
#676 if(sscanf(value,"%c",c) != 1) goto fail;
#680 if(sscanf(value,"%ld",&iv) != 1) goto fail;
#685 if(sscanf(value,"%lu",&uiv) != 1) goto fail;
#690 if(sscanf(value,"%ld",&iv) != 1) goto fail;
#695 if(sscanf(value,"%lu",&uiv) != 1) goto fail;
#700 if(sscanf(value,"%ld",&iv) != 1) goto fail;
#705 if(sscanf(value,"%lu",&uiv) != 1) goto fail;
#711 if(sscanf(value,"%lld",&llv) != 1) goto fail;
#716 if(sscanf(value,"%llu",&ullv) != 1) goto fail;
#721 if(sscanf(value,"%lf",&dv) != 1) goto fail;
#725 if(sscanf(value,"%lf",&dv) != 1) goto fail;
#729 *((char**)memory) = nulldup(value);
#735        oc_log(LOGWARN,"converttype range failure: %d: %s",etype,value);
#738    oc_log(LOGERR,"converttype bad value: %d: %s",etype,value);
ocrc.c#288        char *line,*key,*value;
#309        ocrc->triples[ocrc->ntriples].value[0] = '\0';
#334        value = strchr(line, '=');
#335        if(value == NULL)
#336            value = line + strlen(line);
#338            *value = '\0';
#339            value++;
#342        if(*value == '\0')
#343            strcpy(ocrc->triples[ocrc->ntriples].value,"1");/*dfalt*/
#345          strncpy(ocrc->triples[ocrc->ntriples].value,value,(MAXRCLINESIZE-1));
#347        rctrimocrc->triples[ocrc->ntriples].value);
#350 ocrc->triples[ocrc->ntriples].value);
#415    char* value = NULL;
#434    value = ocrc_lookup("HTTP.DEFLATE",url_hostport);
#435    if(value != NULL) {
#436        if(atoi(value)) state->curlflags.compress = 1;
#440    if((value = ocrc_lookup("HTTP.VERBOSE",url_hostport)) != NULL) {
#441        if(atoi(value)) state->curlflags.verbose = 1;
#445    if((value = ocrc_lookup("HTTP.TIMEOUT",url_hostport)) != NULL) {
#446        if(atoi(value)) state->curlflags.timeout = atoi(value);
#450    if((value = ocrc_lookup("HTTP.USERAGENT",url_hostport)) != NULL) {
#451        if(atoi(value)) state->curlflags.useragent = strdup(value);
#458          (value = ocrc_lookup("HTTP.COOKIEFILE",url_hostport))
#459       || (value = ocrc_lookup("HTTP.COOKIE_FILE",url_hostport))
#460       || (value = ocrc_lookup("HTTP.COOKIEJAR",url_hostport))
#461       || (value = ocrc_lookup("HTTP.COOKIE_JAR",url_hostport))
#463        state->curlflags.cookiejar = strdup(value);
#469    if((value = ocrc_lookup("HTTP.PROXY_SERVER",url_hostport)) != NULL) {
#470        stat = ocparseproxy(state,value);
#473            oclog(OCLOGNOTE,"HTTP.PROXY_SERVER: %s", value);
#476    if((value = ocrc_lookup("HTTP.SSL.VALIDATE",url_hostport)) != NULL) {
#477        if(atoi(value)) {
#485    if((value = ocrc_lookup("HTTP.SSL.CERTIFICATE",url_hostport)) != NULL) {
#486        state->ssl.certificate = strdup(value);
#492    if((value = ocrc_lookup("HTTP.SSL.KEY",url_hostport)) != NULL) {
#493        state->ssl.key = strdup(value);
#499    if((value = ocrc_lookup("HTTP.SSL.KEYPASSWORD",url_hostport)) != NULL) {
#500        state->ssl.keypasswd = strdup(value);
#506    if((value = ocrc_lookup("HTTP.SSL.CAINFO",url_hostport)) != NULL) {
#507        state->ssl.cainfo = strdup(value);
#513    if((value = ocrc_lookup("HTTP.SSL.CAPATH",url_hostport)) != NULL) {
#514        state->ssl.capath = strdup(value);
#520    if((value = ocrc_lookup("HTTP.SSL.VERIFYPEER",url_hostport)) != NULL) {
#521        char* s = strdup(value);
#535    if((value = ocrc_lookup("HTTP.NETRC",url_hostport)) != NULL) {
#538        state->curlflags.netrc = strdup(value);
#604 fprintf(stderr,"lookup %s: [%s]%s = %s\n",hostport,triple->host,triple->key,triple->value);
#606    return (triple == NULL ? NULL : triple->value);
#627                triples[i].value);
#639    char* value = NULL;
#645 value = ocrc_lookup(key,url);
#646 if(value != NULL)
#647     return value;
#649    return value;
ocuri.c#645    char* value = NULL;
#654    value = uri->paramlist[(2*i)+1];
#655    if(resultp) *resultp = value;
ocutil.c#257octypeprint(OCtype etype, void* value, size_t bufsize, char* buf)
#259    if(buf == NULL || bufsize == 0 || value == NULL) return OC_EINVAL;
#263 snprintf(buf,bufsize,"'%c'",*(char*)value);
#266 snprintf(buf,bufsize,"%d",*(signed char*)value);
#269 snprintf(buf,bufsize,"%u",*(unsigned char*)value);
#272 snprintf(buf,bufsize,"%d",*(short*)value);
#275 snprintf(buf,bufsize,"%u",*(unsigned short*)value);
#278 snprintf(buf,bufsize,"%d",*(int*)value);
#281 snprintf(buf,bufsize,"%u",*(unsigned int*)value);
#284 snprintf(buf,bufsize,"%g",*(float*)value);
#287 snprintf(buf,bufsize,"%g",*(double*)value);
#291 snprintf(buf,bufsize,"%lld",*(long long*)value);
#294 snprintf(buf,bufsize,"%llu",*(unsigned long long*)value);
#299 char* s = *(char**)value;
ocutil.h#23extern OCerror octypeprint(OCtype etype, void* value, size_t bufsize, char* buf);
putget.c#32        const size_t nelems, void* value, const nc_type memtype);
#35         const size_t nelems, const void* value, const nc_type memtype);
#638 (const NC_var *const*)ncp->vars.value,
#658     NC_var **vpp = (NC_var **)ncp->vars.value;
#677 (const NC_var *const*)ncp->vars.value,
#862  const size_t *start, size_t nelems, const char *value)
#872 assert(value != NULL);
#884 lstatus = ncx_putn_char_char(&xpnputvalue);
#898 value += nput;
#908  const size_t *start, size_t nelems, const schar *value)
#918 assert(value != NULL);
#930 lstatus = ncx_putn_schar_schar(&xpnputvalue);
#944 value += nput;
#953  const size_t *start, size_t nelems, const uchar *value)
#963 assert(value != NULL);
#975 lstatus = ncx_putn_schar_uchar(&xpnputvalue);
#989 value += nput;
#998  const size_t *start, size_t nelems, const short *value)
#1008 assert(value != NULL);
#1020 lstatus = ncx_putn_schar_short(&xpnputvalue);
#1034 value += nput;
#1043  const size_t *start, size_t nelems, const int *value)
#1053 assert(value != NULL);
#1065 lstatus = ncx_putn_schar_int(&xpnputvalue);
#1079 value += nput;
#1088  const size_t *start, size_t nelems, const float *value)
#1098 assert(value != NULL);
#1110 lstatus = ncx_putn_schar_float(&xpnputvalue);
#1124 value += nput;
#1133  const size_t *start, size_t nelems, const double *value)
#1143 assert(value != NULL);
#1155 lstatus = ncx_putn_schar_double(&xpnputvalue);
#1169 value += nput;
#1178  const size_t *start, size_t nelems, const longlong *value)
#1188 assert(value != NULL);
#1200 lstatus = ncx_putn_schar_longlong(&xpnputvalue);
#1214 value += nput;
#1223  const size_t *start, size_t nelems, const ushort *value)
#1233 assert(value != NULL);
#1245 lstatus = ncx_putn_schar_ushort(&xpnputvalue);
#1259 value += nput;
#1268  const size_t *start, size_t nelems, const uint *value)
#1278 assert(value != NULL);
#1290 lstatus = ncx_putn_schar_uint(&xpnputvalue);
#1304 value += nput;
#1313  const size_t *start, size_t nelems, const ulonglong *value)
#1323 assert(value != NULL);
#1335 lstatus = ncx_putn_schar_ulonglong(&xpnputvalue);
#1349 value += nput;
#1359  const size_t *start, size_t nelems, const schar *value)
#1369 assert(value != NULL);
#1381 lstatus = ncx_putn_short_schar(&xpnputvalue);
#1395 value += nput;
#1404  const size_t *start, size_t nelems, const uchar *value)
#1414 assert(value != NULL);
#1426 lstatus = ncx_putn_short_uchar(&xpnputvalue);
#1440 value += nput;
#1449  const size_t *start, size_t nelems, const short *value)
#1459 assert(value != NULL);
#1471 lstatus = ncx_putn_short_short(&xpnputvalue);
#1485 value += nput;
#1494  const size_t *start, size_t nelems, const int *value)
#1504 assert(value != NULL);
#1516 lstatus = ncx_putn_short_int(&xpnputvalue);
#1530 value += nput;
#1539  const size_t *start, size_t nelems, const float *value)
#1549 assert(value != NULL);
#1561 lstatus = ncx_putn_short_float(&xpnputvalue);
#1575 value += nput;
#1584  const size_t *start, size_t nelems, const double *value)
#1594 assert(value != NULL);
#1606 lstatus = ncx_putn_short_double(&xpnputvalue);
#1620 value += nput;
#1629  const size_t *start, size_t nelems, const longlong *value)
#1639 assert(value != NULL);
#1651 lstatus = ncx_putn_short_longlong(&xpnputvalue);
#1665 value += nput;
#1674  const size_t *start, size_t nelems, const ushort *value)
#1684 assert(value != NULL);
#1696 lstatus = ncx_putn_short_ushort(&xpnputvalue);
#1710 value += nput;
#1719  const size_t *start, size_t nelems, const uint *value)
#1729 assert(value != NULL);
#1741 lstatus = ncx_putn_short_uint(&xpnputvalue);
#1755 value += nput;
#1764  const size_t *start, size_t nelems, const ulonglong *value)
#1774 assert(value != NULL);
#1786 lstatus = ncx_putn_short_ulonglong(&xpnputvalue);
#1800 value += nput;
#1810  const size_t *start, size_t nelems, const schar *value)
#1820 assert(value != NULL);
#1832 lstatus = ncx_putn_int_schar(&xpnputvalue);
#1846 value += nput;
#1855  const size_t *start, size_t nelems, const uchar *value)
#1865 assert(value != NULL);
#1877 lstatus = ncx_putn_int_uchar(&xpnputvalue);
#1891 value += nput;
#1900  const size_t *start, size_t nelems, const short *value)
#1910 assert(value != NULL);
#1922 lstatus = ncx_putn_int_short(&xpnputvalue);
#1936 value += nput;
#1945  const size_t *start, size_t nelems, const int *value)
#1955 assert(value != NULL);
#1967 lstatus = ncx_putn_int_int(&xpnputvalue);
#1981 value += nput;
#1990  const size_t *start, size_t nelems, const float *value)
#2000 assert(value != NULL);
#2012 lstatus = ncx_putn_int_float(&xpnputvalue);
#2026 value += nput;
#2035  const size_t *start, size_t nelems, const double *value)
#2045 assert(value != NULL);
#2057 lstatus = ncx_putn_int_double(&xpnputvalue);
#2071 value += nput;
#2080  const size_t *start, size_t nelems, const longlong *value)
#2090 assert(value != NULL);
#2102 lstatus = ncx_putn_int_longlong(&xpnputvalue);
#2116 value += nput;
#2125  const size_t *start, size_t nelems, const ushort *value)
#2135 assert(value != NULL);
#2147 lstatus = ncx_putn_int_ushort(&xpnputvalue);
#2161 value += nput;
#2170  const size_t *start, size_t nelems, const uint *value)
#2180 assert(value != NULL);
#2192 lstatus = ncx_putn_int_uint(&xpnputvalue);
#2206 value += nput;
#2215  const size_t *start, size_t nelems, const ulonglong *value)
#2225 assert(value != NULL);
#2237 lstatus = ncx_putn_int_ulonglong(&xpnputvalue);
#2251 value += nput;
#2261  const size_t *start, size_t nelems, const schar *value)
#2271 assert(value != NULL);
#2283 lstatus = ncx_putn_float_schar(&xpnputvalue);
#2297 value += nput;
#2306  const size_t *start, size_t nelems, const uchar *value)
#2316 assert(value != NULL);
#2328 lstatus = ncx_putn_float_uchar(&xpnputvalue);
#2342 value += nput;
#2351  const size_t *start, size_t nelems, const short *value)
#2361 assert(value != NULL);
#2373 lstatus = ncx_putn_float_short(&xpnputvalue);
#2387 value += nput;
#2396  const size_t *start, size_t nelems, const int *value)
#2406 assert(value != NULL);
#2418 lstatus = ncx_putn_float_int(&xpnputvalue);
#2432 value += nput;
#2441  const size_t *start, size_t nelems, const float *value)
#2451 assert(value != NULL);
#2463 lstatus = ncx_putn_float_float(&xpnputvalue);
#2477 value += nput;
#2486  const size_t *start, size_t nelems, const double *value)
#2496 assert(value != NULL);
#2508 lstatus = ncx_putn_float_double(&xpnputvalue);
#2522 value += nput;
#2531  const size_t *start, size_t nelems, const longlong *value)
#2541 assert(value != NULL);
#2553 lstatus = ncx_putn_float_longlong(&xpnputvalue);
#2567 value += nput;
#2576  const size_t *start, size_t nelems, const ushort *value)
#2586 assert(value != NULL);
#2598 lstatus = ncx_putn_float_ushort(&xpnputvalue);
#2612 value += nput;
#2621  const size_t *start, size_t nelems, const uint *value)
#2631 assert(value != NULL);
#2643 lstatus = ncx_putn_float_uint(&xpnputvalue);
#2657 value += nput;
#2666  const size_t *start, size_t nelems, const ulonglong *value)
#2676 assert(value != NULL);
#2688 lstatus = ncx_putn_float_ulonglong(&xpnputvalue);
#2702 value += nput;
#2712  const size_t *start, size_t nelems, const schar *value)
#2722 assert(value != NULL);
#2734 lstatus = ncx_putn_double_schar(&xpnputvalue);
#2748 value += nput;
#2757  const size_t *start, size_t nelems, const uchar *value)
#2767 assert(value != NULL);
#2779 lstatus = ncx_putn_double_uchar(&xpnputvalue);
#2793 value += nput;
#2802  const size_t *start, size_t nelems, const short *value)
#2812 assert(value != NULL);
#2824 lstatus = ncx_putn_double_short(&xpnputvalue);
#2838 value += nput;
#2847  const size_t *start, size_t nelems, const int *value)
#2857 assert(value != NULL);
#2869 lstatus = ncx_putn_double_int(&xpnputvalue);
#2883 value += nput;
#2892  const size_t *start, size_t nelems, const float *value)
#2902 assert(value != NULL);
#2914 lstatus = ncx_putn_double_float(&xpnputvalue);
#2928 value += nput;
#2937  const size_t *start, size_t nelems, const double *value)
#2947 assert(value != NULL);
#2959 lstatus = ncx_putn_double_double(&xpnputvalue);
#2973 value += nput;
#2982  const size_t *start, size_t nelems, const longlong *value)
#2992 assert(value != NULL);
#3004 lstatus = ncx_putn_double_longlong(&xpnputvalue);
#3018 value += nput;
#3027  const size_t *start, size_t nelems, const ushort *value)
#3037 assert(value != NULL);
#3049 lstatus = ncx_putn_double_ushort(&xpnputvalue);
#3063 value += nput;
#3072  const size_t *start, size_t nelems, const uint *value)
#3082 assert(value != NULL);
#3094 lstatus = ncx_putn_double_uint(&xpnputvalue);
#3108 value += nput;
#3117  const size_t *start, size_t nelems, const ulonglong *value)
#3127 assert(value != NULL);
#3139 lstatus = ncx_putn_double_ulonglong(&xpnputvalue);
#3153 value += nput;
#3163  const size_t *start, size_t nelems, const schar *value)
#3173 assert(value != NULL);
#3185 lstatus = ncx_putn_uchar_schar(&xpnputvalue);
#3199 value += nput;
#3208  const size_t *start, size_t nelems, const uchar *value)
#3218 assert(value != NULL);
#3230 lstatus = ncx_putn_uchar_uchar(&xpnputvalue);
#3244 value += nput;
#3253  const size_t *start, size_t nelems, const short *value)
#3263 assert(value != NULL);
#3275 lstatus = ncx_putn_uchar_short(&xpnputvalue);
#3289 value += nput;
#3298  const size_t *start, size_t nelems, const int *value)
#3308 assert(value != NULL);
#3320 lstatus = ncx_putn_uchar_int(&xpnputvalue);
#3334 value += nput;
#3343  const size_t *start, size_t nelems, const float *value)
#3353 assert(value != NULL);
#3365 lstatus = ncx_putn_uchar_float(&xpnputvalue);
#3379 value += nput;
#3388  const size_t *start, size_t nelems, const double *value)
#3398 assert(value != NULL);
#3410 lstatus = ncx_putn_uchar_double(&xpnputvalue);
#3424 value += nput;
#3433  const size_t *start, size_t nelems, const longlong *value)
#3443 assert(value != NULL);
#3455 lstatus = ncx_putn_uchar_longlong(&xpnputvalue);
#3469 value += nput;
#3478  const size_t *start, size_t nelems, const ushort *value)
#3488 assert(value != NULL);
#3500 lstatus = ncx_putn_uchar_ushort(&xpnputvalue);
#3514 value += nput;
#3523  const size_t *start, size_t nelems, const uint *value)
#3533 assert(value != NULL);
#3545 lstatus = ncx_putn_uchar_uint(&xpnputvalue);
#3559 value += nput;
#3568  const size_t *start, size_t nelems, const ulonglong *value)
#3578 assert(value != NULL);
#3590 lstatus = ncx_putn_uchar_ulonglong(&xpnputvalue);
#3604 value += nput;
#3614  const size_t *start, size_t nelems, const schar *value)
#3624 assert(value != NULL);
#3636 lstatus = ncx_putn_ushort_schar(&xpnputvalue);
#3650 value += nput;
#3659  const size_t *start, size_t nelems, const uchar *value)
#3669 assert(value != NULL);
#3681 lstatus = ncx_putn_ushort_uchar(&xpnputvalue);
#3695 value += nput;
#3704  const size_t *start, size_t nelems, const short *value)
#3714 assert(value != NULL);
#3726 lstatus = ncx_putn_ushort_short(&xpnputvalue);
#3740 value += nput;
#3749  const size_t *start, size_t nelems, const int *value)
#3759 assert(value != NULL);
#3771 lstatus = ncx_putn_ushort_int(&xpnputvalue);
#3785 value += nput;
#3794  const size_t *start, size_t nelems, const float *value)
#3804 assert(value != NULL);
#3816 lstatus = ncx_putn_ushort_float(&xpnputvalue);
#3830 value += nput;
#3839  const size_t *start, size_t nelems, const double *value)
#3849 assert(value != NULL);
#3861 lstatus = ncx_putn_ushort_double(&xpnputvalue);
#3875 value += nput;
#3884  const size_t *start, size_t nelems, const longlong *value)
#3894 assert(value != NULL);
#3906 lstatus = ncx_putn_ushort_longlong(&xpnputvalue);
#3920 value += nput;
#3929  const size_t *start, size_t nelems, const ushort *value)
#3939 assert(value != NULL);
#3951 lstatus = ncx_putn_ushort_ushort(&xpnputvalue);
#3965 value += nput;
#3974  const size_t *start, size_t nelems, const uint *value)
#3984 assert(value != NULL);
#3996 lstatus = ncx_putn_ushort_uint(&xpnputvalue);
#4010 value += nput;
#4019  const size_t *start, size_t nelems, const ulonglong *value)
#4029 assert(value != NULL);
#4041 lstatus = ncx_putn_ushort_ulonglong(&xpnputvalue);
#4055 value += nput;
#4065  const size_t *start, size_t nelems, const schar *value)
#4075 assert(value != NULL);
#4087 lstatus = ncx_putn_uint_schar(&xpnputvalue);
#4101 value += nput;
#4110  const size_t *start, size_t nelems, const uchar *value)
#4120 assert(value != NULL);
#4132 lstatus = ncx_putn_uint_uchar(&xpnputvalue);
#4146 value += nput;
#4155  const size_t *start, size_t nelems, const short *value)
#4165 assert(value != NULL);
#4177 lstatus = ncx_putn_uint_short(&xpnputvalue);
#4191 value += nput;
#4200  const size_t *start, size_t nelems, const int *value)
#4210 assert(value != NULL);
#4222 lstatus = ncx_putn_uint_int(&xpnputvalue);
#4236 value += nput;
#4245  const size_t *start, size_t nelems, const float *value)
#4255 assert(value != NULL);
#4267 lstatus = ncx_putn_uint_float(&xpnputvalue);
#4281 value += nput;
#4290  const size_t *start, size_t nelems, const double *value)
#4300 assert(value != NULL);
#4312 lstatus = ncx_putn_uint_double(&xpnputvalue);
#4326 value += nput;
#4335  const size_t *start, size_t nelems, const longlong *value)
#4345 assert(value != NULL);
#4357 lstatus = ncx_putn_uint_longlong(&xpnputvalue);
#4371 value += nput;
#4380  const size_t *start, size_t nelems, const ushort *value)
#4390 assert(value != NULL);
#4402 lstatus = ncx_putn_uint_ushort(&xpnputvalue);
#4416 value += nput;
#4425  const size_t *start, size_t nelems, const uint *value)
#4435 assert(value != NULL);
#4447 lstatus = ncx_putn_uint_uint(&xpnputvalue);
#4461 value += nput;
#4470  const size_t *start, size_t nelems, const ulonglong *value)
#4480 assert(value != NULL);
#4492 lstatus = ncx_putn_uint_ulonglong(&xpnputvalue);
#4506 value += nput;
#4516  const size_t *start, size_t nelems, const schar *value)
#4526 assert(value != NULL);
#4538 lstatus = ncx_putn_longlong_schar(&xpnputvalue);
#4552 value += nput;
#4561  const size_t *start, size_t nelems, const uchar *value)
#4571 assert(value != NULL);
#4583 lstatus = ncx_putn_longlong_uchar(&xpnputvalue);
#4597 value += nput;
#4606  const size_t *start, size_t nelems, const short *value)
#4616 assert(value != NULL);
#4628 lstatus = ncx_putn_longlong_short(&xpnputvalue);
#4642 value += nput;
#4651  const size_t *start, size_t nelems, const int *value)
#4661 assert(value != NULL);
#4673 lstatus = ncx_putn_longlong_int(&xpnputvalue);
#4687 value += nput;
#4696  const size_t *start, size_t nelems, const float *value)
#4706 assert(value != NULL);
#4718 lstatus = ncx_putn_longlong_float(&xpnputvalue);
#4732 value += nput;
#4741  const size_t *start, size_t nelems, const double *value)
#4751 assert(value != NULL);
#4763 lstatus = ncx_putn_longlong_double(&xpnputvalue);
#4777 value += nput;
#4786  const size_t *start, size_t nelems, const longlong *value)
#4796 assert(value != NULL);
#4808 lstatus = ncx_putn_longlong_longlong(&xpnputvalue);
#4822 value += nput;
#4831  const size_t *start, size_t nelems, const ushort *value)
#4841 assert(value != NULL);
#4853 lstatus = ncx_putn_longlong_ushort(&xpnputvalue);
#4867 value += nput;
#4876  const size_t *start, size_t nelems, const uint *value)
#4886 assert(value != NULL);
#4898 lstatus = ncx_putn_longlong_uint(&xpnputvalue);
#4912 value += nput;
#4921  const size_t *start, size_t nelems, const ulonglong *value)
#4931 assert(value != NULL);
#4943 lstatus = ncx_putn_longlong_ulonglong(&xpnputvalue);
#4957 value += nput;
#4967  const size_t *start, size_t nelems, const schar *value)
#4977 assert(value != NULL);
#4989 lstatus = ncx_putn_ulonglong_schar(&xpnputvalue);
#5003 value += nput;
#5012  const size_t *start, size_t nelems, const uchar *value)
#5022 assert(value != NULL);
#5034 lstatus = ncx_putn_ulonglong_uchar(&xpnputvalue);
#5048 value += nput;
#5057  const size_t *start, size_t nelems, const short *value)
#5067 assert(value != NULL);
#5079 lstatus = ncx_putn_ulonglong_short(&xpnputvalue);
#5093 value += nput;
#5102  const size_t *start, size_t nelems, const int *value)
#5112 assert(value != NULL);
#5124 lstatus = ncx_putn_ulonglong_int(&xpnputvalue);
#5138 value += nput;
#5147  const size_t *start, size_t nelems, const float *value)
#5157 assert(value != NULL);
#5169 lstatus = ncx_putn_ulonglong_float(&xpnputvalue);
#5183 value += nput;
#5192  const size_t *start, size_t nelems, const double *value)
#5202 assert(value != NULL);
#5214 lstatus = ncx_putn_ulonglong_double(&xpnputvalue);
#5228 value += nput;
#5237  const size_t *start, size_t nelems, const longlong *value)
#5247 assert(value != NULL);
#5259 lstatus = ncx_putn_ulonglong_longlong(&xpnputvalue);
#5273 value += nput;
#5282  const size_t *start, size_t nelems, const ushort *value)
#5292 assert(value != NULL);
#5304 lstatus = ncx_putn_ulonglong_ushort(&xpnputvalue);
#5318 value += nput;
#5327  const size_t *start, size_t nelems, const uint *value)
#5337 assert(value != NULL);
#5349 lstatus = ncx_putn_ulonglong_uint(&xpnputvalue);
#5363 value += nput;
#5372  const size_t *start, size_t nelems, const ulonglong *value)
#5382 assert(value != NULL);
#5394 lstatus = ncx_putn_ulonglong_ulonglong(&xpnputvalue);
#5408 value += nput;
#5419  const size_t *start, size_t nelems, char *value)
#5429 assert(value != NULL);
#5441 lstatus = ncx_getn_char_char(&xpngetvalue);
#5451 value += nget;
#5460  const size_t *start, size_t nelemsschar *value)
#5470 assert(value != NULL);
#5482 lstatus = ncx_getn_schar_schar(&xpngetvalue);
#5492 value += nget;
#5500  const size_t *start, size_t nelems, short *value)
#5510 assert(value != NULL);
#5522 lstatus = ncx_getn_schar_short(&xpngetvalue);
#5532 value += nget;
#5540  const size_t *start, size_t nelems, int *value)
#5550 assert(value != NULL);
#5562 lstatus = ncx_getn_schar_int(&xpngetvalue);
#5572 value += nget;
#5580  const size_t *start, size_t nelems, float *value)
#5590 assert(value != NULL);
#5602 lstatus = ncx_getn_schar_float(&xpngetvalue);
#5612 value += nget;
#5620  const size_t *start, size_t nelems, double *value)
#5630 assert(value != NULL);
#5642 lstatus = ncx_getn_schar_double(&xpngetvalue);
#5652 value += nget;
#5660  const size_t *start, size_t nelemslonglong *value)
#5670 assert(value != NULL);
#5682 lstatus = ncx_getn_schar_longlong(&xpngetvalue);
#5692 value += nget;
#5700  const size_t *start, size_t nelemsuint *value)
#5710 assert(value != NULL);
#5722 lstatus = ncx_getn_schar_uint(&xpngetvalue);
#5732 value += nget;
#5740  const size_t *start, size_t nelemsulonglong *value)
#5750 assert(value != NULL);
#5762 lstatus = ncx_getn_schar_ulonglong(&xpngetvalue);
#5772 value += nget;
#5780  const size_t *start, size_t nelemsuchar *value)
#5790 assert(value != NULL);
#5802 lstatus = ncx_getn_schar_uchar(&xpngetvalue);
#5812 value += nget;
#5820  const size_t *start, size_t nelemsushort *value)
#5830 assert(value != NULL);
#5842 lstatus = ncx_getn_schar_ushort(&xpngetvalue);
#5852 value += nget;
#5861  const size_t *start, size_t nelemsschar *value)
#5871 assert(value != NULL);
#5883 lstatus = ncx_getn_short_schar(&xpngetvalue);
#5893 value += nget;
#5901  const size_t *start, size_t nelemsuchar *value)
#5911 assert(value != NULL);
#5923 lstatus = ncx_getn_short_uchar(&xpngetvalue);
#5933 value += nget;
#5941  const size_t *start, size_t nelems, short *value)
#5951 assert(value != NULL);
#5963 lstatus = ncx_getn_short_short(&xpngetvalue);
#5973 value += nget;
#5981  const size_t *start, size_t nelems, int *value)
#5991 assert(value != NULL);
#6003 lstatus = ncx_getn_short_int(&xpngetvalue);
#6013 value += nget;
#6021  const size_t *start, size_t nelems, float *value)
#6031 assert(value != NULL);
#6043 lstatus = ncx_getn_short_float(&xpngetvalue);
#6053 value += nget;
#6061  const size_t *start, size_t nelems, double *value)
#6071 assert(value != NULL);
#6083 lstatus = ncx_getn_short_double(&xpngetvalue);
#6093 value += nget;
#6101  const size_t *start, size_t nelemslonglong *value)
#6111 assert(value != NULL);
#6123 lstatus = ncx_getn_short_longlong(&xpngetvalue);
#6133 value += nget;
#6141  const size_t *start, size_t nelemsuint *value)
#6151 assert(value != NULL);
#6163 lstatus = ncx_getn_short_uint(&xpngetvalue);
#6173 value += nget;
#6181  const size_t *start, size_t nelemsulonglong *value)
#6191 assert(value != NULL);
#6203 lstatus = ncx_getn_short_ulonglong(&xpngetvalue);
#6213 value += nget;
#6221  const size_t *start, size_t nelemsushort *value)
#6231 assert(value != NULL);
#6243 lstatus = ncx_getn_short_ushort(&xpngetvalue);
#6253 value += nget;
#6262  const size_t *start, size_t nelemsschar *value)
#6272 assert(value != NULL);
#6284 lstatus = ncx_getn_int_schar(&xpngetvalue);
#6294 value += nget;
#6302  const size_t *start, size_t nelemsuchar *value)
#6312 assert(value != NULL);
#6324 lstatus = ncx_getn_int_uchar(&xpngetvalue);
#6334 value += nget;
#6342  const size_t *start, size_t nelems, short *value)
#6352 assert(value != NULL);
#6364 lstatus = ncx_getn_int_short(&xpngetvalue);
#6374 value += nget;
#6382  const size_t *start, size_t nelems, int *value)
#6392 assert(value != NULL);
#6404 lstatus = ncx_getn_int_int(&xpngetvalue);
#6414 value += nget;
#6422  const size_t *start, size_t nelems, float *value)
#6432 assert(value != NULL);
#6444 lstatus = ncx_getn_int_float(&xpngetvalue);
#6454 value += nget;
#6462  const size_t *start, size_t nelems, double *value)
#6472 assert(value != NULL);
#6484 lstatus = ncx_getn_int_double(&xpngetvalue);
#6494 value += nget;
#6502  const size_t *start, size_t nelemslonglong *value)
#6512 assert(value != NULL);
#6524 lstatus = ncx_getn_int_longlong(&xpngetvalue);
#6534 value += nget;
#6542  const size_t *start, size_t nelemsuint *value)
#6552 assert(value != NULL);
#6564 lstatus = ncx_getn_int_uint(&xpngetvalue);
#6574 value += nget;
#6582  const size_t *start, size_t nelemsulonglong *value)
#6592 assert(value != NULL);
#6604 lstatus = ncx_getn_int_ulonglong(&xpngetvalue);
#6614 value += nget;
#6622  const size_t *start, size_t nelemsushort *value)
#6632 assert(value != NULL);
#6644 lstatus = ncx_getn_int_ushort(&xpngetvalue);
#6654 value += nget;
#6663  const size_t *start, size_t nelemsschar *value)
#6673 assert(value != NULL);
#6685 lstatus = ncx_getn_float_schar(&xpngetvalue);
#6695 value += nget;
#6703  const size_t *start, size_t nelemsuchar *value)
#6713 assert(value != NULL);
#6725 lstatus = ncx_getn_float_uchar(&xpngetvalue);
#6735 value += nget;
#6743  const size_t *start, size_t nelems, short *value)
#6753 assert(value != NULL);
#6765 lstatus = ncx_getn_float_short(&xpngetvalue);
#6775 value += nget;
#6783  const size_t *start, size_t nelems, int *value)
#6793 assert(value != NULL);
#6805 lstatus = ncx_getn_float_int(&xpngetvalue);
#6815 value += nget;
#6823  const size_t *start, size_t nelems, float *value)
#6833 assert(value != NULL);
#6845 lstatus = ncx_getn_float_float(&xpngetvalue);
#6855 value += nget;
#6863  const size_t *start, size_t nelems, double *value)
#6873 assert(value != NULL);
#6885 lstatus = ncx_getn_float_double(&xpngetvalue);
#6895 value += nget;
#6903  const size_t *start, size_t nelemslonglong *value)
#6913 assert(value != NULL);
#6925 lstatus = ncx_getn_float_longlong(&xpngetvalue);
#6935 value += nget;
#6943  const size_t *start, size_t nelemsuint *value)
#6953 assert(value != NULL);
#6965 lstatus = ncx_getn_float_uint(&xpngetvalue);
#6975 value += nget;
#6983  const size_t *start, size_t nelemsulonglong *value)
#6993 assert(value != NULL);
#7005 lstatus = ncx_getn_float_ulonglong(&xpngetvalue);
#7015 value += nget;
#7023  const size_t *start, size_t nelemsushort *value)
#7033 assert(value != NULL);
#7045 lstatus = ncx_getn_float_ushort(&xpngetvalue);
#7055 value += nget;
#7064  const size_t *start, size_t nelemsschar *value)
#7074 assert(value != NULL);
#7086 lstatus = ncx_getn_double_schar(&xpngetvalue);
#7096 value += nget;
#7104  const size_t *start, size_t nelemsuchar *value)
#7114 assert(value != NULL);
#7126 lstatus = ncx_getn_double_uchar(&xpngetvalue);
#7136 value += nget;
#7144  const size_t *start, size_t nelems, short *value)
#7154 assert(value != NULL);
#7166 lstatus = ncx_getn_double_short(&xpngetvalue);
#7176 value += nget;
#7184  const size_t *start, size_t nelems, int *value)
#7194 assert(value != NULL);
#7206 lstatus = ncx_getn_double_int(&xpngetvalue);
#7216 value += nget;
#7224  const size_t *start, size_t nelems, float *value)
#7234 assert(value != NULL);
#7246 lstatus = ncx_getn_double_float(&xpngetvalue);
#7256 value += nget;
#7264  const size_t *start, size_t nelems, double *value)
#7274 assert(value != NULL);
#7286 lstatus = ncx_getn_double_double(&xpngetvalue);
#7296 value += nget;
#7304  const size_t *start, size_t nelemslonglong *value)
#7314 assert(value != NULL);
#7326 lstatus = ncx_getn_double_longlong(&xpngetvalue);
#7336 value += nget;
#7344  const size_t *start, size_t nelemsuint *value)
#7354 assert(value != NULL);
#7366 lstatus = ncx_getn_double_uint(&xpngetvalue);
#7376 value += nget;
#7384  const size_t *start, size_t nelemsulonglong *value)
#7394 assert(value != NULL);
#7406 lstatus = ncx_getn_double_ulonglong(&xpngetvalue);
#7416 value += nget;
#7424  const size_t *start, size_t nelemsushort *value)
#7434 assert(value != NULL);
#7446 lstatus = ncx_getn_double_ushort(&xpngetvalue);
#7456 value += nget;
#7465  const size_t *start, size_t nelemsschar *value)
#7475 assert(value != NULL);
#7487 lstatus = ncx_getn_uchar_schar(&xpngetvalue);
#7497 value += nget;
#7505  const size_t *start, size_t nelemsuchar *value)
#7515 assert(value != NULL);
#7527 lstatus = ncx_getn_uchar_uchar(&xpngetvalue);
#7537 value += nget;
#7545  const size_t *start, size_t nelems, short *value)
#7555 assert(value != NULL);
#7567 lstatus = ncx_getn_uchar_short(&xpngetvalue);
#7577 value += nget;
#7585  const size_t *start, size_t nelems, int *value)
#7595 assert(value != NULL);
#7607 lstatus = ncx_getn_uchar_int(&xpngetvalue);
#7617 value += nget;
#7625  const size_t *start, size_t nelems, float *value)
#7635 assert(value != NULL);
#7647 lstatus = ncx_getn_uchar_float(&xpngetvalue);
#7657 value += nget;
#7665  const size_t *start, size_t nelems, double *value)
#7675 assert(value != NULL);
#7687 lstatus = ncx_getn_uchar_double(&xpngetvalue);
#7697 value += nget;
#7705  const size_t *start, size_t nelemslonglong *value)
#7715 assert(value != NULL);
#7727 lstatus = ncx_getn_uchar_longlong(&xpngetvalue);
#7737 value += nget;
#7745  const size_t *start, size_t nelemsuint *value)
#7755 assert(value != NULL);
#7767 lstatus = ncx_getn_uchar_uint(&xpngetvalue);
#7777 value += nget;
#7785  const size_t *start, size_t nelemsulonglong *value)
#7795 assert(value != NULL);
#7807 lstatus = ncx_getn_uchar_ulonglong(&xpngetvalue);
#7817 value += nget;
#7825  const size_t *start, size_t nelemsushort *value)
#7835 assert(value != NULL);
#7847 lstatus = ncx_getn_uchar_ushort(&xpngetvalue);
#7857 value += nget;
#7866  const size_t *start, size_t nelemsschar *value)
#7876 assert(value != NULL);
#7888 lstatus = ncx_getn_ushort_schar(&xpngetvalue);
#7898 value += nget;
#7906  const size_t *start, size_t nelemsuchar *value)
#7916 assert(value != NULL);
#7928 lstatus = ncx_getn_ushort_uchar(&xpngetvalue);
#7938 value += nget;
#7946  const size_t *start, size_t nelems, short *value)
#7956 assert(value != NULL);
#7968 lstatus = ncx_getn_ushort_short(&xpngetvalue);
#7978 value += nget;
#7986  const size_t *start, size_t nelems, int *value)
#7996 assert(value != NULL);
#8008 lstatus = ncx_getn_ushort_int(&xpngetvalue);
#8018 value += nget;
#8026  const size_t *start, size_t nelems, float *value)
#8036 assert(value != NULL);
#8048 lstatus = ncx_getn_ushort_float(&xpngetvalue);
#8058 value += nget;
#8066  const size_t *start, size_t nelems, double *value)
#8076 assert(value != NULL);
#8088 lstatus = ncx_getn_ushort_double(&xpngetvalue);
#8098 value += nget;
#8106  const size_t *start, size_t nelemslonglong *value)
#8116 assert(value != NULL);
#8128 lstatus = ncx_getn_ushort_longlong(&xpngetvalue);
#8138 value += nget;
#8146  const size_t *start, size_t nelemsuint *value)
#8156 assert(value != NULL);
#8168 lstatus = ncx_getn_ushort_uint(&xpngetvalue);
#8178 value += nget;
#8186  const size_t *start, size_t nelemsulonglong *value)
#8196 assert(value != NULL);
#8208 lstatus = ncx_getn_ushort_ulonglong(&xpngetvalue);
#8218 value += nget;
#8226  const size_t *start, size_t nelemsushort *value)
#8236 assert(value != NULL);
#8248 lstatus = ncx_getn_ushort_ushort(&xpngetvalue);
#8258 value += nget;
#8267  const size_t *start, size_t nelemsschar *value)
#8277 assert(value != NULL);
#8289 lstatus = ncx_getn_uint_schar(&xpngetvalue);
#8299 value += nget;
#8307  const size_t *start, size_t nelemsuchar *value)
#8317 assert(value != NULL);
#8329 lstatus = ncx_getn_uint_uchar(&xpngetvalue);
#8339 value += nget;
#8347  const size_t *start, size_t nelems, short *value)
#8357 assert(value != NULL);
#8369 lstatus = ncx_getn_uint_short(&xpngetvalue);
#8379 value += nget;
#8387  const size_t *start, size_t nelems, int *value)
#8397 assert(value != NULL);
#8409 lstatus = ncx_getn_uint_int(&xpngetvalue);
#8419 value += nget;
#8427  const size_t *start, size_t nelems, float *value)
#8437 assert(value != NULL);
#8449 lstatus = ncx_getn_uint_float(&xpngetvalue);
#8459 value += nget;
#8467  const size_t *start, size_t nelems, double *value)
#8477 assert(value != NULL);
#8489 lstatus = ncx_getn_uint_double(&xpngetvalue);
#8499 value += nget;
#8507  const size_t *start, size_t nelemslonglong *value)
#8517 assert(value != NULL);
#8529 lstatus = ncx_getn_uint_longlong(&xpngetvalue);
#8539 value += nget;
#8547  const size_t *start, size_t nelemsuint *value)
#8557 assert(value != NULL);
#8569 lstatus = ncx_getn_uint_uint(&xpngetvalue);
#8579 value += nget;
#8587  const size_t *start, size_t nelemsulonglong *value)
#8597 assert(value != NULL);
#8609 lstatus = ncx_getn_uint_ulonglong(&xpngetvalue);
#8619 value += nget;
#8627  const size_t *start, size_t nelemsushort *value)
#8637 assert(value != NULL);
#8649 lstatus = ncx_getn_uint_ushort(&xpngetvalue);
#8659 value += nget;
#8668  const size_t *start, size_t nelemsschar *value)
#8678 assert(value != NULL);
#8690 lstatus = ncx_getn_longlong_schar(&xpngetvalue);
#8700 value += nget;
#8708  const size_t *start, size_t nelemsuchar *value)
#8718 assert(value != NULL);
#8730 lstatus = ncx_getn_longlong_uchar(&xpngetvalue);
#8740 value += nget;
#8748  const size_t *start, size_t nelems, short *value)
#8758 assert(value != NULL);
#8770 lstatus = ncx_getn_longlong_short(&xpngetvalue);
#8780 value += nget;
#8788  const size_t *start, size_t nelems, int *value)
#8798 assert(value != NULL);
#8810 lstatus = ncx_getn_longlong_int(&xpngetvalue);
#8820 value += nget;
#8828  const size_t *start, size_t nelems, float *value)
#8838 assert(value != NULL);
#8850 lstatus = ncx_getn_longlong_float(&xpngetvalue);
#8860 value += nget;
#8868  const size_t *start, size_t nelems, double *value)
#8878 assert(value != NULL);
#8890 lstatus = ncx_getn_longlong_double(&xpngetvalue);
#8900 value += nget;
#8908  const size_t *start, size_t nelemslonglong *value)
#8918 assert(value != NULL);
#8930 lstatus = ncx_getn_longlong_longlong(&xpngetvalue);
#8940 value += nget;
#8948  const size_t *start, size_t nelemsuint *value)
#8958 assert(value != NULL);
#8970 lstatus = ncx_getn_longlong_uint(&xpngetvalue);
#8980 value += nget;
#8988  const size_t *start, size_t nelemsulonglong *value)
#8998 assert(value != NULL);
#9010 lstatus = ncx_getn_longlong_ulonglong(&xpngetvalue);
#9020 value += nget;
#9028  const size_t *start, size_t nelemsushort *value)
#9038 assert(value != NULL);
#9050 lstatus = ncx_getn_longlong_ushort(&xpngetvalue);
#9060 value += nget;
#9069  const size_t *start, size_t nelemsschar *value)
#9079 assert(value != NULL);
#9091 lstatus = ncx_getn_ulonglong_schar(&xpngetvalue);
#9101 value += nget;
#9109  const size_t *start, size_t nelemsuchar *value)
#9119 assert(value != NULL);
#9131 lstatus = ncx_getn_ulonglong_uchar(&xpngetvalue);
#9141 value += nget;
#9149  const size_t *start, size_t nelems, short *value)
#9159 assert(value != NULL);
#9171 lstatus = ncx_getn_ulonglong_short(&xpngetvalue);
#9181 value += nget;
#9189  const size_t *start, size_t nelems, int *value)
#9199 assert(value != NULL);
#9211 lstatus = ncx_getn_ulonglong_int(&xpngetvalue);
#9221 value += nget;
#9229  const size_t *start, size_t nelems, float *value)
#9239 assert(value != NULL);
#9251 lstatus = ncx_getn_ulonglong_float(&xpngetvalue);
#9261 value += nget;
#9269  const size_t *start, size_t nelems, double *value)
#9279 assert(value != NULL);
#9291 lstatus = ncx_getn_ulonglong_double(&xpngetvalue);
#9301 value += nget;
#9309  const size_t *start, size_t nelemslonglong *value)
#9319 assert(value != NULL);
#9331 lstatus = ncx_getn_ulonglong_longlong(&xpngetvalue);
#9341 value += nget;
#9349  const size_t *start, size_t nelemsuint *value)
#9359 assert(value != NULL);
#9371 lstatus = ncx_getn_ulonglong_uint(&xpngetvalue);
#9381 value += nget;
#9389  const size_t *start, size_t nelemsulonglong *value)
#9399 assert(value != NULL);
#9411 lstatus = ncx_getn_ulonglong_ulonglong(&xpngetvalue);
#9421 value += nget;
#9429  const size_t *start, size_t nelemsushort *value)
#9439 assert(value != NULL);
#9451 lstatus = ncx_getn_ulonglong_ushort(&xpngetvalue);
#9461 value += nget;
#9471  const size_t *start, size_t nelemsuchar *value)
#9481 assert(value != NULL);
#9493 lstatus = ncx_getn_schar_uchar(&xpngetvalue);
#9503 value += nget;
#9660        const size_t nelems, void* value, const nc_type memtype)
#9668       return getNCvx_char_char(ncp,varp,start,nelems,(char*)value);
#9670    return getNCvx_schar_schar(ncp,varp,start,nelems,(signed char*)value);
#9674        return getNCvx_schar_schar(ncp,varp,start,nelems,(signed char*)value);
#9677        return getNCvx_schar_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9680        return getNCvx_schar_short(ncp,varp,start,nelems,(short*)value);
#9683        return getNCvx_schar_int(ncp,varp,start,nelems,(int*)value);
#9686        return getNCvx_schar_float(ncp,varp,start,nelems,(float*)value);
#9689        return getNCvx_schar_double(ncp,varp,start,nelems,(double *)value);
#9692        return getNCvx_schar_longlong(ncp,varp,start,nelems,(long long*)value);
#9695        return getNCvx_schar_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9698        return getNCvx_schar_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9701        return getNCvx_schar_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9704        return getNCvx_short_schar(ncp,varp,start,nelems,(signed char*)value);
#9707        return getNCvx_short_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9710        return getNCvx_short_short(ncp,varp,start,nelems,(short*)value);
#9713        return getNCvx_short_int(ncp,varp,start,nelems,(int*)value);
#9716        return getNCvx_short_float(ncp,varp,start,nelems,(float*)value);
#9719        return getNCvx_short_double(ncp,varp,start,nelems,(double*)value);
#9722        return getNCvx_short_longlong(ncp,varp,start,nelems,(long long*)value);
#9725        return getNCvx_short_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9728        return getNCvx_short_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9731        return getNCvx_short_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9735        return getNCvx_int_schar(ncp,varp,start,nelems,(signed char*)value);
#9738        return getNCvx_int_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9741        return getNCvx_int_short(ncp,varp,start,nelems,(short*)value);
#9744        return getNCvx_int_int(ncp,varp,start,nelems,(int*)value);
#9747        return getNCvx_int_float(ncp,varp,start,nelems,(float*)value);
#9750        return getNCvx_int_double(ncp,varp,start,nelems,(double*)value);
#9753        return getNCvx_int_longlong(ncp,varp,start,nelems,(long long*)value);
#9756        return getNCvx_int_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9759        return getNCvx_int_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9762        return getNCvx_int_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9766        return getNCvx_float_schar(ncp,varp,start,nelems,(signed char*)value);
#9769        return getNCvx_float_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9772        return getNCvx_float_short(ncp,varp,start,nelems,(short*)value);
#9775        return getNCvx_float_int(ncp,varp,start,nelems,(int*)value);
#9778        return getNCvx_float_float(ncp,varp,start,nelems,(float*)value);
#9781        return getNCvx_float_double(ncp,varp,start,nelems,(double*)value);
#9784        return getNCvx_float_longlong(ncp,varp,start,nelems,(long long*)value);
#9787        return getNCvx_float_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9790        return getNCvx_float_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9793        return getNCvx_float_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9797        return getNCvx_double_schar(ncp,varp,start,nelems,(signed char*)value);
#9800        return getNCvx_double_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9803        return getNCvx_double_short(ncp,varp,start,nelems,(short*)value);
#9806        return getNCvx_double_int(ncp,varp,start,nelems,(int*)value);
#9809        return getNCvx_double_float(ncp,varp,start,nelems,(float*)value);
#9812        return getNCvx_double_double(ncp,varp,start,nelems,(double*)value);
#9815        return getNCvx_double_longlong(ncp,varp,start,nelems,(long long*)value);
#9818        return getNCvx_double_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9821        return getNCvx_double_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9824        return getNCvx_double_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9828        return getNCvx_uchar_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9831        return getNCvx_uchar_schar(ncp,varp,start,nelems,(signed char*)value);
#9834        return getNCvx_uchar_short(ncp,varp,start,nelems,(short*)value);
#9837        return getNCvx_uchar_int(ncp,varp,start,nelems,(int*)value);
#9840        return getNCvx_uchar_float(ncp,varp,start,nelems,(float*)value);
#9843        return getNCvx_uchar_double(ncp,varp,start,nelems,(double *)value);
#9846        return getNCvx_uchar_longlong(ncp,varp,start,nelems,(long long*)value);
#9849        return getNCvx_uchar_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9852        return getNCvx_uchar_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9855        return getNCvx_uchar_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9859        return getNCvx_ushort_schar(ncp,varp,start,nelems,(signed char*)value);
#9862        return getNCvx_ushort_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9865        return getNCvx_ushort_short(ncp,varp,start,nelems,(short*)value);
#9868        return getNCvx_ushort_int(ncp,varp,start,nelems,(int*)value);
#9871        return getNCvx_ushort_float(ncp,varp,start,nelems,(float*)value);
#9874        return getNCvx_ushort_double(ncp,varp,start,nelems,(double*)value);
#9877        return getNCvx_ushort_longlong(ncp,varp,start,nelems,(long long*)value);
#9880        return getNCvx_ushort_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9883        return getNCvx_ushort_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9886        return getNCvx_ushort_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9890        return getNCvx_uint_schar(ncp,varp,start,nelems,(signed char*)value);
#9893        return getNCvx_uint_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9896        return getNCvx_uint_short(ncp,varp,start,nelems,(short*)value);
#9899        return getNCvx_uint_int(ncp,varp,start,nelems,(int*)value);
#9902        return getNCvx_uint_float(ncp,varp,start,nelems,(float*)value);
#9905        return getNCvx_uint_double(ncp,varp,start,nelems,(double*)value);
#9908        return getNCvx_uint_longlong(ncp,varp,start,nelems,(long long*)value);
#9911        return getNCvx_uint_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9914        return getNCvx_uint_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9917        return getNCvx_uint_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9921        return getNCvx_longlong_schar(ncp,varp,start,nelems,(signed char*)value);
#9924        return getNCvx_longlong_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9927        return getNCvx_longlong_short(ncp,varp,start,nelems,(short*)value);
#9930        return getNCvx_longlong_int(ncp,varp,start,nelems,(int*)value);
#9933        return getNCvx_longlong_float(ncp,varp,start,nelems,(float*)value);
#9936        return getNCvx_longlong_double(ncp,varp,start,nelems,(double*)value);
#9939        return getNCvx_longlong_longlong(ncp,varp,start,nelems,(long long*)value);
#9942        return getNCvx_longlong_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9945        return getNCvx_longlong_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9948        return getNCvx_longlong_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9952        return getNCvx_ulonglong_schar(ncp,varp,start,nelems,(signed char*)value);
#9955        return getNCvx_ulonglong_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#9958        return getNCvx_ulonglong_short(ncp,varp,start,nelems,(short*)value);
#9961        return getNCvx_ulonglong_int(ncp,varp,start,nelems,(int*)value);
#9964        return getNCvx_ulonglong_float(ncp,varp,start,nelems,(float*)value);
#9967        return getNCvx_ulonglong_double(ncp,varp,start,nelems,(double*)value);
#9970        return getNCvx_ulonglong_longlong(ncp,varp,start,nelems,(long long*)value);
#9973        return getNCvx_ulonglong_uint(ncp,varp,start,nelems,(unsigned int*)value);
#9976        return getNCvx_ulonglong_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#9979        return getNCvx_ulonglong_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#9992         const size_t nelems, const void* value, const nc_type memtype)
#9999        return putNCvx_char_char(ncp,varp,start,nelems,(char*)value);
#10002        return putNCvx_schar_schar(ncp,varp,start,nelems,(signed char*)value);
#10005        return putNCvx_schar_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10008        return putNCvx_schar_short(ncp,varp,start,nelems,(short*)value);
#10011        return putNCvx_schar_int(ncp,varp,start,nelems,(int*)value);
#10014        return putNCvx_schar_float(ncp,varp,start,nelems,(float*)value);
#10017        return putNCvx_schar_double(ncp,varp,start,nelems,(double *)value);
#10020        return putNCvx_schar_longlong(ncp,varp,start,nelems,(long long*)value);
#10023        return putNCvx_schar_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10026        return putNCvx_schar_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10029        return putNCvx_schar_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10032        return putNCvx_short_schar(ncp,varp,start,nelems,(signed char*)value);
#10035        return putNCvx_short_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10038        return putNCvx_short_short(ncp,varp,start,nelems,(short*)value);
#10041        return putNCvx_short_int(ncp,varp,start,nelems,(int*)value);
#10044        return putNCvx_short_float(ncp,varp,start,nelems,(float*)value);
#10047        return putNCvx_short_double(ncp,varp,start,nelems,(double*)value);
#10050        return putNCvx_short_longlong(ncp,varp,start,nelems,(long long*)value);
#10053        return putNCvx_short_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10056        return putNCvx_short_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10059        return putNCvx_short_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10062        return putNCvx_int_schar(ncp,varp,start,nelems,(signed char*)value);
#10065        return putNCvx_int_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10068        return putNCvx_int_short(ncp,varp,start,nelems,(short*)value);
#10071        return putNCvx_int_int(ncp,varp,start,nelems,(int*)value);
#10074        return putNCvx_int_float(ncp,varp,start,nelems,(float*)value);
#10077        return putNCvx_int_double(ncp,varp,start,nelems,(double*)value);
#10080        return putNCvx_int_longlong(ncp,varp,start,nelems,(long long*)value);
#10083        return putNCvx_int_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10086        return putNCvx_int_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10089        return putNCvx_int_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10092        return putNCvx_float_schar(ncp,varp,start,nelems,(signed char*)value);
#10095        return putNCvx_float_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10098        return putNCvx_float_short(ncp,varp,start,nelems,(short*)value);
#10101        return putNCvx_float_int(ncp,varp,start,nelems,(int*)value);
#10104        return putNCvx_float_float(ncp,varp,start,nelems,(float*)value);
#10107        return putNCvx_float_double(ncp,varp,start,nelems,(double*)value);
#10110        return putNCvx_float_longlong(ncp,varp,start,nelems,(long long*)value);
#10113        return putNCvx_float_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10116        return putNCvx_float_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10119        return putNCvx_float_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10122        return putNCvx_double_schar(ncp,varp,start,nelems,(signed char*)value);
#10125        return putNCvx_double_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10128        return putNCvx_double_short(ncp,varp,start,nelems,(short*)value);
#10131        return putNCvx_double_int(ncp,varp,start,nelems,(int*)value);
#10134        return putNCvx_double_float(ncp,varp,start,nelems,(float*)value);
#10137        return putNCvx_double_double(ncp,varp,start,nelems,(double*)value);
#10140        return putNCvx_double_longlong(ncp,varp,start,nelems,(long long*)value);
#10143        return putNCvx_double_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10146        return putNCvx_double_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10149        return putNCvx_double_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10152        return putNCvx_uchar_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10155        return putNCvx_uchar_schar(ncp,varp,start,nelems,(signed char*)value);
#10158        return putNCvx_uchar_short(ncp,varp,start,nelems,(short*)value);
#10161        return putNCvx_uchar_int(ncp,varp,start,nelems,(int*)value);
#10164        return putNCvx_uchar_float(ncp,varp,start,nelems,(float*)value);
#10167        return putNCvx_uchar_double(ncp,varp,start,nelems,(double *)value);
#10170        return putNCvx_uchar_longlong(ncp,varp,start,nelems,(long long*)value);
#10173        return putNCvx_uchar_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10176        return putNCvx_uchar_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10179        return putNCvx_uchar_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10182        return putNCvx_ushort_schar(ncp,varp,start,nelems,(signed char*)value);
#10185        return putNCvx_ushort_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10188        return putNCvx_ushort_short(ncp,varp,start,nelems,(short*)value);
#10191        return putNCvx_ushort_int(ncp,varp,start,nelems,(int*)value);
#10194        return putNCvx_ushort_float(ncp,varp,start,nelems,(float*)value);
#10197        return putNCvx_ushort_double(ncp,varp,start,nelems,(double*)value);
#10200        return putNCvx_ushort_longlong(ncp,varp,start,nelems,(long long*)value);
#10203        return putNCvx_ushort_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10206        return putNCvx_ushort_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10209        return putNCvx_ushort_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10212        return putNCvx_uint_schar(ncp,varp,start,nelems,(signed char*)value);
#10215        return putNCvx_uint_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10218        return putNCvx_uint_short(ncp,varp,start,nelems,(short*)value);
#10221        return putNCvx_uint_int(ncp,varp,start,nelems,(int*)value);
#10224        return putNCvx_uint_float(ncp,varp,start,nelems,(float*)value);
#10227        return putNCvx_uint_double(ncp,varp,start,nelems,(double*)value);
#10230        return putNCvx_uint_longlong(ncp,varp,start,nelems,(long long*)value);
#10233        return putNCvx_uint_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10236        return putNCvx_uint_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10239        return putNCvx_uint_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10242        return putNCvx_longlong_schar(ncp,varp,start,nelems,(signed char*)value);
#10245        return putNCvx_longlong_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10248        return putNCvx_longlong_short(ncp,varp,start,nelems,(short*)value);
#10251        return putNCvx_longlong_int(ncp,varp,start,nelems,(int*)value);
#10254        return putNCvx_longlong_float(ncp,varp,start,nelems,(float*)value);
#10257        return putNCvx_longlong_double(ncp,varp,start,nelems,(double*)value);
#10260        return putNCvx_longlong_longlong(ncp,varp,start,nelems,(long long*)value);
#10263        return putNCvx_longlong_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10266        return putNCvx_longlong_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10269        return putNCvx_longlong_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10272        return putNCvx_ulonglong_schar(ncp,varp,start,nelems,(signed char*)value);
#10275        return putNCvx_ulonglong_uchar(ncp,varp,start,nelems,(unsigned char*)value);
#10278        return putNCvx_ulonglong_short(ncp,varp,start,nelems,(short*)value);
#10281        return putNCvx_ulonglong_int(ncp,varp,start,nelems,(int*)value);
#10284        return putNCvx_ulonglong_float(ncp,varp,start,nelems,(float*)value);
#10287        return putNCvx_ulonglong_double(ncp,varp,start,nelems,(double*)value);
#10290        return putNCvx_ulonglong_longlong(ncp,varp,start,nelems,(long long*)value);
#10293        return putNCvx_ulonglong_uint(ncp,varp,start,nelems,(unsigned int*)value);
#10296        return putNCvx_ulonglong_ulonglong(ncp,varp,start,nelems,(unsigned long long*)value);
#10299        return putNCvx_ulonglong_ushort(ncp,varp,start,nelems,(unsigned short*)value);
#10324    signed char* value = (signed char*) value0; /* legally allow ptr arithmetic */
#10373        return( readNCv(nc3varpstart, 1, (void*)valuememtype) );
#10383            return( readNCv(nc3varpstart, *edges, (void*)valuememtype) );
#10395        return( readNCv(nc3varpstartiocount, (void*)valuememtype) );
#10414        const int lstatus = readNCv(nc3varpcoordiocount, (void*)valuememtype);
#10427        value += (iocount * memtypelen);
#10451    signed char* value = (signed char*) value0; /* legally allow ptr arithmetic */
#10503        return( writeNCv(nc3varpstart, 1, (void*)valuememtype) );
#10516            return( writeNCv(nc3varpstart, *edges, (void*)valuememtype) );
#10528        return( writeNCv(nc3varpstartiocount, (void*)valuememtype) );
#10547        const int lstatus = writeNCv(nc3varpcoordiocount, (void*)valuememtype);
#10560        value += (iocount * memtypelen);
semantics.c#446     processeconstrefsR(con->value.compoundv);
#458    Symbolrefsym = con->value.enumv;
#469 con->value.enumv = (Symbol*)listget(candidates,0);
#492 con->value.enumv = listget(grpmatches,0);
#512 con->value.enumv = match;
#517    con->value.enumv = (Symbol*)listget(candidates,0);
#867 if(con->value.uint64v > NC_MAX_INT64) {forceuint64=1; break;}
#878 case NC_BYTE :   if(con->value.int8v < 0)   {hasneg = 1;} break;
#879 case NC_SHORT:   if(con->value.int16v < 0)  {hasneg = 1;} break;
#880 case NC_INT:     if(con->value.int32v < 0)  {hasneg = 1;} break;
#946     validateNILr(con->value.compoundv);
#1117     computeunlimitedsizes(dimset,nextunlim,con->value.compoundv,ischar);
#1131     length += con->value.stringv.len;
#1187             computeunlimitedsizes(dimset,first,con->value.compoundv,ischar);
test_get.c#27    text value;
#36        err = nc_get_var1_text(BAD_IDiindex, &value);
#39        err = nc_get_var1_text(ncidBAD_VARIDindex, &value);
#44     err = nc_get_var1_text(ncidiindex, &value);
#58 err = nc_get_var1_text(ncidiNULL, &value);
#60 err = nc_get_var1_text(ncidiindex, &value);
#67     IF (!equal(value,expect,var_type[i],NCT_TEXT)) {
#69     (double) value);
#105    uchar value;
#114        err = nc_get_var1_uchar(BAD_IDiindex, &value);
#117        err = nc_get_var1_uchar(ncidBAD_VARIDindex, &value);
#122     err = nc_get_var1_uchar(ncidiindex, &value);
#136 err = nc_get_var1_uchar(ncidiNULL, &value);
#138 err = nc_get_var1_uchar(ncidiindex, &value);
#145     IF (!equal(value,expect,var_type[i],NCT_UCHAR)) {
#147     (double) value);
#183    schar value;
#192        err = nc_get_var1_schar(BAD_IDiindex, &value);
#195        err = nc_get_var1_schar(ncidBAD_VARIDindex, &value);
#200     err = nc_get_var1_schar(ncidiindex, &value);
#214 err = nc_get_var1_schar(ncidiNULL, &value);
#216 err = nc_get_var1_schar(ncidiindex, &value);
#223     IF (!equal(value,expect,var_type[i],NCT_SCHAR)) {
#225     (double) value);
#261    short value;
#270        err = nc_get_var1_short(BAD_IDiindex, &value);
#273        err = nc_get_var1_short(ncidBAD_VARIDindex, &value);
#278     err = nc_get_var1_short(ncidiindex, &value);
#292 err = nc_get_var1_short(ncidiNULL, &value);
#294 err = nc_get_var1_short(ncidiindex, &value);
#301     IF (!equal(value,expect,var_type[i],NCT_SHORT)) {
#303     (double) value);
#339    int value;
#348        err = nc_get_var1_int(BAD_IDiindex, &value);
#351        err = nc_get_var1_int(ncidBAD_VARIDindex, &value);
#356     err = nc_get_var1_int(ncidiindex, &value);
#370 err = nc_get_var1_int(ncidiNULL, &value);
#372 err = nc_get_var1_int(ncidiindex, &value);
#379     IF (!equal(value,expect,var_type[i],NCT_INT)) {
#381     (double) value);
#417    long value;
#426        err = nc_get_var1_long(BAD_IDiindex, &value);
#429        err = nc_get_var1_long(ncidBAD_VARIDindex, &value);
#434     err = nc_get_var1_long(ncidiindex, &value);
#448 err = nc_get_var1_long(ncidiNULL, &value);
#450 err = nc_get_var1_long(ncidiindex, &value);
#457     IF (!equal(value,expect,var_type[i],NCT_LONG)) {
#459     (double) value);
#495    float value;
#504        err = nc_get_var1_float(BAD_IDiindex, &value);
#507        err = nc_get_var1_float(ncidBAD_VARIDindex, &value);
#512     err = nc_get_var1_float(ncidiindex, &value);
#526 err = nc_get_var1_float(ncidiNULL, &value);
#528 err = nc_get_var1_float(ncidiindex, &value);
#535     IF (!equal(value,expect,var_type[i],NCT_FLOAT)) {
#537     (double) value);
#573    double value;
#582        err = nc_get_var1_double(BAD_IDiindex, &value);
#585        err = nc_get_var1_double(ncidBAD_VARIDindex, &value);
#590     err = nc_get_var1_double(ncidiindex, &value);
#604 err = nc_get_var1_double(ncidiNULL, &value);
#606 err = nc_get_var1_double(ncidiindex, &value);
#613     IF (!equal(value,expect,var_type[i],NCT_DOUBLE)) {
#615     (double) value);
#651    ushort value;
#660        err = nc_get_var1_ushort(BAD_IDiindex, &value);
#663        err = nc_get_var1_ushort(ncidBAD_VARIDindex, &value);
#668     err = nc_get_var1_ushort(ncidiindex, &value);
#682 err = nc_get_var1_ushort(ncidiNULL, &value);
#684 err = nc_get_var1_ushort(ncidiindex, &value);
#691     IF (!equal(value,expect,var_type[i],NCT_USHORT)) {
#693     (double) value);
#729    uint value;
#738        err = nc_get_var1_uint(BAD_IDiindex, &value);
#741        err = nc_get_var1_uint(ncidBAD_VARIDindex, &value);
#746     err = nc_get_var1_uint(ncidiindex, &value);
#760 err = nc_get_var1_uint(ncidiNULL, &value);
#762 err = nc_get_var1_uint(ncidiindex, &value);
#769     IF (!equal(value,expect,var_type[i],NCT_UINT)) {
#771     (double) value);
#807    longlong value;
#816        err = nc_get_var1_longlong(BAD_IDiindex, &value);
#819        err = nc_get_var1_longlong(ncidBAD_VARIDindex, &value);
#824     err = nc_get_var1_longlong(ncidiindex, &value);
#838 err = nc_get_var1_longlong(ncidiNULL, &value);
#840 err = nc_get_var1_longlong(ncidiindex, &value);
#847     IF (!equal(value,expect,var_type[i],NCT_LONGLONG)) {
#849     (double) value);
#885    ulonglong value;
#894        err = nc_get_var1_ulonglong(BAD_IDiindex, &value);
#897        err = nc_get_var1_ulonglong(ncidBAD_VARIDindex, &value);
#902     err = nc_get_var1_ulonglong(ncidiindex, &value);
#916 err = nc_get_var1_ulonglong(ncidiNULL, &value);
#918 err = nc_get_var1_ulonglong(ncidiindex, &value);
#925     IF (!equal(value,expect,var_type[i],NCT_ULONGLONG)) {
#927     (double) value);
#968    text value[MAX_NELS];
#978        err = nc_get_var_text(BAD_IDivalue);
#981        err = nc_get_var_text(ncidBAD_VARIDvalue);
#1002 err = nc_get_var_text(ncidivalue);
#1019     IF (!equal(value[j],expect[j],var_type[i],NCT_TEXT)){
#1027     error("got: %g", (double) value[j]);
#1058    uchar value[MAX_NELS];
#1068        err = nc_get_var_uchar(BAD_IDivalue);
#1071        err = nc_get_var_uchar(ncidBAD_VARIDvalue);
#1092 err = nc_get_var_uchar(ncidivalue);
#1109     IF (!equal(value[j],expect[j],var_type[i],NCT_UCHAR)){
#1117     error("got: %g", (double) value[j]);
#1148    schar value[MAX_NELS];
#1158        err = nc_get_var_schar(BAD_IDivalue);
#1161        err = nc_get_var_schar(ncidBAD_VARIDvalue);
#1182 err = nc_get_var_schar(ncidivalue);
#1199     IF (!equal(value[j],expect[j],var_type[i],NCT_SCHAR)){
#1207     error("got: %g", (double) value[j]);
#1238    short value[MAX_NELS];
#1248        err = nc_get_var_short(BAD_IDivalue);
#1251        err = nc_get_var_short(ncidBAD_VARIDvalue);
#1272 err = nc_get_var_short(ncidivalue);
#1289     IF (!equal(value[j],expect[j],var_type[i],NCT_SHORT)){
#1297     error("got: %g", (double) value[j]);
#1328    int value[MAX_NELS];
#1338        err = nc_get_var_int(BAD_IDivalue);
#1341        err = nc_get_var_int(ncidBAD_VARIDvalue);
#1362 err = nc_get_var_int(ncidivalue);
#1379     IF (!equal(value[j],expect[j],var_type[i],NCT_INT)){
#1387     error("got: %g", (double) value[j]);
#1418    long value[MAX_NELS];
#1428        err = nc_get_var_long(BAD_IDivalue);
#1431        err = nc_get_var_long(ncidBAD_VARIDvalue);
#1452 err = nc_get_var_long(ncidivalue);
#1469     IF (!equal(value[j],expect[j],var_type[i],NCT_LONG)){
#1477     error("got: %g", (double) value[j]);
#1508    float value[MAX_NELS];
#1518        err = nc_get_var_float(BAD_IDivalue);
#1521        err = nc_get_var_float(ncidBAD_VARIDvalue);
#1542 err = nc_get_var_float(ncidivalue);
#1559     IF (!equal(value[j],expect[j],var_type[i],NCT_FLOAT)){
#1567     error("got: %g", (double) value[j]);
#1598    double value[MAX_NELS];
#1608        err = nc_get_var_double(BAD_IDivalue);
#1611        err = nc_get_var_double(ncidBAD_VARIDvalue);
#1632 err = nc_get_var_double(ncidivalue);
#1649     IF (!equal(value[j],expect[j],var_type[i],NCT_DOUBLE)){
#1657     error("got: %g", (double) value[j]);
#1688    ushort value[MAX_NELS];
#1698        err = nc_get_var_ushort(BAD_IDivalue);
#1701        err = nc_get_var_ushort(ncidBAD_VARIDvalue);
#1722 err = nc_get_var_ushort(ncidivalue);
#1739     IF (!equal(value[j],expect[j],var_type[i],NCT_USHORT)){
#1747     error("got: %g", (double) value[j]);
#1778    uint value[MAX_NELS];
#1788        err = nc_get_var_uint(BAD_IDivalue);
#1791        err = nc_get_var_uint(ncidBAD_VARIDvalue);
#1812 err = nc_get_var_uint(ncidivalue);
#1829     IF (!equal(value[j],expect[j],var_type[i],NCT_UINT)){
#1837     error("got: %g", (double) value[j]);
#1868    longlong value[MAX_NELS];
#1878        err = nc_get_var_longlong(BAD_IDivalue);
#1881        err = nc_get_var_longlong(ncidBAD_VARIDvalue);
#1902 err = nc_get_var_longlong(ncidivalue);
#1919     IF (!equal(value[j],expect[j],var_type[i],NCT_LONGLONG)){
#1927     error("got: %g", (double) value[j]);
#1958    ulonglong value[MAX_NELS];
#1968        err = nc_get_var_ulonglong(BAD_IDivalue);
#1971        err = nc_get_var_ulonglong(ncidBAD_VARIDvalue);
#1992 err = nc_get_var_ulonglong(ncidivalue);
#2009     IF (!equal(value[j],expect[j],var_type[i],NCT_ULONGLONG)){
#2017     error("got: %g", (double) value[j]);
#2057    text value[MAX_NELS];
#2071        err = nc_get_vara_text(BAD_IDistartedgevalue);
#2074        err = nc_get_vara_text(ncidBAD_VARIDstartedgevalue);
#2079     err = nc_get_vara_text(ncidistartedgevalue);
#2084     err = nc_get_vara_text(ncidistartedgevalue);
#2095     err = nc_get_vara_text(BAD_IDistartedgevalue);
#2098     err = nc_get_vara_text(ncidBAD_VARIDstartedgevalue);
#2101     err = nc_get_vara_text(ncidistartedgevalue);
#2148 err = nc_get_vara_text(ncidiNULLNULLvalue);
#2150 err = nc_get_vara_text(ncidistartedgevalue);
#2167 IF (!equal(value[j],expect[j],var_type[i],NCT_TEXT)){
#2175 error("got: %g", (double) value[j]);
#2213    uchar value[MAX_NELS];
#2227        err = nc_get_vara_uchar(BAD_IDistartedgevalue);
#2230        err = nc_get_vara_uchar(ncidBAD_VARIDstartedgevalue);
#2235     err = nc_get_vara_uchar(ncidistartedgevalue);
#2240     err = nc_get_vara_uchar(ncidistartedgevalue);
#2251     err = nc_get_vara_uchar(BAD_IDistartedgevalue);
#2254     err = nc_get_vara_uchar(ncidBAD_VARIDstartedgevalue);
#2257     err = nc_get_vara_uchar(ncidistartedgevalue);
#2304 err = nc_get_vara_uchar(ncidiNULLNULLvalue);
#2306 err = nc_get_vara_uchar(ncidistartedgevalue);
#2323 IF (!equal(value[j],expect[j],var_type[i],NCT_UCHAR)){
#2331 error("got: %g", (double) value[j]);
#2369    schar value[MAX_NELS];
#2383        err = nc_get_vara_schar(BAD_IDistartedgevalue);
#2386        err = nc_get_vara_schar(ncidBAD_VARIDstartedgevalue);
#2391     err = nc_get_vara_schar(ncidistartedgevalue);
#2396     err = nc_get_vara_schar(ncidistartedgevalue);
#2407     err = nc_get_vara_schar(BAD_IDistartedgevalue);
#2410     err = nc_get_vara_schar(ncidBAD_VARIDstartedgevalue);
#2413     err = nc_get_vara_schar(ncidistartedgevalue);
#2460 err = nc_get_vara_schar(ncidiNULLNULLvalue);
#2462 err = nc_get_vara_schar(ncidistartedgevalue);
#2479 IF (!equal(value[j],expect[j],var_type[i],NCT_SCHAR)){
#2487 error("got: %g", (double) value[j]);
#2525    short value[MAX_NELS];
#2539        err = nc_get_vara_short(BAD_IDistartedgevalue);
#2542        err = nc_get_vara_short(ncidBAD_VARIDstartedgevalue);
#2547     err = nc_get_vara_short(ncidistartedgevalue);
#2552     err = nc_get_vara_short(ncidistartedgevalue);
#2563     err = nc_get_vara_short(BAD_IDistartedgevalue);
#2566     err = nc_get_vara_short(ncidBAD_VARIDstartedgevalue);
#2569     err = nc_get_vara_short(ncidistartedgevalue);
#2616 err = nc_get_vara_short(ncidiNULLNULLvalue);
#2618 err = nc_get_vara_short(ncidistartedgevalue);
#2635 IF (!equal(value[j],expect[j],var_type[i],NCT_SHORT)){
#2643 error("got: %g", (double) value[j]);
#2681    int value[MAX_NELS];
#2695        err = nc_get_vara_int(BAD_IDistartedgevalue);
#2698        err = nc_get_vara_int(ncidBAD_VARIDstartedgevalue);
#2703     err = nc_get_vara_int(ncidistartedgevalue);
#2708     err = nc_get_vara_int(ncidistartedgevalue);
#2719     err = nc_get_vara_int(BAD_IDistartedgevalue);
#2722     err = nc_get_vara_int(ncidBAD_VARIDstartedgevalue);
#2725     err = nc_get_vara_int(ncidistartedgevalue);
#2772 err = nc_get_vara_int(ncidiNULLNULLvalue);
#2774 err = nc_get_vara_int(ncidistartedgevalue);
#2791 IF (!equal(value[j],expect[j],var_type[i],NCT_INT)){
#2799 error("got: %g", (double) value[j]);
#2837    long value[MAX_NELS];
#2851        err = nc_get_vara_long(BAD_IDistartedgevalue);
#2854        err = nc_get_vara_long(ncidBAD_VARIDstartedgevalue);
#2859     err = nc_get_vara_long(ncidistartedgevalue);
#2864     err = nc_get_vara_long(ncidistartedgevalue);
#2875     err = nc_get_vara_long(BAD_IDistartedgevalue);
#2878     err = nc_get_vara_long(ncidBAD_VARIDstartedgevalue);
#2881     err = nc_get_vara_long(ncidistartedgevalue);
#2928 err = nc_get_vara_long(ncidiNULLNULLvalue);
#2930 err = nc_get_vara_long(ncidistartedgevalue);
#2947 IF (!equal(value[j],expect[j],var_type[i],NCT_LONG)){
#2955 error("got: %g", (double) value[j]);
#2993    float value[MAX_NELS];
#3007        err = nc_get_vara_float(BAD_IDistartedgevalue);
#3010        err = nc_get_vara_float(ncidBAD_VARIDstartedgevalue);
#3015     err = nc_get_vara_float(ncidistartedgevalue);
#3020     err = nc_get_vara_float(ncidistartedgevalue);
#3031     err = nc_get_vara_float(BAD_IDistartedgevalue);
#3034     err = nc_get_vara_float(ncidBAD_VARIDstartedgevalue);
#3037     err = nc_get_vara_float(ncidistartedgevalue);
#3084 err = nc_get_vara_float(ncidiNULLNULLvalue);
#3086 err = nc_get_vara_float(ncidistartedgevalue);
#3103 IF (!equal(value[j],expect[j],var_type[i],NCT_FLOAT)){
#3111 error("got: %g", (double) value[j]);
#3149    double value[MAX_NELS];
#3163        err = nc_get_vara_double(BAD_IDistartedgevalue);
#3166        err = nc_get_vara_double(ncidBAD_VARIDstartedgevalue);
#3171     err = nc_get_vara_double(ncidistartedgevalue);
#3176     err = nc_get_vara_double(ncidistartedgevalue);
#3187     err = nc_get_vara_double(BAD_IDistartedgevalue);
#3190     err = nc_get_vara_double(ncidBAD_VARIDstartedgevalue);
#3193     err = nc_get_vara_double(ncidistartedgevalue);
#3240 err = nc_get_vara_double(ncidiNULLNULLvalue);
#3242 err = nc_get_vara_double(ncidistartedgevalue);
#3259 IF (!equal(value[j],expect[j],var_type[i],NCT_DOUBLE)){
#3267 error("got: %g", (double) value[j]);
#3305    ushort value[MAX_NELS];
#3319        err = nc_get_vara_ushort(BAD_IDistartedgevalue);
#3322        err = nc_get_vara_ushort(ncidBAD_VARIDstartedgevalue);
#3327     err = nc_get_vara_ushort(ncidistartedgevalue);
#3332     err = nc_get_vara_ushort(ncidistartedgevalue);
#3343     err = nc_get_vara_ushort(BAD_IDistartedgevalue);
#3346     err = nc_get_vara_ushort(ncidBAD_VARIDstartedgevalue);
#3349     err = nc_get_vara_ushort(ncidistartedgevalue);
#3396 err = nc_get_vara_ushort(ncidiNULLNULLvalue);
#3398 err = nc_get_vara_ushort(ncidistartedgevalue);
#3415 IF (!equal(value[j],expect[j],var_type[i],NCT_USHORT)){
#3423 error("got: %g", (double) value[j]);
#3461    uint value[MAX_NELS];
#3475        err = nc_get_vara_uint(BAD_IDistartedgevalue);
#3478        err = nc_get_vara_uint(ncidBAD_VARIDstartedgevalue);
#3483     err = nc_get_vara_uint(ncidistartedgevalue);
#3488     err = nc_get_vara_uint(ncidistartedgevalue);
#3499     err = nc_get_vara_uint(BAD_IDistartedgevalue);
#3502     err = nc_get_vara_uint(ncidBAD_VARIDstartedgevalue);
#3505     err = nc_get_vara_uint(ncidistartedgevalue);
#3552 err = nc_get_vara_uint(ncidiNULLNULLvalue);
#3554 err = nc_get_vara_uint(ncidistartedgevalue);
#3571 IF (!equal(value[j],expect[j],var_type[i],NCT_UINT)){
#3579 error("got: %g", (double) value[j]);
#3617    longlong value[MAX_NELS];
#3631        err = nc_get_vara_longlong(BAD_IDistartedgevalue);
#3634        err = nc_get_vara_longlong(ncidBAD_VARIDstartedgevalue);
#3639     err = nc_get_vara_longlong(ncidistartedgevalue);
#3644     err = nc_get_vara_longlong(ncidistartedgevalue);
#3655     err = nc_get_vara_longlong(BAD_IDistartedgevalue);
#3658     err = nc_get_vara_longlong(ncidBAD_VARIDstartedgevalue);
#3661     err = nc_get_vara_longlong(ncidistartedgevalue);
#3708 err = nc_get_vara_longlong(ncidiNULLNULLvalue);
#3710 err = nc_get_vara_longlong(ncidistartedgevalue);
#3727 IF (!equal(value[j],expect[j],var_type[i],NCT_LONGLONG)){
#3735 error("got: %g", (double) value[j]);
#3773    ulonglong value[MAX_NELS];
#3787        err = nc_get_vara_ulonglong(BAD_IDistartedgevalue);
#3790        err = nc_get_vara_ulonglong(ncidBAD_VARIDstartedgevalue);
#3795     err = nc_get_vara_ulonglong(ncidistartedgevalue);
#3800     err = nc_get_vara_ulonglong(ncidistartedgevalue);
#3811     err = nc_get_vara_ulonglong(BAD_IDistartedgevalue);
#3814     err = nc_get_vara_ulonglong(ncidBAD_VARIDstartedgevalue);
#3817     err = nc_get_vara_ulonglong(ncidistartedgevalue);
#3864 err = nc_get_vara_ulonglong(ncidiNULLNULLvalue);
#3866 err = nc_get_vara_ulonglong(ncidistartedgevalue);
#3883 IF (!equal(value[j],expect[j],var_type[i],NCT_ULONGLONG)){
#3891 error("got: %g", (double) value[j]);
#3938    text value[MAX_NELS];
#3953        err = nc_get_vars_text(BAD_IDistartedgestridevalue);
#3956        err = nc_get_vars_text(ncidBAD_VARIDstartedgestridevalue);
#3961            err = nc_get_vars_text(ncidistartedgestridevalue);
#3970            err = nc_get_vars_text(ncidistartedgestridevalue);
#3975            err = nc_get_vars_text(ncidistartedgestridevalue);
#4039                    err = nc_get_vars_text(ncidiNULLNULLNULLvalue);
#4041                    err = nc_get_vars_text(ncidiindexcountstridevalue);
#4058     IF (!equal(value[j],expect[j],var_type[i], NCT_TEXT)){
#4066     error("got: %g", (double) value[j]);
#4112    uchar value[MAX_NELS];
#4127        err = nc_get_vars_uchar(BAD_IDistartedgestridevalue);
#4130        err = nc_get_vars_uchar(ncidBAD_VARIDstartedgestridevalue);
#4135            err = nc_get_vars_uchar(ncidistartedgestridevalue);
#4144            err = nc_get_vars_uchar(ncidistartedgestridevalue);
#4149            err = nc_get_vars_uchar(ncidistartedgestridevalue);
#4213                    err = nc_get_vars_uchar(ncidiNULLNULLNULLvalue);
#4215                    err = nc_get_vars_uchar(ncidiindexcountstridevalue);
#4232     IF (!equal(value[j],expect[j],var_type[i], NCT_UCHAR)){
#4240     error("got: %g", (double) value[j]);
#4286    schar value[MAX_NELS];
#4301        err = nc_get_vars_schar(BAD_IDistartedgestridevalue);
#4304        err = nc_get_vars_schar(ncidBAD_VARIDstartedgestridevalue);
#4309            err = nc_get_vars_schar(ncidistartedgestridevalue);
#4318            err = nc_get_vars_schar(ncidistartedgestridevalue);
#4323            err = nc_get_vars_schar(ncidistartedgestridevalue);
#4387                    err = nc_get_vars_schar(ncidiNULLNULLNULLvalue);
#4389                    err = nc_get_vars_schar(ncidiindexcountstridevalue);
#4406     IF (!equal(value[j],expect[j],var_type[i], NCT_SCHAR)){
#4414     error("got: %g", (double) value[j]);
#4460    short value[MAX_NELS];
#4475        err = nc_get_vars_short(BAD_IDistartedgestridevalue);
#4478        err = nc_get_vars_short(ncidBAD_VARIDstartedgestridevalue);
#4483            err = nc_get_vars_short(ncidistartedgestridevalue);
#4492            err = nc_get_vars_short(ncidistartedgestridevalue);
#4497            err = nc_get_vars_short(ncidistartedgestridevalue);
#4561                    err = nc_get_vars_short(ncidiNULLNULLNULLvalue);
#4563                    err = nc_get_vars_short(ncidiindexcountstridevalue);
#4580     IF (!equal(value[j],expect[j],var_type[i], NCT_SHORT)){
#4588     error("got: %g", (double) value[j]);
#4634    int value[MAX_NELS];
#4649        err = nc_get_vars_int(BAD_IDistartedgestridevalue);
#4652        err = nc_get_vars_int(ncidBAD_VARIDstartedgestridevalue);
#4657            err = nc_get_vars_int(ncidistartedgestridevalue);
#4666            err = nc_get_vars_int(ncidistartedgestridevalue);
#4671            err = nc_get_vars_int(ncidistartedgestridevalue);
#4735                    err = nc_get_vars_int(ncidiNULLNULLNULLvalue);
#4737                    err = nc_get_vars_int(ncidiindexcountstridevalue);
#4754     IF (!equal(value[j],expect[j],var_type[i], NCT_INT)){
#4762     error("got: %g", (double) value[j]);
#4808    long value[MAX_NELS];
#4823        err = nc_get_vars_long(BAD_IDistartedgestridevalue);
#4826        err = nc_get_vars_long(ncidBAD_VARIDstartedgestridevalue);
#4831            err = nc_get_vars_long(ncidistartedgestridevalue);
#4840            err = nc_get_vars_long(ncidistartedgestridevalue);
#4845            err = nc_get_vars_long(ncidistartedgestridevalue);
#4909                    err = nc_get_vars_long(ncidiNULLNULLNULLvalue);
#4911                    err = nc_get_vars_long(ncidiindexcountstridevalue);
#4928     IF (!equal(value[j],expect[j],var_type[i], NCT_LONG)){
#4936     error("got: %g", (double) value[j]);
#4982    float value[MAX_NELS];
#4997        err = nc_get_vars_float(BAD_IDistartedgestridevalue);
#5000        err = nc_get_vars_float(ncidBAD_VARIDstartedgestridevalue);
#5005            err = nc_get_vars_float(ncidistartedgestridevalue);
#5014            err = nc_get_vars_float(ncidistartedgestridevalue);
#5019            err = nc_get_vars_float(ncidistartedgestridevalue);
#5083                    err = nc_get_vars_float(ncidiNULLNULLNULLvalue);
#5085                    err = nc_get_vars_float(ncidiindexcountstridevalue);
#5102     IF (!equal(value[j],expect[j],var_type[i], NCT_FLOAT)){
#5110     error("got: %g", (double) value[j]);
#5156    double value[MAX_NELS];
#5171        err = nc_get_vars_double(BAD_IDistartedgestridevalue);
#5174        err = nc_get_vars_double(ncidBAD_VARIDstartedgestridevalue);
#5179            err = nc_get_vars_double(ncidistartedgestridevalue);
#5188            err = nc_get_vars_double(ncidistartedgestridevalue);
#5193            err = nc_get_vars_double(ncidistartedgestridevalue);
#5257                    err = nc_get_vars_double(ncidiNULLNULLNULLvalue);
#5259                    err = nc_get_vars_double(ncidiindexcountstridevalue);
#5276     IF (!equal(value[j],expect[j],var_type[i], NCT_DOUBLE)){
#5284     error("got: %g", (double) value[j]);
#5330    ushort value[MAX_NELS];
#5345        err = nc_get_vars_ushort(BAD_IDistartedgestridevalue);
#5348        err = nc_get_vars_ushort(ncidBAD_VARIDstartedgestridevalue);
#5353            err = nc_get_vars_ushort(ncidistartedgestridevalue);
#5362            err = nc_get_vars_ushort(ncidistartedgestridevalue);
#5367            err = nc_get_vars_ushort(ncidistartedgestridevalue);
#5431                    err = nc_get_vars_ushort(ncidiNULLNULLNULLvalue);
#5433                    err = nc_get_vars_ushort(ncidiindexcountstridevalue);
#5450     IF (!equal(value[j],expect[j],var_type[i], NCT_USHORT)){
#5458     error("got: %g", (double) value[j]);
#5504    uint value[MAX_NELS];
#5519        err = nc_get_vars_uint(BAD_IDistartedgestridevalue);
#5522        err = nc_get_vars_uint(ncidBAD_VARIDstartedgestridevalue);
#5527            err = nc_get_vars_uint(ncidistartedgestridevalue);
#5536            err = nc_get_vars_uint(ncidistartedgestridevalue);
#5541            err = nc_get_vars_uint(ncidistartedgestridevalue);
#5605                    err = nc_get_vars_uint(ncidiNULLNULLNULLvalue);
#5607                    err = nc_get_vars_uint(ncidiindexcountstridevalue);
#5624     IF (!equal(value[j],expect[j],var_type[i], NCT_UINT)){
#5632     error("got: %g", (double) value[j]);
#5678    longlong value[MAX_NELS];
#5693        err = nc_get_vars_longlong(BAD_IDistartedgestridevalue);
#5696        err = nc_get_vars_longlong(ncidBAD_VARIDstartedgestridevalue);
#5701            err = nc_get_vars_longlong(ncidistartedgestridevalue);
#5710            err = nc_get_vars_longlong(ncidistartedgestridevalue);
#5715            err = nc_get_vars_longlong(ncidistartedgestridevalue);
#5779                    err = nc_get_vars_longlong(ncidiNULLNULLNULLvalue);
#5781                    err = nc_get_vars_longlong(ncidiindexcountstridevalue);
#5798     IF (!equal(value[j],expect[j],var_type[i], NCT_LONGLONG)){
#5806     error("got: %g", (double) value[j]);
#5852    ulonglong value[MAX_NELS];
#5867        err = nc_get_vars_ulonglong(BAD_IDistartedgestridevalue);
#5870        err = nc_get_vars_ulonglong(ncidBAD_VARIDstartedgestridevalue);
#5875            err = nc_get_vars_ulonglong(ncidistartedgestridevalue);
#5884            err = nc_get_vars_ulonglong(ncidistartedgestridevalue);
#5889            err = nc_get_vars_ulonglong(ncidistartedgestridevalue);
#5953                    err = nc_get_vars_ulonglong(ncidiNULLNULLNULLvalue);
#5955                    err = nc_get_vars_ulonglong(ncidiindexcountstridevalue);
#5972     IF (!equal(value[j],expect[j],var_type[i], NCT_ULONGLONG)){
#5980     error("got: %g", (double) value[j]);
#6030    text value[MAX_NELS];
#6046        err = nc_get_varm_text(BAD_IDistartedgestrideimapvalue);
#6049        err = nc_get_varm_text(ncidBAD_VARIDstartedgestrideimapvalue);
#6054            err = nc_get_varm_text(ncidistartedgestrideimapvalue);
#6063            err = nc_get_varm_text(ncidistartedgestrideimapvalue);
#6068            err = nc_get_varm_text(ncidistartedgestrideimapvalue);
#6138                    err = nc_get_varm_text(ncid,i,NULL,NULL,NULL,NULL,value);
#6140                    err = nc_get_varm_text(ncid,i,index,count,stride,imap,value);
#6158     IF (!equal(value[j],expect[j],var_type[i], NCT_TEXT)){
#6166                                    error("got: %g", (double) value[j]);
#6212    uchar value[MAX_NELS];
#6228        err = nc_get_varm_uchar(BAD_IDistartedgestrideimapvalue);
#6231        err = nc_get_varm_uchar(ncidBAD_VARIDstartedgestrideimapvalue);
#6236            err = nc_get_varm_uchar(ncidistartedgestrideimapvalue);
#6245            err = nc_get_varm_uchar(ncidistartedgestrideimapvalue);
#6250            err = nc_get_varm_uchar(ncidistartedgestrideimapvalue);
#6320                    err = nc_get_varm_uchar(ncid,i,NULL,NULL,NULL,NULL,value);
#6322                    err = nc_get_varm_uchar(ncid,i,index,count,stride,imap,value);
#6340     IF (!equal(value[j],expect[j],var_type[i], NCT_UCHAR)){
#6348                                    error("got: %g", (double) value[j]);
#6394    schar value[MAX_NELS];
#6410        err = nc_get_varm_schar(BAD_IDistartedgestrideimapvalue);
#6413        err = nc_get_varm_schar(ncidBAD_VARIDstartedgestrideimapvalue);
#6418            err = nc_get_varm_schar(ncidistartedgestrideimapvalue);
#6427            err = nc_get_varm_schar(ncidistartedgestrideimapvalue);
#6432            err = nc_get_varm_schar(ncidistartedgestrideimapvalue);
#6502                    err = nc_get_varm_schar(ncid,i,NULL,NULL,NULL,NULL,value);
#6504                    err = nc_get_varm_schar(ncid,i,index,count,stride,imap,value);
#6522     IF (!equal(value[j],expect[j],var_type[i], NCT_SCHAR)){
#6530                                    error("got: %g", (double) value[j]);
#6576    short value[MAX_NELS];
#6592        err = nc_get_varm_short(BAD_IDistartedgestrideimapvalue);
#6595        err = nc_get_varm_short(ncidBAD_VARIDstartedgestrideimapvalue);
#6600            err = nc_get_varm_short(ncidistartedgestrideimapvalue);
#6609            err = nc_get_varm_short(ncidistartedgestrideimapvalue);
#6614            err = nc_get_varm_short(ncidistartedgestrideimapvalue);
#6684                    err = nc_get_varm_short(ncid,i,NULL,NULL,NULL,NULL,value);
#6686                    err = nc_get_varm_short(ncid,i,index,count,stride,imap,value);
#6704     IF (!equal(value[j],expect[j],var_type[i], NCT_SHORT)){
#6712                                    error("got: %g", (double) value[j]);
#6758    int value[MAX_NELS];
#6774        err = nc_get_varm_int(BAD_IDistartedgestrideimapvalue);
#6777        err = nc_get_varm_int(ncidBAD_VARIDstartedgestrideimapvalue);
#6782            err = nc_get_varm_int(ncidistartedgestrideimapvalue);
#6791            err = nc_get_varm_int(ncidistartedgestrideimapvalue);
#6796            err = nc_get_varm_int(ncidistartedgestrideimapvalue);
#6866                    err = nc_get_varm_int(ncid,i,NULL,NULL,NULL,NULL,value);
#6868                    err = nc_get_varm_int(ncid,i,index,count,stride,imap,value);
#6886     IF (!equal(value[j],expect[j],var_type[i], NCT_INT)){
#6894                                    error("got: %g", (double) value[j]);
#6940    long value[MAX_NELS];
#6956        err = nc_get_varm_long(BAD_IDistartedgestrideimapvalue);
#6959        err = nc_get_varm_long(ncidBAD_VARIDstartedgestrideimapvalue);
#6964            err = nc_get_varm_long(ncidistartedgestrideimapvalue);
#6973            err = nc_get_varm_long(ncidistartedgestrideimapvalue);
#6978            err = nc_get_varm_long(ncidistartedgestrideimapvalue);
#7048                    err = nc_get_varm_long(ncid,i,NULL,NULL,NULL,NULL,value);
#7050                    err = nc_get_varm_long(ncid,i,index,count,stride,imap,value);
#7068     IF (!equal(value[j],expect[j],var_type[i], NCT_LONG)){
#7076                                    error("got: %g", (double) value[j]);
#7122    float value[MAX_NELS];
#7138        err = nc_get_varm_float(BAD_IDistartedgestrideimapvalue);
#7141        err = nc_get_varm_float(ncidBAD_VARIDstartedgestrideimapvalue);
#7146            err = nc_get_varm_float(ncidistartedgestrideimapvalue);
#7155            err = nc_get_varm_float(ncidistartedgestrideimapvalue);
#7160            err = nc_get_varm_float(ncidistartedgestrideimapvalue);
#7230                    err = nc_get_varm_float(ncid,i,NULL,NULL,NULL,NULL,value);
#7232                    err = nc_get_varm_float(ncid,i,index,count,stride,imap,value);
#7250     IF (!equal(value[j],expect[j],var_type[i], NCT_FLOAT)){
#7258                                    error("got: %g", (double) value[j]);
#7304    double value[MAX_NELS];
#7320        err = nc_get_varm_double(BAD_IDistartedgestrideimapvalue);
#7323        err = nc_get_varm_double(ncidBAD_VARIDstartedgestrideimapvalue);
#7328            err = nc_get_varm_double(ncidistartedgestrideimapvalue);
#7337            err = nc_get_varm_double(ncidistartedgestrideimapvalue);
#7342            err = nc_get_varm_double(ncidistartedgestrideimapvalue);
#7412                    err = nc_get_varm_double(ncid,i,NULL,NULL,NULL,NULL,value);
#7414                    err = nc_get_varm_double(ncid,i,index,count,stride,imap,value);
#7432     IF (!equal(value[j],expect[j],var_type[i], NCT_DOUBLE)){
#7440                                    error("got: %g", (double) value[j]);
#7486    ushort value[MAX_NELS];
#7502        err = nc_get_varm_ushort(BAD_IDistartedgestrideimapvalue);
#7505        err = nc_get_varm_ushort(ncidBAD_VARIDstartedgestrideimapvalue);
#7510            err = nc_get_varm_ushort(ncidistartedgestrideimapvalue);
#7519            err = nc_get_varm_ushort(ncidistartedgestrideimapvalue);
#7524            err = nc_get_varm_ushort(ncidistartedgestrideimapvalue);
#7594                    err = nc_get_varm_ushort(ncid,i,NULL,NULL,NULL,NULL,value);
#7596                    err = nc_get_varm_ushort(ncid,i,index,count,stride,imap,value);
#7614     IF (!equal(value[j],expect[j],var_type[i], NCT_USHORT)){
#7622                                    error("got: %g", (double) value[j]);
#7668    uint value[MAX_NELS];
#7684        err = nc_get_varm_uint(BAD_IDistartedgestrideimapvalue);
#7687        err = nc_get_varm_uint(ncidBAD_VARIDstartedgestrideimapvalue);
#7692            err = nc_get_varm_uint(ncidistartedgestrideimapvalue);
#7701            err = nc_get_varm_uint(ncidistartedgestrideimapvalue);
#7706            err = nc_get_varm_uint(ncidistartedgestrideimapvalue);
#7776                    err = nc_get_varm_uint(ncid,i,NULL,NULL,NULL,NULL,value);
#7778                    err = nc_get_varm_uint(ncid,i,index,count,stride,imap,value);
#7796     IF (!equal(value[j],expect[j],var_type[i], NCT_UINT)){
#7804                                    error("got: %g", (double) value[j]);
#7850    longlong value[MAX_NELS];
#7866        err = nc_get_varm_longlong(BAD_IDistartedgestrideimapvalue);
#7869        err = nc_get_varm_longlong(ncidBAD_VARIDstartedgestrideimapvalue);
#7874            err = nc_get_varm_longlong(ncidistartedgestrideimapvalue);
#7883            err = nc_get_varm_longlong(ncidistartedgestrideimapvalue);
#7888            err = nc_get_varm_longlong(ncidistartedgestrideimapvalue);
#7958                    err = nc_get_varm_longlong(ncid,i,NULL,NULL,NULL,NULL,value);
#7960                    err = nc_get_varm_longlong(ncid,i,index,count,stride,imap,value);
#7978     IF (!equal(value[j],expect[j],var_type[i], NCT_LONGLONG)){
#7986                                    error("got: %g", (double) value[j]);
#8032    ulonglong value[MAX_NELS];
#8048        err = nc_get_varm_ulonglong(BAD_IDistartedgestrideimapvalue);
#8051        err = nc_get_varm_ulonglong(ncidBAD_VARIDstartedgestrideimapvalue);
#8056            err = nc_get_varm_ulonglong(ncidistartedgestrideimapvalue);
#8065            err = nc_get_varm_ulonglong(ncidistartedgestrideimapvalue);
#8070            err = nc_get_varm_ulonglong(ncidistartedgestrideimapvalue);
#8140                    err = nc_get_varm_ulonglong(ncid,i,NULL,NULL,NULL,NULL,value);
#8142                    err = nc_get_varm_ulonglong(ncid,i,index,count,stride,imap,value);
#8160     IF (!equal(value[j],expect[j],var_type[i], NCT_ULONGLONG)){
#8168                                    error("got: %g", (double) value[j]);
#8202    text value[MAX_NELS];
#8213     err = nc_get_att_text(BAD_IDiATT_NAME(i,j), value);
#8216     err = nc_get_att_text(ncidBAD_VARIDATT_NAME(i,j), value);
#8219     err = nc_get_att_text(ncidi, "noSuch", value);
#8232     err = nc_get_att_text(ncidiATT_NAME(i,j), value);
#8249 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_TEXT)){
#8257                                error("got: %g", (double) value[k]);
#8288    uchar value[MAX_NELS];
#8299     err = nc_get_att_uchar(BAD_IDiATT_NAME(i,j), value);
#8302     err = nc_get_att_uchar(ncidBAD_VARIDATT_NAME(i,j), value);
#8305     err = nc_get_att_uchar(ncidi, "noSuch", value);
#8318     err = nc_get_att_uchar(ncidiATT_NAME(i,j), value);
#8335 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_UCHAR)){
#8343                                error("got: %g", (double) value[k]);
#8374    schar value[MAX_NELS];
#8385     err = nc_get_att_schar(BAD_IDiATT_NAME(i,j), value);
#8388     err = nc_get_att_schar(ncidBAD_VARIDATT_NAME(i,j), value);
#8391     err = nc_get_att_schar(ncidi, "noSuch", value);
#8404     err = nc_get_att_schar(ncidiATT_NAME(i,j), value);
#8421 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_SCHAR)){
#8429                                error("got: %g", (double) value[k]);
#8460    short value[MAX_NELS];
#8471     err = nc_get_att_short(BAD_IDiATT_NAME(i,j), value);
#8474     err = nc_get_att_short(ncidBAD_VARIDATT_NAME(i,j), value);
#8477     err = nc_get_att_short(ncidi, "noSuch", value);
#8490     err = nc_get_att_short(ncidiATT_NAME(i,j), value);
#8507 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_SHORT)){
#8515                                error("got: %g", (double) value[k]);
#8546    int value[MAX_NELS];
#8557     err = nc_get_att_int(BAD_IDiATT_NAME(i,j), value);
#8560     err = nc_get_att_int(ncidBAD_VARIDATT_NAME(i,j), value);
#8563     err = nc_get_att_int(ncidi, "noSuch", value);
#8576     err = nc_get_att_int(ncidiATT_NAME(i,j), value);
#8593 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_INT)){
#8601                                error("got: %g", (double) value[k]);
#8632    long value[MAX_NELS];
#8643     err = nc_get_att_long(BAD_IDiATT_NAME(i,j), value);
#8646     err = nc_get_att_long(ncidBAD_VARIDATT_NAME(i,j), value);
#8649     err = nc_get_att_long(ncidi, "noSuch", value);
#8662     err = nc_get_att_long(ncidiATT_NAME(i,j), value);
#8679 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_LONG)){
#8687                                error("got: %g", (double) value[k]);
#8718    float value[MAX_NELS];
#8729     err = nc_get_att_float(BAD_IDiATT_NAME(i,j), value);
#8732     err = nc_get_att_float(ncidBAD_VARIDATT_NAME(i,j), value);
#8735     err = nc_get_att_float(ncidi, "noSuch", value);
#8748     err = nc_get_att_float(ncidiATT_NAME(i,j), value);
#8765 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_FLOAT)){
#8773                                error("got: %g", (double) value[k]);
#8804    double value[MAX_NELS];
#8815     err = nc_get_att_double(BAD_IDiATT_NAME(i,j), value);
#8818     err = nc_get_att_double(ncidBAD_VARIDATT_NAME(i,j), value);
#8821     err = nc_get_att_double(ncidi, "noSuch", value);
#8834     err = nc_get_att_double(ncidiATT_NAME(i,j), value);
#8851 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_DOUBLE)){
#8859                                error("got: %g", (double) value[k]);
#8890    ushort value[MAX_NELS];
#8901     err = nc_get_att_ushort(BAD_IDiATT_NAME(i,j), value);
#8904     err = nc_get_att_ushort(ncidBAD_VARIDATT_NAME(i,j), value);
#8907     err = nc_get_att_ushort(ncidi, "noSuch", value);
#8920     err = nc_get_att_ushort(ncidiATT_NAME(i,j), value);
#8937 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_USHORT)){
#8945                                error("got: %g", (double) value[k]);
#8976    uint value[MAX_NELS];
#8987     err = nc_get_att_uint(BAD_IDiATT_NAME(i,j), value);
#8990     err = nc_get_att_uint(ncidBAD_VARIDATT_NAME(i,j), value);
#8993     err = nc_get_att_uint(ncidi, "noSuch", value);
#9006     err = nc_get_att_uint(ncidiATT_NAME(i,j), value);
#9023 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_UINT)){
#9031                                error("got: %g", (double) value[k]);
#9062    longlong value[MAX_NELS];
#9073     err = nc_get_att_longlong(BAD_IDiATT_NAME(i,j), value);
#9076     err = nc_get_att_longlong(ncidBAD_VARIDATT_NAME(i,j), value);
#9079     err = nc_get_att_longlong(ncidi, "noSuch", value);
#9092     err = nc_get_att_longlong(ncidiATT_NAME(i,j), value);
#9109 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_LONGLONG)){
#9117                                error("got: %g", (double) value[k]);
#9148    ulonglong value[MAX_NELS];
#9159     err = nc_get_att_ulonglong(BAD_IDiATT_NAME(i,j), value);
#9162     err = nc_get_att_ulonglong(ncidBAD_VARIDATT_NAME(i,j), value);
#9165     err = nc_get_att_ulonglong(ncidi, "noSuch", value);
#9178     err = nc_get_att_ulonglong(ncidiATT_NAME(i,j), value);
#9195 IF (!equal(value[k],expect[k],ATT_TYPE(i,j), NCT_ULONGLONG)){
#9203                                error("got: %g", (double) value[k]);
test_put.c#236    text value;
#274 err = nc_get_var1_text(ncidiindex, &value);
#280                            IF (!equal(value,expect,var_type[i],NCT_TEXT)) {
#290     error("got: %g", (double) value);
#320    uchar value;
#358 err = nc_get_var1_uchar(ncidiindex, &value);
#364                            IF (!equal(value,expect,var_type[i],NCT_UCHAR)) {
#374     error("got: %g", (double) value);
#404    schar value;
#442 err = nc_get_var1_schar(ncidiindex, &value);
#448                            IF (!equal(value,expect,var_type[i],NCT_SCHAR)) {
#458     error("got: %g", (double) value);
#488    short value;
#526 err = nc_get_var1_short(ncidiindex, &value);
#532                            IF (!equal(value,expect,var_type[i],NCT_SHORT)) {
#542     error("got: %g", (double) value);
#572    int value;
#610 err = nc_get_var1_int(ncidiindex, &value);
#616                            IF (!equal(value,expect,var_type[i],NCT_INT)) {
#626     error("got: %g", (double) value);
#656    long value;
#694 err = nc_get_var1_long(ncidiindex, &value);
#700                            IF (!equal(value,expect,var_type[i],NCT_LONG)) {
#710     error("got: %g", (double) value);
#740    float value;
#778 err = nc_get_var1_float(ncidiindex, &value);
#784                            IF (!equal(value,expect,var_type[i],NCT_FLOAT)) {
#794     error("got: %g", (double) value);
#824    double value;
#862 err = nc_get_var1_double(ncidiindex, &value);
#868                            IF (!equal(value,expect,var_type[i],NCT_DOUBLE)) {
#878     error("got: %g", (double) value);
#908    ushort value;
#946 err = nc_get_var1_ushort(ncidiindex, &value);
#952                            IF (!equal(value,expect,var_type[i],NCT_USHORT)) {
#962     error("got: %g", (double) value);
#992    uint value;
#1030 err = nc_get_var1_uint(ncidiindex, &value);
#1036                            IF (!equal(value,expect,var_type[i],NCT_UINT)) {
#1046     error("got: %g", (double) value);
#1076    longlong value;
#1114 err = nc_get_var1_longlong(ncidiindex, &value);
#1120                            IF (!equal(value,expect,var_type[i],NCT_LONGLONG)) {
#1130     error("got: %g", (double) value);
#1160    ulonglong value;
#1198 err = nc_get_var1_ulonglong(ncidiindex, &value);
#1204                            IF (!equal(value,expect,var_type[i],NCT_ULONGLONG)) {
#1214     error("got: %g", (double) value);
#1246    text value[MAX_NELS];
#1276 err = nc_get_att_text(ncidiATT_NAME(i,j), value);
#1287                        IF (!equal(value[k],expect[k],datatype,NCT_TEXT)) {
#1295                                error("got: %g", (double) value[k]);
#1321    uchar value[MAX_NELS];
#1351 err = nc_get_att_uchar(ncidiATT_NAME(i,j), value);
#1362                        IF (!equal(value[k],expect[k],datatype,NCT_UCHAR)) {
#1370                                error("got: %g", (double) value[k]);
#1396    schar value[MAX_NELS];
#1426 err = nc_get_att_schar(ncidiATT_NAME(i,j), value);
#1437                        IF (!equal(value[k],expect[k],datatype,NCT_SCHAR)) {
#1445                                error("got: %g", (double) value[k]);
#1471    short value[MAX_NELS];
#1501 err = nc_get_att_short(ncidiATT_NAME(i,j), value);
#1512                        IF (!equal(value[k],expect[k],datatype,NCT_SHORT)) {
#1520                                error("got: %g", (double) value[k]);
#1546    int value[MAX_NELS];
#1576 err = nc_get_att_int(ncidiATT_NAME(i,j), value);
#1587                        IF (!equal(value[k],expect[k],datatype,NCT_INT)) {
#1595                                error("got: %g", (double) value[k]);
#1621    long value[MAX_NELS];
#1651 err = nc_get_att_long(ncidiATT_NAME(i,j), value);
#1662                        IF (!equal(value[k],expect[k],datatype,NCT_LONG)) {
#1670                                error("got: %g", (double) value[k]);
#1696    float value[MAX_NELS];
#1726 err = nc_get_att_float(ncidiATT_NAME(i,j), value);
#1737                        IF (!equal(value[k],expect[k],datatype,NCT_FLOAT)) {
#1745                                error("got: %g", (double) value[k]);
#1771    double value[MAX_NELS];
#1801 err = nc_get_att_double(ncidiATT_NAME(i,j), value);
#1812                        IF (!equal(value[k],expect[k],datatype,NCT_DOUBLE)) {
#1820                                error("got: %g", (double) value[k]);
#1846    ushort value[MAX_NELS];
#1876 err = nc_get_att_ushort(ncidiATT_NAME(i,j), value);
#1887                        IF (!equal(value[k],expect[k],datatype,NCT_USHORT)) {
#1895                                error("got: %g", (double) value[k]);
#1921    uint value[MAX_NELS];
#1951 err = nc_get_att_uint(ncidiATT_NAME(i,j), value);
#1962                        IF (!equal(value[k],expect[k],datatype,NCT_UINT)) {
#1970                                error("got: %g", (double) value[k]);
#1996    longlong value[MAX_NELS];
#2026 err = nc_get_att_longlong(ncidiATT_NAME(i,j), value);
#2037                        IF (!equal(value[k],expect[k],datatype,NCT_LONGLONG)) {
#2045                                error("got: %g", (double) value[k]);
#2071    ulonglong value[MAX_NELS];
#2101 err = nc_get_att_ulonglong(ncidiATT_NAME(i,j), value);
#2112                        IF (!equal(value[k],expect[k],datatype,NCT_ULONGLONG)) {
#2120                                error("got: %g", (double) value[k]);
#2146    text value = 5; /* any value would do - only for error cases */
#2177        err = nc_put_var1_text(BAD_IDiindex, &value);
#2180        err = nc_put_var1_text(ncidBAD_VARIDindex, &value);
#2186 err = nc_put_var1_text(ncidiindex, &value);
#2196            value = hash_textvar_type[i], var_rank[i], indexNCT_TEXT);
#2198 err = nc_put_var1_text(ncidiNULL, &value);
#2200 err = nc_put_var1_text(ncidiindex, &value);
#2202 if (inRange3(valuevar_type[i],NCT_TEXT)) {
#2210 (double)value, (long)value);
#2240    uchar value = 5; /* any value would do - only for error cases */
#2271        err = nc_put_var1_uchar(BAD_IDiindex, &value);
#2274        err = nc_put_var1_uchar(ncidBAD_VARIDindex, &value);
#2280 err = nc_put_var1_uchar(ncidiindex, &value);
#2290            value = hash_ucharvar_type[i], var_rank[i], indexNCT_UCHAR);
#2292 err = nc_put_var1_uchar(ncidiNULL, &value);
#2294 err = nc_put_var1_uchar(ncidiindex, &value);
#2296 if (inRange3(valuevar_type[i],NCT_UCHAR)) {
#2304 (double)value, (long)value);
#2334    schar value = 5; /* any value would do - only for error cases */
#2365        err = nc_put_var1_schar(BAD_IDiindex, &value);
#2368        err = nc_put_var1_schar(ncidBAD_VARIDindex, &value);
#2374 err = nc_put_var1_schar(ncidiindex, &value);
#2384            value = hash_scharvar_type[i], var_rank[i], indexNCT_SCHAR);
#2386 err = nc_put_var1_schar(ncidiNULL, &value);
#2388 err = nc_put_var1_schar(ncidiindex, &value);
#2390 if (inRange3(valuevar_type[i],NCT_SCHAR)) {
#2398 (double)value, (long)value);
#2428    short value = 5; /* any value would do - only for error cases */
#2459        err = nc_put_var1_short(BAD_IDiindex, &value);
#2462        err = nc_put_var1_short(ncidBAD_VARIDindex, &value);
#2468 err = nc_put_var1_short(ncidiindex, &value);
#2478            value = hash_shortvar_type[i], var_rank[i], indexNCT_SHORT);
#2480 err = nc_put_var1_short(ncidiNULL, &value);
#2482 err = nc_put_var1_short(