NCerror freeNCDAPCOMMON(NCDAPCOMMON* dapcomm) { /* abort the metadata file */ (void)nc_abort(getncid(dapcomm)); freenccache(dapcomm,dapcomm->cdf.cache); nclistfree(dapcomm->cdf.projectedvars); nullfree(dapcomm->cdf.recorddimname); /* free the trees */ freecdfroot34(dapcomm->cdf.ddsroot); dapcomm->cdf.ddsroot = NULL; freecdfroot34(dapcomm->cdf.fullddsroot); dapcomm->cdf.fullddsroot = NULL; if(dapcomm->oc.ocdasroot != NULL) oc_root_free(dapcomm->oc.conn,dapcomm->oc.ocdasroot); dapcomm->oc.ocdasroot = NULL; oc_close(dapcomm->oc.conn); /* also reclaims remaining OC trees */ ncurifree(dapcomm->oc.url); nullfree(dapcomm->oc.urltext); nullfree(dapcomm->oc.rawurltext); dcefree((DCEnode*)dapcomm->oc.dapconstraint); dapcomm->oc.dapconstraint = NULL; free(dapcomm); return NC_NOERR; }
static bool match(UChar **items, int32_t *item_lengths, uint32_t item_count, UChar *needle, Match *match_results, int32_t *final_positions, int32_t needle_char_len, UChar *level1, UChar *level2, UChar *level3) { Stack stack = {0}; int32_t i = 0, maxhl = 0; int32_t r = 0, *positions = NULL; MatchInfo *matches = NULL; bool ok = FALSE; MemoryItem ***memo = NULL; int32_t needle_len = u_strlen(needle); if (needle_len <= 0 || item_count <= 0) { for (i = 0; i < (int32_t)item_count; i++) match_results[i].score = 0.0; ok = TRUE; goto end; } matches = (MatchInfo*)calloc(item_count, sizeof(MatchInfo)); positions = (int32_t*)calloc(2*needle_len, sizeof(int32_t)); // One set of positions is the final answer and one set is working space if (matches == NULL || positions == NULL) {PyErr_NoMemory(); goto end;} for (i = 0; i < (int32_t)item_count; i++) { matches[i].haystack = items[i]; matches[i].haystack_len = item_lengths[i]; matches[i].needle = needle; matches[i].needle_len = needle_len; matches[i].max_score_per_char = (1.0 / matches[i].haystack_len + 1.0 / needle_len) / 2.0; matches[i].level1 = level1; matches[i].level2 = level2; matches[i].level3 = level3; maxhl = MAX(maxhl, matches[i].haystack_len); } if (maxhl <= 0) { for (i = 0; i < (int32_t)item_count; i++) match_results[i].score = 0.0; ok = TRUE; goto end; } alloc_stack(&stack, needle_len, maxhl); memo = alloc_memory(needle_len, maxhl); if (stack.items == NULL || memo == NULL) {PyErr_NoMemory(); goto end;} for (i = 0; i < (int32_t)item_count; i++) { for (r = 0; r < needle_len; r++) { positions[r] = -1; } stack_clear(&stack); clear_memory(memo, needle_len, matches[i].haystack_len); matches[i].memo = memo; match_results[i].score = process_item(&matches[i], &stack, positions); convert_positions(positions, final_positions + i, matches[i].haystack, needle_char_len, needle_len, match_results[i].score); } ok = TRUE; end: nullfree(positions); nullfree(stack.items); nullfree(matches); nullfree(memo); return ok; }
static void freestringvec(char** list) { if(list != NULL) { char** p; for(p=list;*p;p++) {nullfree(*p);} nullfree(list); } }
int NCDISPATCH_finalize(void) { int status = NC_NOERR; nullfree(ncrc_globalstate.tempdir); nullfree(ncrc_globalstate.home); NC_rcclear(&ncrc_globalstate.rcinfo); memset(&ncrc_globalstate,0,sizeof(NCRCglobalstate)); return status; }
/* Free up a single node, but not any nodes it points to. */ static void free1cdfnode(CDFnode* node) { unsigned int j,k; if(node == NULL) return; nullfree(node->ocname); nullfree(node->ncbasename); nullfree(node->ncfullname); if(node->attributes != NULL) { for(j=0;j<nclistlength(node->attributes);j++) { NCattribute* att = (NCattribute*)nclistget(node->attributes,j); nullfree(att->name); for(k=0;k<nclistlength(att->values);k++) nullfree((char*)nclistget(att->values,k)); nclistfree(att->values); nullfree(att); } } nullfree(node->dodsspecial.dimname); nclistfree(node->subnodes); nclistfree(node->attributes); nclistfree(node->array.dimsetplus); nclistfree(node->array.dimsetall); nclistfree(node->array.dimset0); nclistfree(node->array.dimsettrans); /* Clean up the ncdap4 fields also */ nullfree(node->typename); nullfree(node->vlenname); nullfree(node); }
// Matcher.calculate_scores {{{ static PyObject * Matcher_calculate_scores(Matcher *self, PyObject *args) { int32_t *final_positions = NULL, *p; Match *matches = NULL; bool ok = FALSE; uint32_t i = 0, needle_char_len = 0, j = 0; PyObject *items = NULL, *score = NULL, *positions = NULL, *pneedle = NULL; UChar *needle = NULL; if (!PyArg_ParseTuple(args, "O", &pneedle)) return NULL; needle = python_to_icu(pneedle, NULL); if (needle == NULL) return NULL; needle_char_len = u_countChar32(needle, -1); items = PyTuple_New(self->item_count); positions = PyTuple_New(self->item_count); matches = (Match*)calloc(self->item_count, sizeof(Match)); final_positions = (int32_t*) calloc(needle_char_len * self->item_count, sizeof(int32_t)); if (items == NULL || matches == NULL || final_positions == NULL || positions == NULL) {PyErr_NoMemory(); goto end;} for (i = 0; i < self->item_count; i++) { score = PyTuple_New(needle_char_len); if (score == NULL) { PyErr_NoMemory(); goto end; } PyTuple_SET_ITEM(positions, (Py_ssize_t)i, score); } Py_BEGIN_ALLOW_THREADS; ok = match(self->items, self->item_lengths, self->item_count, needle, matches, final_positions, needle_char_len, self->collator, self->level1, self->level2, self->level3); Py_END_ALLOW_THREADS; if (ok) { for (i = 0; i < self->item_count; i++) { score = PyFloat_FromDouble(matches[i].score); if (score == NULL) { PyErr_NoMemory(); goto end; } PyTuple_SET_ITEM(items, (Py_ssize_t)i, score); p = final_positions + (i * needle_char_len); for (j = 0; j < needle_char_len; j++) { score = PyLong_FromLong((long)p[j]); if (score == NULL) { PyErr_NoMemory(); goto end; } PyTuple_SET_ITEM(PyTuple_GET_ITEM(positions, (Py_ssize_t)i), (Py_ssize_t)j, score); } } } else { PyErr_NoMemory(); goto end; } end: nullfree(needle); nullfree(matches); nullfree(final_positions); if (PyErr_Occurred()) { Py_XDECREF(items); items = NULL; Py_XDECREF(positions); positions = NULL; return NULL; } return Py_BuildValue("NN", items, positions); } // }}}
static NCerror mapnodesr(CDFnode* connode, CDFnode* fullnode, int depth) { unsigned int i,j; NCerror ncstat = NC_NOERR; ASSERT((simplenodematch(connode,fullnode))); #ifdef DEBUG { char* path1 = makecdfpathstring(fullnode,"."); char* path2 = makecdfpathstring(connode,"."); fprintf(stderr,"mapnode: %s->%s\n",path1,path2); nullfree(path1); nullfree(path2); } #endif /* Map node */ mapfcn(connode,fullnode); #if 0 { int i; for(i=0;i<nclistlength(fullnode->subnodes);i++) { CDFnode* n = (CDFnode*)nclistget(fullnode->subnodes,i); fprintf(stderr,"fullnode.subnode[%d]: (%d) %s\n",i,n->nctype,n->ocname); } for(i=0;i<nclistlength(connode->subnodes);i++) { CDFnode* n = (CDFnode*)nclistget(connode->subnodes,i); fprintf(stderr,"connode.subnode[%d]: (%d) %s\n",i,n->nctype,n->ocname); } } #endif /* Try to match connode subnodes against fullnode subnodes */ ASSERT(nclistlength(connode->subnodes) <= nclistlength(fullnode->subnodes)); for(i=0;i<nclistlength(connode->subnodes);i++) { CDFnode* consubnode = (CDFnode*)nclistget(connode->subnodes,i); /* Search full subnodes for a matching subnode from con */ for(j=0;j<nclistlength(fullnode->subnodes);j++) { CDFnode* fullsubnode = (CDFnode*)nclistget(fullnode->subnodes,j); if(simplenodematch(fullsubnode,consubnode)) { ncstat = mapnodesr(consubnode,fullsubnode,depth+1); if(ncstat) goto done; } } } done: return THROW(ncstat); }
/* Exceptions: anonymous dimensions. */ static NCerror fix1node(NCDAPCOMMON* nccomm, CDFnode* node) { if(node->nctype == NC_Dimension && node->ocname == NULL) return NC_NOERR; ASSERT((node->ocname != NULL)); nullfree(node->ncbasename); node->ncbasename = cdflegalname(node->ocname); if(node->ncbasename == NULL) return NC_ENOMEM; nullfree(node->ncfullname); node->ncfullname = makecdfpathstring(node,nccomm->cdf.separator); if(node->ncfullname == NULL) return NC_ENOMEM; if(node->nctype == NC_Atomic) node->externaltype = nctypeconvert(nccomm,node->etype); return NC_NOERR; }
/* Replace the protocol */ int ncurisetprotocol(NCURI* duri,const char* protocol) { nullfree(duri->protocol); duri->protocol = strdup(protocol); return (NCU_OK); }
/* Parse a mode string at the commas nul terminate each tag */ static int parseurlmode(const char* modestr0, char** listp) { int stat = NC_NOERR; char* modestr = NULL; char* p = NULL; char* endp = NULL; /* Make modifiable copy */ if((modestr=strdup(modestr0)) == NULL) {stat=NC_ENOMEM; goto done;} /* Split modestr at the commas or EOL */ p = modestr; for(;;) { endp = strchr(p,','); if(endp == NULL) break; /* Null terminate each comma-separated string */ *endp++ = '\0'; p = endp; } if(listp) *listp = modestr; modestr = NULL; done: if(stat) {nullfree(modestr);} return stat; }
/* Parse url fragment for format etc. */ static int url_getmodel(const char* modestr, NCmode* model) { int stat = NC_NOERR; char* args = NULL; char* p = NULL; model->format = 0; model->implementation = 0; if((stat=parseurlmode(modestr,&args))) goto done; p = args; for(;*p;) { struct LEGALMODES* legal = legalmodes; while(legal->tag) { if(strcmp(legal->tag,p)==0) { if(model->format != 0 && legal->format != 0) {stat = NC_EINVAL; goto done;} if(model->implementation != 0 && legal->implementation != 0) {stat = NC_EINVAL; goto done;} if(model->iosp != 0 && legal->iosp != 0) {stat = NC_EINVAL; goto done;} if(legal->format != 0) model->format = legal->format; if(legal->implementation != 0) model->implementation = legal->implementation; if(legal->iosp != 0) model->iosp = legal->iosp; } } } done: nullfree(args); return stat; }
static int printAttribute(D4printer* out, NCD4node* attr, int depth) { int ret = NC_NOERR; int i = 0; char* fqn = NULL; INDENT(depth); CAT("<Attribute"); printXMLAttributeName(out,"name",attr->name); if(attr->basetype->subsort <= NC_MAX_ATOMIC_TYPE) printXMLAttributeName(out,"type",attr->basetype->name); else { printXMLAttributeName(out,"type",(fqn = NCD4_makeFQN(attr->basetype))); } CAT(">\n"); depth++; for(i=0;i<nclistlength(attr->attr.values);i++) { printValue(out,(const char*)nclistget(attr->attr.values,i),depth); CAT("\n"); } depth--; INDENT(depth); CAT("</Attribute>"); nullfree(fqn); return THROW(ret); }
/* Parse incoming url constraints, if any, to check for syntactic correctness */ NCerror parsedapconstraints(NCDAPCOMMON* dapcomm, char* constraints, DCEconstraint* dceconstraint) { NCerror ncstat = NC_NOERR; char* errmsg; ASSERT(dceconstraint != NULL); nclistclear(dceconstraint->projections); nclistclear(dceconstraint->selections); ncstat = dapceparse(constraints,dceconstraint,&errmsg); if(ncstat) { nclog(NCLOGWARN,"DCE constraint parse failure: %s",errmsg); nullfree(errmsg); nclistclear(dceconstraint->projections); nclistclear(dceconstraint->selections); } else { #ifdef IGNORE int i; #ifdef DEBUG NClist* allnodes; fprintf(stderr,"constraint: %s",dumpconstraint(dceconstraint)); #endif /* Go thru each node and add annotation */ allnodes = dceallnodes((DCEnode*)dceconstraint,CES_NIL); for(i=0;i<nclistlength(allnodes);i++) { DCEnode* node = (DCEnode*)nclistget(allnodes,i); } #endif } return ncstat; }
CDFnode* makecdfnode(NCDAPCOMMON* nccomm, char* ocname, OCtype octype, /*optional*/ OCddsnode ocnode, CDFnode* container) { CDFnode* node; assert(nccomm != NULL); node = (CDFnode*)calloc(1,sizeof(CDFnode)); if(node == NULL) return (CDFnode*)NULL; node->ocname = NULL; if(ocname) { size_t len = strlen(ocname); if(len >= NC_MAX_NAME) len = NC_MAX_NAME-1; node->ocname = (char*)malloc(len+1); if(node->ocname == NULL) { nullfree(node); return NULL;} memcpy(node->ocname,ocname,len); node->ocname[len] = '\0'; } node->nctype = octypetonc(octype); node->ocnode = ocnode; node->subnodes = nclistnew(); node->container = container; if(ocnode != NULL) { oc_dds_atomictype(nccomm->oc.conn,ocnode,&octype); node->etype = octypetonc(octype); } if(container != NULL) node->root = container->root; else if(node->nctype == NC_Dataset) node->root = node; return node; }
static void defdimensions(OCddsnode ocnode, CDFnode* cdfnode, NCDAPCOMMON* nccomm, CDFtree* tree) { size_t i,ocrank; oc_dds_rank(nccomm->oc.conn,ocnode,&ocrank); assert(ocrank > 0); for(i=0;i<ocrank;i++) { CDFnode* cdfdim; OCddsnode ocdim; char* ocname; size_t declsize; oc_dds_ithdimension(nccomm->oc.conn,ocnode,i,&ocdim); oc_dimension_properties(nccomm->oc.conn,ocdim,&declsize,&ocname); cdfdim = makecdfnode(nccomm,ocname,OC_Dimension, ocdim,cdfnode->container); nullfree(ocname); nclistpush(tree->nodes,(void*)cdfdim); /* Initially, constrained and unconstrained are same */ cdfdim->dim.declsize = declsize; cdfdim->dim.array = cdfnode; if(cdfnode->array.dimset0 == NULL) cdfnode->array.dimset0 = nclistnew(); nclistpush(cdfnode->array.dimset0,(void*)cdfdim); } }
/* Given a das attribute walk it to see if it has at least 1 actual attribute (no recursion) */ static int hasattribute3(OCconnection conn, OCobject dasnode) { int i; OCerror ocstat = OC_NOERR; int tf = 0; /* assume false */ unsigned int nsubnodes; OCtype ocsubtype; OCobject* subnodes = NULL; OCHECK(oc_inq_class(conn,dasnode,&ocsubtype)); if(ocsubtype == OC_Attribute) return 1; /* this is an attribute */ ASSERT((ocsubtype == OC_Attributeset)); OCHECK(oc_inq_nsubnodes(conn,dasnode,&nsubnodes)); OCHECK(oc_inq_subnodes(conn,dasnode,&subnodes)); for(i=0;i<nsubnodes;i++) { OCobject subnode = subnodes[i]; OCHECK(oc_inq_class(conn,subnode,&ocsubtype)); if(ocsubtype == OC_Attribute) {tf=1; break;} } done: nullfree(subnodes); return tf; }
void freegetvara(Getvara* vara) { if(vara == NULL) return; dcefree((DCEnode*)vara->varaprojection); nullfree(vara); }
static int printVariable(D4printer* out, NCD4node* var, int depth) { int ret = NC_NOERR; NCD4node* basetype = var->basetype; char* fqn = NULL; INDENT(depth); CAT("<"); switch (var->subsort) { default: CAT(basetype->name); printXMLAttributeName(out, "name", var->name); break; case NC_ENUM: CAT("Enum"); printXMLAttributeName(out, "name", var->name); printXMLAttributeName(out, "enum", (fqn=NCD4_makeFQN(basetype))); break; case NC_OPAQUE: CAT("Opaque"); printXMLAttributeName(out, "name", var->name); printXMLAttributeName(out, "type", (fqn=NCD4_makeFQN(basetype))); break; case NC_SEQ: CAT("Seq"); printXMLAttributeName(out, "name", var->name); printXMLAttributeName(out, "type", (fqn=NCD4_makeFQN(basetype))); break; case NC_STRUCT: CAT("Struct"); printXMLAttributeName(out, "name", var->name); printXMLAttributeName(out, "type", (fqn=NCD4_makeFQN(basetype))); break; } if(hasMetaData(var)) { CAT(">\n"); depth++; if((ret=printMetaData(out,var,depth))) goto done; depth--; INDENT(depth); CAT("</"); if(basetype->subsort == NC_ENUM) CAT("Enum"); else if(basetype->subsort == NC_OPAQUE) CAT("Opaque"); else if(basetype->subsort == NC_STRUCT) CAT("Struct"); else if(basetype->subsort == NC_SEQ) CAT("Sequence"); else CAT(basetype->name); CAT(">"); } else CAT("/>"); done: nullfree(fqn); return THROW(ret); }
NCerror fetchtemplatemetadata3(NCDAPCOMMON* dapcomm) { NCerror ncstat = NC_NOERR; OCerror ocstat = OC_NOERR; OCddsnode ocroot = NULL; CDFnode* ddsroot = NULL; char* ce = NULL; /* Temporary hack: we need to get the selection string from the url */ /* Get (almost) unconstrained DDS; In order to handle functions correctly, those selections must always be included */ if(FLAGSET(dapcomm->controls,NCF_UNCONSTRAINABLE)) ce = NULL; else ce = nulldup(dapcomm->oc.url->selection); /* Get selection constrained DDS */ ocstat = dap_fetch(dapcomm,dapcomm->oc.conn,ce,OCDDS,&ocroot); if(ocstat != OC_NOERR) { /* Special Hack. If the protocol is file, then see if we can get the dds from the .dods file */ if(strcmp(dapcomm->oc.url->protocol,"file") != 0) { THROWCHK(ocstat); goto done; } /* Fetch the data dds */ ocstat = dap_fetch(dapcomm,dapcomm->oc.conn,ce,OCDATADDS,&ocroot); if(ocstat != OC_NOERR) { THROWCHK(ocstat); goto done; } /* Note what we did */ nclog(NCLOGWARN,"Cannot locate .dds file, using .dods file"); } /* Get selection constrained DAS */ ocstat = dap_fetch(dapcomm,dapcomm->oc.conn,ce,OCDAS,&dapcomm->oc.ocdasroot); if(ocstat != OC_NOERR) { /* Ignore but complain */ nclog(NCLOGWARN,"Could not read DAS; ignored"); dapcomm->oc.ocdasroot = NULL; ocstat = OC_NOERR; } /* Construct the netcdf cdf tree corresponding to the dds tree*/ ncstat = buildcdftree34(dapcomm,ocroot,OCDDS,&ddsroot); if(ncstat != NC_NOERR) {THROWCHK(ncstat); goto done;} dapcomm->cdf.fullddsroot = ddsroot; done: nullfree(ce); if(ocstat != OC_NOERR) ncstat = ocerrtoncerr(ocstat); return ncstat; }
static NCerror buildattribute3a(NCDAPCOMMON* dapcomm, NCattribute* att, nc_type vartype, int varid) { int i; NCerror ncstat = NC_NOERR; unsigned int nvalues = nclistlength(att->values); NC* drno = dapcomm->controller; /* If the type of the attribute is string, then we need*/ /* to convert to a single character string by concatenation. modified: 10/23/09 to insert newlines. modified: 10/28/09 to interpret escapes */ if(att->etype == NC_STRING || att->etype == NC_URL) { char* newstring; size_t newlen = 0; for(i=0;i<nvalues;i++) { char* s = (char*)nclistget(att->values,i); newlen += (1+strlen(s)); } newstring = (char*)malloc(newlen); MEMCHECK(newstring,NC_ENOMEM); newstring[0] = '\0'; for(i=0;i<nvalues;i++) { char* s = (char*)nclistget(att->values,i); if(i > 0) strcat(newstring,"\n"); strcat(newstring,s); } dapexpandescapes(newstring); if(newstring[0]=='\0') ncstat = nc_put_att_text(drno->substrate,varid,att->name,1,newstring); else ncstat = nc_put_att_text(drno->substrate,varid,att->name,strlen(newstring),newstring); free(newstring); } else { nc_type atype; unsigned int typesize; void* mem; /* It turns out that some servers upgrade the type of _FillValue in order to correctly preserve the original value. However, since the type of the underlying variable is not changes, we get a type mismatch. So, make sure the type of the fillvalue is the same as that of the controlling variable. */ if(varid != NC_GLOBAL && strcmp(att->name,"_FillValue")==0) atype = nctypeconvert(dapcomm,vartype); else atype = nctypeconvert(dapcomm,att->etype); typesize = nctypesizeof(atype); mem = malloc(typesize * nvalues); ncstat = dapcvtattrval3(atype,mem,att->values); ncstat = nc_put_att(drno->substrate,varid,att->name,atype,nvalues,mem); nullfree(mem); } return THROW(ncstat); }
static int printMap(D4printer* out, NCD4node* mapref, int depth) { char* fqn = NULL; INDENT(depth); CAT("<Map"); printXMLAttributeName(out, "name", (fqn=NCD4_makeFQN(mapref))); CAT("/>"); nullfree(fqn); return THROW(NC_NOERR); }
void ncurifree(NCURI* duri) { if(duri == NULL) return; nullfree(duri->uri); nullfree(duri->protocol); nullfree(duri->user); nullfree(duri->password); nullfree(duri->host); nullfree(duri->port); nullfree(duri->path); nullfree(duri->query); nullfree(duri->fragment); freestringvec(duri->querylist); freestringvec(duri->fraglist); free(duri); }
NCerror fetchconstrainedmetadata3(NCDAPCOMMON* dapcomm) { NCerror ncstat = NC_NOERR; OCerror ocstat = OC_NOERR; OCddsnode ocroot; CDFnode* ddsroot; /* constrained */ char* ce = NULL; if(FLAGSET(dapcomm->controls,NCF_UNCONSTRAINABLE)) ce = NULL; else ce = buildconstraintstring3(dapcomm->oc.dapconstraint); { ocstat = dap_fetch(dapcomm,dapcomm->oc.conn,ce,OCDDS,&ocroot); if(ocstat != OC_NOERR) {THROWCHK(ocstat); goto fail;} /* Construct our parallel dds tree; including attributes*/ ncstat = buildcdftree34(dapcomm,ocroot,OCDDS,&ddsroot); if(ncstat) goto fail; ocroot = NULL; /* avoid duplicate reclaim */ dapcomm->cdf.ddsroot = ddsroot; ddsroot = NULL; /* to avoid double reclamation */ if(!FLAGSET(dapcomm->controls,NCF_UNCONSTRAINABLE)) { /* fix DAP server problem by adding back any inserting needed structure nodes */ ncstat = restruct3(dapcomm->cdf.ddsroot,dapcomm->cdf.fullddsroot,dapcomm->oc.dapconstraint->projections); if(ncstat) goto fail; } #ifdef DEBUG fprintf(stderr,"constrained:\n%s",dumptree(dapcomm->cdf.ddsroot)); #endif /* Combine DDS and DAS */ if(dapcomm->oc.ocdasroot != NULL) { ncstat = dapmerge3(dapcomm,dapcomm->cdf.ddsroot->ocnode, dapcomm->oc.ocdasroot); if(ncstat != NC_NOERR) {THROWCHK(ncstat); goto fail;} } /* map the constrained DDS to the unconstrained DDS */ ncstat = mapnodes3(dapcomm->cdf.ddsroot,dapcomm->cdf.fullddsroot); if(ncstat) goto fail; } fail: nullfree(ce); if(ocstat != OC_NOERR) ncstat = ocerrtoncerr(ocstat); return ncstat; }
static void freestringlist(NClist* list) { if(list != NULL) { int i; for(i=0;i<nclistlength(list);i++) { void* p = nclistget(list,i); nullfree(p); } nclistfree(list); } }
void freenccache(NCDAPCOMMON* nccomm, NCcache* cache) { int i; if(cache == NULL) return; freenccachenode(nccomm,cache->prefetch); for(i=0;i<nclistlength(cache->nodes);i++) { freenccachenode(nccomm,(NCcachenode*)nclistget(cache->nodes,i)); } nclistfree(cache->nodes); nullfree(cache); }
static int readpacket(NCD4INFO* state, NCURI* url, NCbytes* packet, NCD4mode dxx, long* lastmodified) { int stat = NC_NOERR; int fileprotocol = 0; const char* suffix = dxxextension(dxx); CURL* curl = state->curl->curl; #ifdef HAVE_GETTIMEOFDAY struct timeval time0; struct timeval time1; #endif fileprotocol = (strcmp(url->protocol,"file")==0); if(fileprotocol) { /* Short circuit file://... urls*/ /* We do this because the test code always needs to read files*/ stat = readfile(state, url,suffix,packet); } else { char* fetchurl = NULL; int flags = NCURIBASE; if(!fileprotocol) flags |= NCURIQUERY; flags |= NCURIENCODE; fetchurl = ncuribuild(url,NULL,suffix,flags); MEMCHECK(fetchurl); if(FLAGSET(state->controls.flags,NCF_SHOWFETCH)) { nclog(NCLOGDBG,"fetch url=%s",fetchurl); #ifdef HAVE_GETTIMEOFDAY gettimeofday(&time0,NULL); #endif } stat = NCD4_fetchurl(curl,fetchurl,packet,lastmodified); nullfree(fetchurl); if(stat) goto fail; if(FLAGSET(state->controls.flags,NCF_SHOWFETCH)) { double secs = 0; #ifdef HAVE_GETTIMEOFDAY gettimeofday(&time1,NULL); secs = deltatime(time0,time1); #endif nclog(NCLOGDBG,"fetch complete: %0.3f",secs); } } #ifdef D4DEBUG { fprintf(stderr,"readpacket: packet.size=%lu\n", (unsigned long)ncbyteslength(packet)); } #endif fail: return THROW(stat); }
void freenccachenode(NCDAPCOMMON* nccomm, NCcachenode* node) { if(node == NULL) return; oc_data_free(nccomm->oc.conn,node->content); #ifdef IGNORE oc_root_free(nccomm->oc.conn,node->ocroot); #endif dcefree((DCEnode*)node->constraint); freecdfroot34(node->datadds); nclistfree(node->vars); nullfree(node); }
static void free_matcher(Matcher *self) { uint32_t i = 0; if (self->items != NULL) { for (i = 0; i < self->item_count; i++) { nullfree(self->items[i]); } } nullfree(self->items); nullfree(self->item_lengths); nullfree(self->level1); nullfree(self->level2); nullfree(self->level3); }
void freenccachenode(NCDAPCOMMON* nccomm, NCcachenode* node) { if(node == NULL) return; #ifdef DEBUG fprintf(stderr,"freecachenode: %s\n", dumpcachenode(node)); #endif oc_data_free(nccomm->oc.conn,node->content); dcefree((DCEnode*)node->constraint); freecdfroot34(node->datadds); nclistfree(node->vars); nullfree(node); }
static int printXMLAttributeName(D4printer* out, char* name, const char* value) { int ret = NC_NOERR; char* escaped = NULL; if(name == NULL) return THROW(ret); if(value == NULL) value = ""; CAT(" "); CAT(name); CAT("=\""); /* add xml entity escaping */ escaped = NCD4_entityescape(value); CAT(escaped); CAT("\""); nullfree(escaped); return THROW(ret); }