bindata.c#32    if(con->nctype != NC_ECONST) {
#35    switch (con->nctype) {
#96    default: PANIC1("bin_constant: unexpected type: %d",con->nctype);
cache.c#410 if(var->nctype != NC_Atomic)
cdata.c#36    switch (con->nctype) {
#112    default: PANIC1("ncstype: bad type code: %d",con->nctype);
cdf.c#59 switch (node->nctype) {
#87 if(node->nctype == NC_Atomic)
#225 if(node->nctype == NC_Grid || node->nctype == NC_Dataset)
#315    } else if(node->nctype == NC_Sequence) {
#480                if(subtemp->nctype == NC_Grid) {
#530    ASSERT((patterngrid->nctype == NC_Grid));
#620 fprintf(stderr,"fullnode.subnode[%d]: (%d) %s\n",i,n->nctype,n->ocname);
#624 fprintf(stderr,"connode.subnode[%d]: (%d) %s\n",i,n->nctype,n->ocname);
#852 if(subnode->nctype == NC_Dimension) continue; /*ignore*/
#893 if(subnode->nctype == NC_Dimension) continue; /*ignore*/
#922    node->nctype = octypetonc(octype);
#932    else if(node->nctype == NC_Dataset)
#1146       && node1->nctype == NC_Dataset) return 1;
#1154    if(node1->nctype != node2->nctype) {
#1156 int structgrid = ((node1->nctype == NC_Grid && node2->nctype == NC_Structure)
#1157                          || (node1->nctype == NC_Structure && node2->nctype == NC_Grid) ? 1 : 0);
#1162    if(node1->nctype == NC_Atomic && node1->etype != node2->etype)
#1173    if(node->nctype == NC_Dimension && node->ocname == NULL) return NC_NOERR;
#1181    if(node->nctype == NC_Atomic)
constraints.c#255 if(node->nctype != NC_Sequence
#256               && node->nctype != NC_Structure
#257               && node->nctype != NC_Grid
#258               && node->nctype != NC_Atomic
#365     if(node->nctype == NC_Sequence)
#636    return (node->nctype == NC_Dataset
#637               || node->nctype == NC_Sequence
#638               || node->nctype == NC_Structure
#639               || node->nctype == NC_Grid);
cvt.c#29    if(src->nctype == NC_FILLVALUE) {
#30 if(dst->nctype != NC_FILLVALUE) {
#37    if(src->nctype == NC_ECONST) {
#38 if(dst->nctype == NC_ECONST) {
#46    } else if(dst->nctype == NC_ECONST) {
#52    if(src->nctype == NC_OPAQUE) {
#57 switch (CASE(src->nctype,dst->nctype)) {
#559 nctypename(src->nctype),src->nctype,
#560 nctypename(dst->nctype),dst->nctype);
#575    ASSERT(isprimplus(prim->nctype));
#576    if(prim->nctype == NC_STRING) {
#592    } else if(prim->nctype == NC_OPAQUE) {
#628 con.nctype = NC_CHAR;
dapalign.c#94ncctypealignment(int nctype)
#99    switch (nctype) {
#116 PANIC1("nctypealignment: bad type code: %d",nctype);
dapalign.h#52extern unsigned int ncctypealignment(int nctype);
dapdump.c#45 nc_type nctype;
#52 stat = nc_inq_att(hdr->ncid,NC_GLOBAL,att->name,&nctype,&nvalues);
#54 att->etype = nctypetodap(nctype);
#59 if(nctype == NC_CHAR) {
#97 nc_type nctype;
#102   &nctype,
#107 var->nctype = (nctype);
#111 nctypetostring(var->nctype),
#125     nc_type nctype;
#130     stat = nc_inq_att(hdr->ncid,var->varid,att->name,&nctype,&nvalues);
#132     att->etype = nctypetodap(nctype);
#152dumpdata1(nc_type nctype, size_t index, char* data)
#154    switch (nctype) {
#186 fprintf(stdout,"Unknown type: %i",nctype);
#289 if(root->nctype == NC_Grid) {
#315    switch (root->nctype) {
#400    char* nctype = NULL;
#404    switch (node->nctype) {
#405    case NC_Datasetnctype = "Dataset"; break;
#406    case NC_Sequencenctype = "Sequence"; break;
#407    case NC_Structurenctype = "Structure"; break;
#408    case NC_Gridnctype = "Grid"; break;
#429 (nctype?nctype:primtype),node->ocname);
dapdump.h#19    nc_type nctype;
#42extern void dumpdata1(nc_type nctype, size_t index, char* data);
#55extern void dumpdata1(nc_type nctype, size_t index, char* data);
daputil.c#88nctypeconvert(NCDAPCOMMONdrnonc_type nctype)
#93 switch (nctype) {
#111 switch (nctype) {
#160nctypetodap(nc_type nctype)
#162    switch (nctype) {
#181nctypesizeof(nc_type nctype)
#183    switch (nctype) {
#202nctypetostring(nc_type nctype)
#204    switch (nctype) {
#349 if(!withdataset && node->nctype == NC_Dataset) break;
#432         if(node->nctype != NC_Dataset) {
#464    if(node->nctype != NC_Dataset)
#466    if(node->nctype != NC_Dataset || withdataset)
#500    for(node=node->container;node->nctype != NC_Dataset;node=node->container) {
#501       if(node->nctype == NC_Sequence) return TRUE;
#511    for(node=node->container;node->nctype != NC_Dataset;node=node->container) {
#512       if(node->nctype == NC_Structure
#524       && node->container->nctype == NC_Grid) {
#536       && node->container->nctype == NC_Grid) {
#554    if(grid == NULL || grid->nctype != NC_Grid) return FALSE;
#562    if(seq == NULL || seq->nctype != NC_Sequence) return FALSE;
#571       || node->container->nctype != NC_Dataset) return FALSE;
data.c#55istype(Datasrcdatasrc , nc_type nctype)
#58    if(ci != NULL && ci->nctype == nctype) return 1;
#63isstringable(nc_type nctype)
#65    switch (nctype) {
#126    con.nctype = NC_COMPOUND;
#202    ASSERT(con->nctype == NC_COMPOUND);
#242    if(ds->data[ds->index].nctype != NC_FILLVALUEPANIC("srcsetfill: not fill");
#243    ds->data[ds->index].nctype = NC_COMPOUND;
#275    switch (newcon.nctype) {
#449    if(prim->nctype == NC_ECONST)
#451    else if(usingclassic && prim->nctype == NC_STRING)
#453    else if(prim->nctype == NC_CHAR)
#456        alignment = nctypealignment(prim->nctype);
#652    c->nctype = NC_COMPOUND;
#663    c->nctype = NC_STRING;
#739  d.nctype = NC_COMPOUND;
data.h#52    nc_type    nctype; /* NC_INT,... */
#115int isstringable(nc_type nctype);
#128#define islistconst(con) ((con)!=NULL && (con)->nctype == NC_COMPOUND)
#129#define isfillconst(con) ((con)!=NULL && (con)->nctype == NC_FILLVALUE)
#131#define consttype(con) (con==NULL?NC_NAT:(con)->nctype)
#133#define isnilconst(con) ((con)!=NULL && (con)->nctype == NC_NIL)
dump.c#60       switch (dp->nctype) {
#77     if(isprimplus(dp->nctype) || dp->nctype == NC_FILLVALUE) {
#82         sprintf(tmp,"?%d? ",dp->nctype);
#94    ASSERT(isprimplus(ci->nctype) || ci->nctype == NC_FILLVALUE);
#95    switch (ci->nctype) {
#158    default: PANIC1("dumpdataprim: bad type code:%d",ci->nctype);
#191    switch (con->nctype) {
f77data.c#35    switch (ci->nctype) {
#71    default: PANIC1("f77data: bad type code: %d",ci->nctype);
genc.c#523nctype(nc_type type)
#586ncstype(nc_type nctype)
#588    switch (nctype) {
#614 derror("ncstype: bad type code: %d",nctype);
#650 return nctype(tsym->typ.typecode);
#807 nctype(tsym->typ.basetype->typ.typecode),
genchar.c#98        if(isstringable(c->nctype)) {
#144        if(isstringable(c->nctype)) {
#159    switch (con->nctype) {
#191        if(ccon->nctype == NC_CHAR) {
#193        } else if(ccon->nctype == NC_STRING) {
#310        if(isstringable(c->nctype)) {
#342    con->nctype = NC_STRING;
generate.c#268            if(con == NULL || con->nctype == NC_FILL) {
#356            if(con->nctype != NC_COMPOUND) {
#445    ASSERT(prim->nctype==NC_OPAQUE);
#476    ASSERT((prim->nctype != NC_COMPOUND));
#480    switch (prim->nctype) {
#524    target.nctype = basetype->typ.typecode;
#526    if(target.nctype != NC_ECONST) {
#530    switch (target.nctype) {
genf77.c#28static const char* nfstype(nc_type nctype);
#30static const char* nfstype(nc_type nctype);
#172 nc_type nctype;
#174 for(nctype=0;nctype<=NC_DOUBLE;nctype++) {pertypesizes[nctype] = 0;}
#198 for(nctype=NC_BYTE;nctype <= NC_DOUBLE;nctype++) {
#200            if(nctype == NC_FLOATbasetype = "real";
#201            else if(nctype == NC_DOUBLEbasetype = "double precision";
#202     if(pertypesizes[nctype] > 0) {
#204 basetypencftype(nctype),
#205 pertypesizes[nctype]);
#646nfstype(nc_type nctype)
#648    switch (nctype) {
#662 derror("ncstype: bad type code: %d",nctype);
genj.c#355jstype(nc_type nctype)
#357    switch (nctype) {
#387 derror("ncstype: bad type code: %d",nctype);
genlib.c#375 nctype(vars[ivar].type),
#383 nctype(vars[ivar].type),
#427 nctype(atts[iatt].type),
#900nctype(
genlib.h#84extern Symbolbasetypefor(nc_type nctype);/* Convert nctype to a Symbol*/
#125extern const char* nctype(nc_type type);
genlib.h#25extern const char* nctype ( nc_type  type );
getfill.c#60        con.nctype = tsym->typ.typecode;
#94        con.nctype = tsym->typ.typecode;
#154    switch(value->nctype) {
#178 derror("nc_getfill: unrecognized type: %d",value->nctype);
#183nc_dfaltfillname(nc_type nctype)
#185    switch (nctype) {
getvara.c#137           && node->nctype == NC_Atomic
#512        xnode->nctypedepth,dimindex,oc_data_modestring(mode));
#517    switch (xnode->nctype) {
#1094    gridable = (patternpathnext->nctype == NC_Grid && depth+2 < plen);
#1102        } else if(gridable && xsubnode->nctype == NC_Atomic) {
#1246           && node->nctype == NC_Atomic
jdata.c#36    switch (con->nctype) {
#90    default: PANIC1("ncstype: bad type code: %d",con->nctype);
main.c#586    fillconstant.nctype = NC_FILLVALUE;
ncaux.c#299nctypealignment(nc_type nctype)
#303    switch (nctype) {
nccommon.h#248    nc_type          nctype;     /* e.g. var, dimension  */
ncd2dispatch.c#839     if(dim->nctype != NC_Dimension) continue;
#976    switch (node->nctype) {
#1285 if(var->nctype != NC_Sequence) continue;
#1523     if(container->nctype == NC_Dataset) break;
#1524     if(container->nctype != NC_Structure
#1692    ASSERT((xseq->nctype == NC_Sequence));
#1716 if(current->nctype == NC_Structure
#1717    || current->nctype == NC_Dataset) {
#1731 } else if(current->nctype ==  NC_Sequence) {
#1812    ASSERT(seq->nctype == NC_Sequence);
#1878    ASSERT(candidate->nctype == NC_Atomic && newchoice->nctype == NC_Atomic);
#1910        if(subnode->nctype == NC_Structure || subnode->nctype == NC_Grid)
#1912 else if(subnode->nctype == NC_Atomic)
#2119 if(node->nctype == NC_Sequence
ncgentab.c#2117       nctype(valtype));
ncgeny.c#336int            nctype; /* for tracking attribute list type*/
#3009makeprimitivetype(nc_type nctype)
#3011    Symbolsym = install(primtypenames[nctype]);
#3014    sym->ncid = nctype;
#3015    sym->typ.typecode = nctype;
#3016    sym->typ.size = ncsize(nctype);
#3018    sym->typ.alignment = nctypealignment(nctype);
#3081makeconstdata(nc_type nctype)
#3084    consttype = nctype;
#3085    con.nctype = nctype;
#3088    switch (nctype) {
#3136     nctypename(nctype));
#3150    con.nctype = NC_ECONST;
#3194basetypefor(nc_type nctype)
#3196    return primsymbols[nctype];
#3202    if(con->nctype == NC_STRING) {
#3264 iconst.nctype = (con->nctype == NC_STRING?NC_STRING:NC_INT);
#3272 iconst.nctype = NC_STRING;
#3274 if(iconst.nctype == NC_STRING)
#3281 iconst.nctype = NC_INT;
#3283 if(iconst.nctype == NC_INT)
#3387                    iconst.nctype = NC_INT;
#3389                    if(iconst.nctype == NC_INT) {
#3441    switch (con.nctype) {
#3450 derror("Not a signed integer type: %d",con.nctype);
#3463     if(con->nctype == NC_COMPOUND) {
#3465     } else if(con->nctype == NC_FILLVALUE) return 1;
#3525        result.nctype = NC_DOUBLE;
#3530     if(arglist->data[1].nctype != NC_STRING) {
#3536     if(arglist->data[0].nctype != NC_STRING) {
ncgeny.h#158int            nctype; /* for tracking attribute list type*/
ocdump.c#29static void dumpattvalue(OCtype nctype, char** aset, int index);
#201dumpattvalue(OCtype nctype, char** strings, int index)
#203    if(nctype == OC_String || nctype == OC_URL) {
offsets.c#109nctypealignment(nc_type nctype)
#113    switch (nctype) {
#129 fprintf(stderr,"nctypealignment: bad type code: %d",nctype);
offsets.h#59extern unsigned int nctypealignment(nc_type nctype);
semantics.c#410     newec.nctype = esym->typ.typecode;
#444 if(con->nctype == NC_COMPOUND) {
#447 } else if(con->nctype == NC_ECONST) {
#825 if(con->nctype > NC_MAX_ATOMIC_TYPE) { /* illegal */
#838 if(con->nctype == NC_STRINGstringcount++;
#839 else if(con->nctype == NC_CHARcharcount++;
#853 if(con->nctype == NC_FLOATforcefloat = 1;
#854 else if(con->nctype == NC_DOUBLE) {forcedouble=1; break;}
#866 if(con->nctype != NC_UINT64) continue;
#877 switch (con->nctype) {
#889 result = infertype(result,con->nctype,hasneg);
#900    nc_type nctype;
#909    nctype = inferattributetype1(src);
#911    if(nctype == NC_NAT) { /* Illegal attribute value list */
#917    if(nctype == NC_STRING)
#922 switch (nctype) {
#925     nctype = NC_INT;
#930 asym->typ.basetype = basetypefor(nctype);
#932 asym->typ.basetype = basetypefor(nctype);
#1114     if(con->nctype != NC_COMPOUND) {
#1126 switch (con->nctype) {
#1137     semwarn(datalistline(data),"Illegal character constant: %d",con->nctype);
#1184         if(con->nctype != NC_COMPOUND)
util.c#158nctypename(nc_type nctype)
#161    if(nctype >= NC_NAT && nctype <= NC_COMPOUND)
#162 return nctypenames[nctype];
#163    if(nctype >= NC_GRP && nctype <= NC_PRIM)
#164 return nctypenamesextend[(nctype - NC_GRP)];
#165    if(nctype == NC_FILLVALUE) return "NC_FILL";
#166    if(nctype == NC_NIL) return "NC_NIL";
#168    sprintf(s,"NC_<%d>",nctype);
#205ncsize(nc_type nctype)
#207    if(nctype >= NC_NAT && nctype <= NC_COMPOUND)
#208 return ncsizes[nctype];
#258signedtype(nc_type nctype)
#260    switch (nctype) {
#265 return nctype;
#272    return nctype;
#276unsignedtype(nc_type nctype)
#278    switch (nctype) {
#283 return nctype;
#290    return nctype;
#294isinttype(nc_type nctype)
#296    return (nctype != NC_CHAR)
#297            && ((nctype >= NC_BYTE && nctype <= NC_INT)
#298         || (nctype >= NC_UBYTE && nctype <= NC_UINT64));
#311isfloattype(nc_type nctype)
#313    return (nctype == NC_FLOAT || nctype <= NC_DOUBLE);
#317isclassicprim(nc_type nctype)
#319    return    (nctype >= NC_BYTE && nctype <= NC_DOUBLE)
#324isclassicprimplus(nc_type nctype)
#326    return    (nctype >= NC_BYTE && nctype <= NC_DOUBLE)
#327    || (nctype == NC_STRING)
#332isprim(nc_type nctype)
#334    return    (nctype >= NC_BYTE && nctype <= NC_STRING)
#339isprimplus(nc_type nctype)
#341    return    (nctype >= NC_BYTE && nctype <= NC_STRING)
#342    || (nctype == NC_ECONST)
#343    || (nctype == NC_OPAQUE)
#537    switch(con->nctype) {
util.h#29extern nc_type signedtype(nc_type nctype);
#30extern nc_type unsignedtype(nc_type nctype);
#33extern int isinttype(nc_type nctype); /* some kind of integer*/
#34extern int isuinttype(nc_type nctype); /* some kind of integer*/
#35extern int isfloattype(nc_type nctype); /* some kind of float*/


HyperKWIC - Version 7.20DA executed at 11:37 on 27 Oct 2017 | Polyhedron Solutions - INTERNAL USE | COMMERCIAL (Any O/S) SN 4AKIed