void mSort (void *b, int n, int s, int (*cmp)(void *va, void *vb))
{
int size = n * s, s_of_i = sizeof (int) ;
char sBuf [4*1024] ;
char *mBuf = 0, *buf ;
if (n < 2)
return ;
/* If size is small, use the stack, else malloc */
if (size < 4*1024)
buf = sBuf ;
else
{
/* buf = mBuf = (char *) malloc (size) ; */
buf = mBuf = (char *) needLargeZeroedMem(size);
}
if (s == s_of_i && /* aligned integers. Use direct int pointers. */
(((char *)b - (char *) 0) % s_of_i) == 0)
mDoSortInt ((int*)b, n, cmp, (int*)buf) ;
else
mDoSort ((char *)b, n, s, cmp, buf) ;
/* if (mBuf) free (mBuf) ; */
if (mBuf) freeMem (mBuf) ;
}
Bits *bitClone(Bits* orig, int bitCount)
/* Clone bits. */
{
int byteCount = ((bitCount+7)>>3);
Bits* bits = needLargeZeroedMem(byteCount);
memcpy(bits, orig, byteCount);
return bits;
}
void chainStitchId(char *inChain, char *outChain)
/* chainStitchId - Join chain fragments with the same chain ID into a single chain per ID. */
{
struct lineFile *lf = lineFileOpen(inChain, TRUE);
struct chain *chain = NULL, *chainList = NULL;
FILE *f = mustOpen(outChain, "w");
int idArrLen = 64 * 1024 * 1024;
struct chain **idArr = needLargeZeroedMem(idArrLen * sizeof(struct chain *));
int i=0;
/* Build up an array of chains, indexed by IDs. Agglomerate chains with same
* ID as we go. */
while ((chain = chainRead(lf)) != NULL)
{
while (chain->id >= idArrLen)
{
idArr = needMoreMem(idArr, idArrLen, idArrLen*2*sizeof(idArr[0]));
idArrLen *= 2;
}
if (idArr[chain->id] == NULL)
idArr[chain->id] = chain;
else
{
tackOnFrag(idArr[chain->id], chain);
chainFree(&chain);
}
}
lineFileClose(&lf);
/* Clean up each agglomerated chain and add to head of list (but step
* backwards so the resulting list is in order by chain id). */
for (i = idArrLen-1; i >= 0; i--)
{
chain = idArr[i];
if (chain != NULL)
{
slSort(&(chain->blockList), cBlockCmpTarget);
slAddHead(&chainList, chain);
}
}
/* Ordering by original chain id gets us most of the way to sorting by
* score, but not all the way: sort and finally write out the chains. */
slSort(&chainList, chainCmpScore);
for (chain = chainList; chain != NULL; chain = chain->next)
{
chainWrite(chain, f);
/* could free here, but program is about to end so why waste the time. */
}
carefulClose(&f);
}
static struct lmBlock *newBlock(struct lm *lm, size_t reqSize)
/* Allocate a new block of at least reqSize */
{
size_t size = (reqSize > lm->blockSize ? reqSize : lm->blockSize);
size_t fullSize = size + sizeof(struct lmBlock);
struct lmBlock *mb = needLargeZeroedMem(fullSize);
if (mb == NULL)
errAbort("Couldn't allocate %"PRIdMAX" bytes", (intmax_t)fullSize);
mb->free = (char *)(mb+1);
mb->end = ((char *)mb) + fullSize;
mb->next = lm->blocks;
lm->blocks = mb;
return mb;
}
Bits *bitAlloc(int bitCount)
/* Allocate bits. */
{
int byteCount = ((bitCount+7)>>3);
return needLargeZeroedMem(byteCount);
}