void ajPatCompDel (AjPPatComp *pthys)
{
ajuint i;
AjPPatComp thys;
if(!pthys)
return;
if(!*pthys)
return;
thys = *pthys;
ajStrDel(&thys->pattern);
ajStrDel(&thys->regex);
if(thys->buf)
AJFREE(thys->buf);
if(thys->sotable)
AJFREE(thys->sotable);
if(thys->type==6)
{
for(i=0;i<thys->m;++i)
AJFREE(thys->skipm[i]);
AJFREE(thys->skipm);
}
AJFREE(*pthys);
return;
}
void ajRegFree(AjPRegexp* pexp)
{
AjPRegexp exp;
if(!pexp)
return;
if(!*pexp)
return;
exp = *pexp;
/*
ajDebug("ajRegFree %x size regexp %d\n", exp,
(ajint) sizeof(exp));
*/
regFreeCount += 1;
regFree += sizeof(*exp);
if(exp->pcre)
regFree += sizeof(exp->pcre);
if(exp->extra)
regFree += sizeof(exp->extra);
regTotal --;
AJFREE(exp->pcre);
AJFREE(exp->extra);
AJFREE(exp->ovector);
AJFREE(*pexp);
return;
}
static void messTableDelete(AjPTable* table)
{
void **keyarray = NULL;
void **valarray = NULL;
ajint i;
if(!table)
return;
if(!*table)
return;
ajTableToarrayKeysValues(*table, &keyarray, &valarray);
for(i = 0; keyarray[i]; i++)
{
AJFREE(keyarray[i]);
AJFREE(valarray[i]);
}
AJFREE(keyarray);
AJFREE(valarray);
ajTableFree(table);
*table = NULL;
return;
}
void ajHistDel(AjPHist* phist)
{
ajuint i;
AjPHist hist;
if(!phist) return;
hist = *phist;
if (!hist)
return;
for(i=0;i<hist->numofsets; i++)
{
if(hist->hists[i]->deletedata)
{
ajStrDel(&hist->hists[i]->title);
ajStrDel(&hist->hists[i]->xaxis);
ajStrDel(&hist->hists[i]->yaxis);
AJFREE(hist->hists[i]->data);
}
AJFREE((hist->hists[i]));
}
AJFREE(hist->hists);
ajStrDel(&hist->title);
ajStrDel(&hist->xaxis);
ajStrDel(&hist->yaxisleft);
ajStrDel(&hist->yaxisright);
AJFREE(*phist);
return;
}
static void remap_DelTable(AjPTable * table)
{
void **keyarray = NULL; /* array for table */
void **valarray = NULL; /* array for table */
ajint i;
PValue value;
if(ajTableGetLength(*table))
{
ajTableToarrayKeysValues(*table, &keyarray, &valarray);
for(i = 0; keyarray[i]; i++)
{
value = (PValue) valarray[i];
ajStrDel(&(value->iso));
AJFREE(valarray[i]); /* free the ajint* value */
ajStrDel((AjPStr*)&keyarray[i]);
}
AJFREE(keyarray);
AJFREE(valarray);
}
ajTableFree(table);
return;
}
void ajXmlDel(AjPXml *Pxml)
{
AjPXml xml;
if(!Pxml) return;
if(!(*Pxml)) return;
xml = *Pxml;
ajStrDel(&xml->Id);
ajStrDel(&xml->Db);
ajStrDel(&xml->Setdb);
ajStrDel(&xml->Full);
ajStrDel(&xml->Qry);
ajStrDel(&xml->Formatstr);
ajStrDel(&xml->Filename);
ajStrDel(&xml->TextPtr);
if(xml->Doc)
ajDomDocumentDestroyNode(xml->Doc, &xml->Doc);
AJFREE(*Pxml);
*Pxml = NULL;
return;
}
static void dbiblast_dbfree( PBlastDb* pdb)
{
PBlastDb db;
if(!pdb)
return;
if(!*pdb)
return;
db = *pdb;
dbiblast_memfclosefile(&db->TFile);
dbiblast_memfclosefile(&db->HFile);
dbiblast_memfclosefile(&db->SFile);
dbiblast_memfclosefile(&db->FFile);
ajStrDel(&db->Name);
ajStrDel(&db->Date);
ajStrDel(&db->Title);
AJFREE(*pdb);
return;
}
void ensKaryotypebandDel(EnsPKaryotypeband *Pkb)
{
EnsPKaryotypeband pthis = NULL;
if(!Pkb)
return;
if(!*Pkb)
return;
pthis = *Pkb;
pthis->Use--;
if(pthis->Use)
{
*Pkb = NULL;
return;
}
ensFeatureDel(&pthis->Feature);
ajStrDel(&pthis->Name);
ajStrDel(&pthis->Stain);
AJFREE(pthis);
*Pkb = NULL;
return;
}
static void silent_split_hits(AjPList *hits, AjPList *silents,
AjPList *nonsilents, AjBool allmut)
{
PSilent res;
while(ajListPop(*hits,(void **)&res))
{
if(res->issilent)
{
ajListPushAppend(*silents,(void *)res);
continue;
}
if(allmut)
ajListPushAppend(*nonsilents,(void *)res);
else
{
ajStrDel(&res->code);
ajStrDel(&res->site);
ajStrDel(&res->seqaa);
ajStrDel(&res->reaa);
AJFREE(res);
}
}
return;
}
static void prima_PrimerDel(PPrimer *p)
{
ajStrDel(&((*p)->substr));
AJFREE(*p);
return;
}
void ajRefseqDel(AjPRefseq *Prefseq)
{
AjPRefseq refseq;
AjPSeqRange tmprange;
if(!Prefseq) return;
if(!(*Prefseq)) return;
refseq = *Prefseq;
ajStrDel(&refseq->Id);
ajStrDel(&refseq->Db);
ajStrDel(&refseq->Setdb);
ajStrDel(&refseq->Full);
ajStrDel(&refseq->Qry);
ajStrDel(&refseq->Formatstr);
ajStrDel(&refseq->Filename);
ajStrDel(&refseq->TextPtr);
ajStrDel(&refseq->Desc);
ajStrDel(&refseq->Seq);
while(ajListPop(refseq->Seqlist,(void **)&tmprange))
ajSeqrangeDel(&tmprange);
ajListFree(&refseq->Seqlist);
AJFREE(*Prefseq);
*Prefseq = NULL;
return;
}
void embPropMolwtDel(EmbPPropMolwt **thys)
{
EmbPPropMolwt *pthis = NULL;
ajuint i;
pthis = *thys;
for(i=0; i < EMBPROPSIZE + 2; ++i)
AJFREE(pthis[i]);
AJFREE(pthis);
*thys = NULL;
return;
}
void embPropAminoDel(EmbPPropAmino **thys)
{
EmbPPropAmino *pthis = NULL;
ajuint i;
pthis = *thys;
for(i=0; i < EMBPROPSIZE; ++i)
AJFREE(pthis[i]);
AJFREE(pthis);
*thys = NULL;
return;
}
void ensAssemblyexceptionDel(EnsPAssemblyexception* Pae)
{
EnsPAssemblyexception pthis = NULL;
if(!Pae)
return;
if(!*Pae)
return;
pthis = *Pae;
pthis->Use--;
if(pthis->Use)
{
*Pae = NULL;
return;
}
AJFREE(*Pae);
return;
}
AjPRegexp ajRegCompC(const char* rexp)
{
AjPRegexp ret;
int options = 0;
int errpos = 0;
const char *errptr = NULL;
const unsigned char *tableptr = NULL;
AJNEW0(ret);
AJCNEW0(ret->ovector, AJREG_OVECSIZE);
ret->ovecsize = AJREG_OVECSIZE/3;
ret->pcre = pcre_compile(rexp, options, &errptr, &errpos, tableptr);
if(!ret->pcre)
{
ajErr("Failed to compile regular expression '%s' at position %d: %s",
rexp, errpos, errptr);
AJFREE(ret);
return NULL;
}
regAlloc += sizeof(ret);
regCount ++;
regTotal ++;
/*ajDebug("ajRegCompC %x size %d regexp '%s'\n",
ret, (int) sizeof(ret), rexp);*/
return ret;
}
static void jaspscan_infodel(PJspmat *thys)
{
PJspmat pthis;
pthis = *thys;
ajStrDel(&pthis->id);
ajStrDel(&pthis->num);
ajStrDel(&pthis->name);
ajStrDel(&pthis->klass);
ajStrDel(&pthis->species);
ajStrDel(&pthis->sgroup);
ajStrDel(&pthis->protseq);
ajStrDel(&pthis->exp);
ajStrDel(&pthis->pmid);
ajStrDel(&pthis->models);
ajStrDel(&pthis->mcs);
ajStrDel(&pthis->jaspar);
ajStrDel(&pthis->transfac);
ajStrDel(&pthis->content);
ajStrDel(&pthis->desc);
ajStrDel(&pthis->comment);
ajStrDel(&pthis->erttss);
ajStrDel(&pthis->srttss);
ajStrDel(&pthis->consens);
AJFREE(*thys);
*thys = NULL;
return;
}
static void assemblyexceptionadaptorClearIdentifierCache(void **key,
void **value,
void *cl)
{
EnsPAssemblyexception ae = NULL;
if(!key)
return;
if(!*key)
return;
if(!value)
return;
if(!*value)
return;
(void) cl;
AJFREE(*key);
while(ajListPop(*((AjPList *) value), (void **) &ae))
ensAssemblyexceptionDel(&ae);
ajListFree((AjPList *) value);
return;
}
void ensStorableDel(EnsPStorable *Pstorable)
{
EnsPStorable pthis = NULL;
if(!Pstorable)
return;
if(!*Pstorable)
return;
pthis = *Pstorable;
pthis->Use--;
if(pthis->Use)
{
*Pstorable = NULL;
return;
}
AJFREE(pthis);
*Pstorable = NULL;
return;
}
void ensProjectionsegmentDel(EnsPProjectionsegment *Pps)
{
EnsPProjectionsegment pthis = NULL;
if(!Pps)
return;
if(!*Pps)
return;
pthis = *Pps;
pthis->Use--;
if(pthis->Use)
{
*Pps = NULL;
return;
}
ensSliceDel(&pthis->TrgSlice);
AJFREE(pthis);
*Pps = NULL;
return;
}
void embIeppKDel(double *pK)
{
AJFREE(pK);
return;
}
static char* messGetFilename(const char *path)
{
static char *path_copy = NULL;
const char *path_delim = SUBDIR_DELIMITER_STR;
char *result = NULL;
char *tmp;
if(path != NULL)
{
if(strcmp((path + strlen(path) - 1), path_delim) != 0)
{ /* Last char = "/" ?? */
if(path_copy != NULL)
AJFREE(path_copy);
path_copy = ajSysFuncStrdup(path);
tmp = ajSysFuncStrtok(path_copy, path_delim);
while(tmp != NULL)
{
result = tmp; /* Keep results of previous strtok */
tmp = ajSysFuncStrtok(NULL, path_delim);
}
}
}
return(result);
}
static char* messFormat(va_list args, const char *format, const char *prefix)
{
static char *new_buf = NULL;
char *buf_ptr;
ajint num_bytes;
ajint prefix_len;
if(format == NULL)
ajMessCrash("invalid call, no format string.");
if(prefix == NULL)
prefix_len = 0;
else
{
prefix_len = strlen(prefix);
if((prefix_len + 1) > PREFIXSIZE)
ajMessCrash("prefix string is too long.");
}
/* If they supply the internal buffer as an argument, e.g. because they */
/* used ajFmtString as an arg, then make a copy, otherwise use internal */
/* buffer. */
if(format == messbuf)
{
if(new_buf != NULL)
AJFREE(new_buf);
buf_ptr = new_buf = ajSysFuncStrdup(format);
}
else
buf_ptr = messbuf;
/* Add the prefix if there is one. */
if(prefix != NULL)
{
if(!strcpy(buf_ptr, prefix))
ajMessCrash("strcpy failed");
}
num_bytes = prefix_len + 1;
num_bytes += ajFmtVPrintCL((buf_ptr + prefix_len),BUFSIZE, format, args);
/*
** Check the result. This should never happen using the
** ajFmtVPrintCL routine instead of the vsprintf routine
*/
if(num_bytes < 0)
ajMessCrash("vsprintf failed: %s", ajMessGetSysmessageC());
else if(num_bytes > BUFSIZE)
ajMessCrash("messubs internal buffer size (%d) exceeded, "
"a total of %d bytes were written",
BUFSIZE, num_bytes);
return(buf_ptr);
}
static void callCountDel(void** key, void** value, void* cl)
{
char *p;
ajuint *cnt;
(void) cl;
p = (char*) *key;
cnt = (ajuint*) *value;
AJFREE(p);
AJFREE(cnt);
*key = NULL;
return;
}
void ajMessExit(void)
{
AJFREE(messErrMess);
messTableDelete(&messErrorTable);
messTableDelete(&messDebugTestTable);
return;
}
__deprecated char* ajMessSysErrorText(void)
{
char *mess;
if(errno)
mess = ajFmtString(SYSERR_FORMAT, errno, strerror(errno));
else
mess = ajFmtString(SYSERR_OK, errno, strerror(errno));
/* must make copy - will be used when mess* calls itself */
AJFREE(messErrMess);
messErrMess = ajSysFuncStrdup(mess);
AJFREE(mess);
return messErrMess;
}
static void cacheNodeDel(const EnsPCache cache, CachePNode* Pnode)
{
if(!cache)
return;
if(!Pnode)
return;
if(!*Pnode)
return;
switch(cache->Type)
{
case ensECacheTypeNumeric:
/* Delete AJAX unsigned integer key data. */
AJFREE((*Pnode)->Key);
break;
case ensECacheTypeAlphaNumeric:
/* Delete AJAX String key data. */
ajStrDel((AjPStr *) &((*Pnode)->Key));
break;
default:
ajWarn("cacheNodeDel got unexpected Cache type %d.\n",
cache->Type);
}
/* Delete the value data. */
if(cache->Delete && (*Pnode)->Value)
(*cache->Delete)(&((*Pnode)->Value));
AJFREE(*Pnode);
*Pnode = NULL;
return;
}
static const AjPStr assemSAMGetReadgroupHeaderlines(const AjPAssem assem)
{
AjPStr* rgids = NULL;
const AjPAssemReadgroup rg = NULL;
ajint i =0;
ajTableToarrayKeys(assem->Readgroups, (void***)&rgids);
ajStrAssignC(&assemoutSamLinetxt, "");
while (rgids[i]) /* read groups */
{
rg = ajTableFetchS(assem->Readgroups, rgids[i++]);
ajFmtPrintAppS(&assemoutSamLinetxt, "@RG\tID:%S", rg->ID);
if(rg->CN)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tCN:%S", rg->CN);
if(rg->Desc)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tDS:%S", rg->Desc);
if(rg->Date)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tDT:%S", rg->Date);
if(rg->FlowOrder)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tFO:%S", rg->FlowOrder);
if(rg->KeySeq)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tKS:%S", rg->KeySeq);
if(rg->Library)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tLB:%S", rg->Library);
if(rg->Programs)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tPG:%S", rg->Programs);
if(rg->Isize)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tPI:%d", rg->Isize);
if(rg->Platform)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tPL:%s",
ajAssemreadgroupGetPlatformname(rg));
if(rg->Unit)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tPU:%S", rg->Unit);
if(rg->Sample)
ajFmtPrintAppS(&assemoutSamLinetxt, "\tSM:%S", rg->Sample);
ajStrAppendC(&assemoutSamLinetxt, "\n");
}
AJFREE(rgids);
return assemoutSamLinetxt;
}
static void prima_prune_nearby(AjPList pairlist, ajint *npair, ajint range)
{
PPair pair;
ajint count;
ajint fst;
ajint fst2;
ajint blim;
ajint blim2;
ajint elim;
ajint elim2;
ajint i;
ajint j;
ajint len;
for(i=0;i<*npair;++i)
{
for(j=0;j<i;++j) /* Ignore those already processed */
{
ajListPop(pairlist,(void **)&pair);
ajListPushAppend(pairlist,(void *)pair);
}
ajListPop(pairlist,(void **)&pair);/* Get next high scoring pair */
len = pair->f->primerlen;
fst = pair->f->start + len -1;
blim = fst-range;
elim = fst+range;
len = pair->r->primerlen;
blim2 = pair->r->start - range;
elim2 = pair->r->start + range;
ajListPushAppend(pairlist,(void *)pair);
count = *npair;
for(j=i+1;j<*npair;++j)
{
ajListPop(pairlist,(void **)&pair);
fst2=pair->f->start+pair->f->primerlen-1;
if((fst2<blim || fst2>elim) && (pair->r->start<blim2 ||
pair->r->start>elim2))
ajListPushAppend(pairlist,(void *)pair);
else
{
prima_PrimerDel(&pair->f);
prima_PrimerDel(&pair->r);
AJFREE(pair);
--count;
}
}
*npair = count;
}
return;
}
void ajPatternSeqDel (AjPPatternSeq* pthys)
{
AjPPatternSeq thys = *pthys;
ajStrDel(&thys->Name);
ajStrDel(&thys->Pattern);
ajPatCompDel((AjPPatComp*) &thys->Compiled);
AJFREE (*pthys);
return;
}
/* @funcstatic sigscanlig_LigHitDel *******************************************
**
** Destructor for Lighit object.
**
** @param [r] obj [SigPLighit *]
**
** @return [AjBool] True on success
** @@
******************************************************************************/
void sigscanlig_LigHitDel(SigPLighit *obj)
{
if((!obj) || (!(*obj)))
return;
ajStrDel(&(*obj)->ligid);
AJFREE(*obj);
*obj = NULL;
return;
}
