自学教程：C++ uglyf函数代码示例

void loadCr2g(char *fileName, struct cr2g **chromLists){char buf[512];struct cr2g *el;FILE *f = mustOpen(fileName, "r");char *words[8];int wordCount;char *parts[3];int partCount;int chromIx;uglyf("Loading %s<BR>/n", fileName);while (fgets(buf, sizeof(buf), f) != NULL)    {    wordCount = chopString(buf, whiteSpaceChopper, words, ArraySize(words));    if (wordCount != 3)        errAbort("Bad cr2g file/n");    partCount = chopString(words[0], ":-", parts, ArraySize(parts));    if (partCount != 3)        errAbort("Bad cr2g file/n");    AllocVar(el);    chromIx = findChromIx(parts[0]);    el->strand = words[1][0];    el->start = atoi(parts[1]);    el->end = atoi(parts[2]);    strncpy(el->geneName, words[2], sizeof(el->geneName));    el->next = chromLists[chromIx];    chromLists[chromIx] = el;    }uglyf("Done loading %s<BR>/n", fileName);fclose(f);}

void chainPair(struct seqPair *sp, FILE *f)/* Make chains for all alignments in sp. */{long startTime, dt;struct axt *axt;struct cBlock *blockList, *block;struct chain *chainList = NULL, *chain;uglyf("%s %d nodes/n", sp->name, slCount(sp->blockList));/* Make up tree and time it for debugging. */startTime = clock1000();chainList = chainBlocks(&sp->blockList, gapCost);dt = clock1000() - startTime;uglyf("Made %d chains in %5.3f seconds/n", slCount(chainList), dt*0.001);/* Dump chains to file. */for (chain = chainList; chain != NULL; chain = chain->next)    {    struct cBlock *first = chain->blockList;    struct cBlock *last = slLastEl(first);    struct cBlock *block;    fprintf(f, "%s Chain %d, score %d, %d %d, %d %d:/n", 	sp->name, slCount(chain->blockList), chain->score,	first->qStart, last->qEnd, first->tStart, last->qEnd);    for (block = chain->blockList; block != NULL; block = block->next)        {	fprintf(f, " %s q %d, t %d, score %d/n", sp->name,		block->qStart, block->tStart, block->score);	}    fprintf(f, "/n");    }chainFreeList(&chainList);uglyf("/n");}

void rt1dFindOld(char *tabFile, char *treeFile, bits32 chromIx, bits32 start, bits32 end)/* rt1dCreate - find items in 1-D range tree. */{struct lineFile *lf = lineFileOpen(tabFile, TRUE);struct cirTreeFile *crf = cirTreeFileOpen(treeFile);struct fileOffsetSize *block, *blockList = cirTreeFindOverlappingBlocks(crf, chromIx, start, end);uglyf("Got %d overlapping blocks/n", slCount(blockList));for (block = blockList; block != NULL; block = block->next)    {    uglyf("block->offset %llu, block->size %llu/n", block->offset, block->size);    lineFileSeek(lf, block->offset, SEEK_SET);    bits64 sizeUsed = 0;    while (sizeUsed < block->size)        {	char *line;	int size;	if (!lineFileNext(lf, &line, &size))	    errAbort("Couldn't read %s/n", lf->fileName);	char *parsedLine = cloneString(line);	char *row[3];	if (chopLine(parsedLine, row) != ArraySize(row))	    errAbort("Badly formatted line of %s/n%s", lf->fileName, line);	bits32 bedChromIx = sqlUnsigned(row[0]);	bits32 bedStart = sqlUnsigned(row[1]);	bits32 bedEnd = sqlUnsigned(row[2]);	if (bedChromIx == chromIx && rangeIntersection(bedStart, bedEnd, start, end) > 0)	    fprintf(stdout, "%s/n", line);	freeMem(parsedLine);	sizeUsed += size;	}    }}

void alignNt(char *nt)/* Do alignments of draft bacs against one NT. */{char indexFileName[512];char ntFaName[512];struct lineFile *indexLf;int lineSize;char *line;char *words[3];int wordCount;struct patSpace *ps;struct dnaSeq *ntSeq;printf("<H1>Check Layout of %s</H1>/n", nt);printf("<PRE>");sprintf(ntFaName, "%s/p%s.fa", faDir, nt);ntSeq = faReadAllDna(ntFaName);ps = makePatSpace(&ntSeq, 1, oocFile, 10, 500);sprintf(indexFileName, "%s/%s.index", indexDir, nt);uglyf("Checking out %s and %s/n", indexFileName, ntFaName);indexLf = lineFileOpen(indexFileName, TRUE);while (lineFileNext(indexLf, &line, &lineSize))    {    wordCount = chopLine(line, words);    if (wordCount > 0)	{	char bacFaName[512];	struct dnaSeq *contigList, *contig;	char *bacAcc = words[0];	char *s = strrchr(bacAcc, '.');	if (s != NULL)	    *s = 0;	uglyf("%s/n", bacAcc);	sprintf(bacFaName, "%s/%s.fa", faDir, bacAcc);	contigList = faReadAllDna(bacFaName);	for (contig = contigList; contig != NULL; contig = contig->next)	    {	    boolean isRc;	    uglyf(" %s/n", contig->name);	    for (isRc = FALSE; isRc <= TRUE; isRc += 1)		{		struct ssBundle *bunList, *bun;		bunList = ssFindBundles(ps, contig, contig->name, ffTight);		for (bun = bunList; bun != NULL; bun = bun->next)		    {		    showBundle(bun, isRc);		    }		ssBundleFreeList(&bunList);		reverseComplement(contig->dna, contig->size);		}	    }	freeDnaSeqList(&contigList);	}    }lineFileClose(&indexLf);freeDnaSeqList(&ntSeq);}

void intersectOnChrom(char *db, struct sqlConnection *conn, char *chrom, 	char *track1, char *track2)/* Do intersection on one chromosome. */{int chromSize = hChromSize(chrom);struct lm *lm = lmInit(0);struct bed *bedList1, *bedList2, *andBed;struct featureBits *fb1, *fb2;Bits *bit1, *bit2;int fieldCount1, fieldCount2;struct binKeeper *bk2;uglyTime(NULL);scanChromTable(conn, chrom, track1);scanChromTable(conn, chrom, track2);uglyTime("Scan tracks");bedList1 = getChromAsBed(conn, db, track1, chrom, lm, &fieldCount1);bedList2 = getChromAsBed(conn, db, track2, chrom, lm, &fieldCount2);uglyTime("Tracks as bed");uglyf("%d items with %d fields in %s, ", slCount(bedList1), fieldCount1, track1);uglyf("%d items with %d fields in %s/n", slCount(bedList2), fieldCount2, track2);bit1 = bitAlloc(chromSize+8);bit2 = bitAlloc(chromSize+8);uglyTime("bitAlloc");fb1 = fbList(db, chrom, track1,  bedList1, chromSize);fb2 = fbList(db, chrom, track1,  bedList1, chromSize);uglyTime("bed to featureBits list");fbOrBits(bit1, chromSize, fb1, 0);fbOrBits(bit2, chromSize, fb2, 0);uglyTime("or into bits");bitAnd(bit1, bit2, chromSize);uglyTime("Anding bitfields");andBed = bitsToBed4List(bit1, chromSize, chrom, 0, 0, chromSize, lm);uglyTime("Converting bitfield to bed 4");bitCountAllOverlaps(bedList1, bit2, fieldCount2);uglyTime("Counting overlaps in track1 with bitfield of track2");bk2 = fbToBinKeeper(fb2, chromSize);uglyTime("Adding featureBits list from track 2 into binKeeper.");bkCountAllOverlaps(bedList1, bk2, fieldCount2);uglyTime("Count overlaps in track1 with binKeeper of track2");featureBitsFreeList(&fb1);featureBitsFreeList(&fb2);uglyTime("free featureBits");bitFree(&bit1);bitFree(&bit2);uglyTime("bitFree");}

void hgNibSeq(char *database, char *destDir, int faCount, char *faNames[])/* hgNibSeq - convert DNA to nibble-a-base and store location in database. */{char dir[256], name[128], chromName[128], ext[64];char nibName[512];struct sqlConnection *conn = sqlConnect(database);char query[512];int i;char *faName;struct dnaSeq *seq = NULL;unsigned long total = 0;int size;if (!strchr(destDir, '/'))   errAbort("Use full path name for nib file dir/n");makeDir(destDir);if ((!appendTbl) || !sqlTableExists(conn, tableName))    createTable(conn);for (i=0; i<faCount; ++i)    {    faName = faNames[i];    splitPath(faName, dir, name, ext);    sprintf(nibName, "%s/%s.nib", destDir, name);    printf("Processing %s to %s/n", faName, nibName);    if (preMadeNib)        {	FILE *nibFile;	nibOpenVerify(nibName, &nibFile, &size);	carefulClose(&nibFile);	}    else	{	seq = faReadDna(faName);	if (seq != NULL)	    {	    size = seq->size;	    uglyf("Read DNA/n");	    nibWrite(seq, nibName);	    uglyf("Wrote nib/n");	    freeDnaSeq(&seq);	    }	}    strcpy(chromName, chromPrefix);    strcat(chromName, name);    sqlSafef(query, sizeof query, "INSERT into %s VALUES('%s', %d, '%s')",        tableName, chromName, size, nibName);    sqlUpdate(conn,query);    total += size;    }sqlDisconnect(&conn);printf("%lu total bases/n", total);}

int main(){testPolyOut();uglyf("Ok1/n");testPolyIn();uglyf("Ok2/n");testPolyhOut();uglyf("Ok3/n");testPolyhIn();uglyf("Ok4/n");return 0;}

void makeCdnaToGene(struct cdnaInfo *cdnaList)/* Make cdna to gene translation file. */{struct hash *hash = newHash(12);struct cdnaInfo *ci;struct fineAli *fa;struct geneHit *gh;struct geneHitList *geneHitList = NULL;struct geneHitList *ghl;struct hashEl *he;uglyf("Making cdnaToGene file<BR>/n");for (ci = cdnaList; ci != NULL; ci = ci->next)    {    if (ci->isDupe)        continue;    for (fa = ci->fineAli; fa != NULL; fa = fa->next)        {        if (fa->isDupe || !fa->isGood)             continue;        if ((he = hashLookup(hash, fa->geneName)) == NULL)            {            AllocVar(ghl);            ghl->geneName = fa->geneName;            ghl->next = geneHitList;            geneHitList = ghl;            he = hashAdd(hash, fa->geneName, ghl);            }        ghl = (struct geneHitList *)(he->val);        AllocVar(gh);        gh->cdnaName = ci->name;        gh->chromOffset = fa->hStart;        gh->next = ghl->hits;        ghl->hits = gh;        }    }slSort(&geneHitList, cmpGhlName);for (ghl=geneHitList; ghl!=NULL; ghl = ghl->next)    {    slReverse(&ghl->hits);    slSort(&ghl->hits, cmpGhOffset);    fprintf(cdnaToGeneFile, "%s ", ghl->geneName);    for (gh = ghl->hits; gh != NULL; gh = gh->next)        fprintf(cdnaToGeneFile, "%s ", gh->cdnaName);    fprintf(cdnaToGeneFile, "/n");    }freeHash(&hash);slFreeList(&geneHitList);uglyf("Done making cdnaToGene file<BR>/n");}

void smallTest()/* Test out stuff. */{struct ggMrnaCluster *mc = makeTestInput();struct geneGraph *gg;static struct ggMrnaInput dummyCi;uglyf("Initial input/n");dumpMc(mc);uglyf("/n");gg = ggGraphCluster(mc, &dummyCi);traverseGeneGraph(gg, mc->tStart, mc->tEnd, dumpGgAliInfo);errAbort("Done testing");}

int bwtSearch(UBYTE *bwt, bits32 size, char *string)/* Reverse Burrows Wheeler transform of string. */{/* Empty case is easy here (and a pain if we have to deal with it later) */if (size == 0)    return 0;/* Make array that will store the count of occurences of each character up to a given position. */bits32 *occ;AllocArray(occ, size+1);/* Count up occurences of all characters into offset array.   */bits32 i, counts[256], offsets[256];for (i=0; i<256; ++i)    counts[i] = 0;for (i=0; i<size; ++i)    {    int c = bwt[i];    occ[i] = counts[c];    counts[c] += 1;    }/* Convert counts to offsets. */bits32 total = 0;for (i=0; i<ArraySize(offsets); ++i)    {    offsets[i] = total;    total += counts[i];    }i = strlen(string)-1;int start = 0, end = size-1;while (start <= end)    {    UBYTE c = string[i];    int startOcc = findOcc(bwt, c, start-1);    int endOcc = findOcc(bwt, c, end) - 1;    uglyf("%u  start=%u  end=%u  c=%c(%d) offsets[%c]=%d startOcc=%d endOcc=%d/n", i, start, end, c, c, c, offsets[c], startOcc, endOcc);    start = offsets[c] + startOcc;    end = offsets[c] + endOcc;    if (i == 0)        break;    i = i - 1;    }uglyf("final i=%d start=%u end=%u/n", i, start, end);if (i != 0)    return 0;return end - start + 1;}

void freen(char *chrom)/* Test something */{uglyTime(NULL);struct sqlConnection *conn = sqlConnect("hg19");uglyTime("connect");char query[512];sqlSafef(query, sizeof(query), "select * from knownGene where chrom='%s'", chrom);struct sqlResult *sr = sqlGetResult(conn, query);uglyTime("get result");char **row;struct rbTree *rt = rangeTreeNew();while ((row = sqlNextRow(sr)) != NULL)    {    struct genePred *gp = genePredLoad(row);    int i;    int exonCount = gp->exonCount;    for (i=0; i<exonCount; ++i)        rangeTreeAdd(rt, gp->exonStarts[i], gp->exonEnds[i]);    }uglyTime("Add rows");struct range *list = rangeTreeList(rt);uglyTime("Did list");uglyf("%d items in chrom %s/n", slCount(list), chrom);}

void loadFaSeq(struct hash *faHash, char *newName, char strand, 	char **pName, struct dnaSeq **pSeq, char *pStrand)/* retrieve sequence from hash.  Reverse complement * if necessary. */{struct dnaSeq *seq;if (sameString(newName, *pName))    {    if (strand != *pStrand)        {	seq = *pSeq;	reverseComplement(seq->dna, seq->size);	*pStrand = strand;	}    }else    {    char fileName[512];    *pName = newName;    *pSeq = seq = hashFindVal(faHash, newName);    *pStrand = strand;    if (strand == '-')        reverseComplement(seq->dna, seq->size);    uglyf("Loaded %d bases from %s fa/n", seq->size, newName);    }}

void splitSim(char *XXX)/* splitSim - Simulate gapless distribution size. */{int splitCount = simSize / aveSize;bool *splitBuf = needMem(simSize+1);int start = 0, size;int i;uglyf("split count %d/n", splitCount);for (i=0; i<splitCount; ++i)     {     for (;;)	 {	 int rPos = random()%simSize;	 if (splitBuf[rPos] == 0)	     {	     splitBuf[rPos] = 1;	     break;	     }	 }     }splitBuf[simSize] = 1;start = 0;for (i=0; i<=simSize; ++i)    {    if (splitBuf[i])        {	size = i - start;	if (size < countCount)	     counts[size] += 1;	start = i;	}    }for (i=0; i<countCount; ++i)    printf("%3d %6d/n", i, counts[i]);}

int main(int argc, char *argv[]){char *rerunDir = "/projects/cc/hg/gs.2/g2g/g2g.fix";FILE *f = mustOpen("/projects/cc/hg/gs.2/g2g/g2g.fix/makeFix.con", "w");char *inName = "/projects/cc/hg/gs.2/g2g/miss.txt";struct lineFile *lf = lineFileOpen(inName, TRUE);int wordCount, lineSize, len;char *line, *words[16];char *a, *b;char *s;char both[32];while (lineFileNext(lf, &line, &lineSize))    {    s = strchr(line, ':');    if (s == NULL)	continue;    *s = 0;    a = line;    b = strchr(a, '_');    if (b == NULL)	errAbort("Expecting '_' in first word line %d of %s", lf->lineIx, lf->fileName);    *b++ = 0;    sprintf(both, "%s_%s", a, b);    uglyf("Processing %s/n", both);    fprintf(f, "log = %s/log/%s/n", rerunDir, both);    fprintf(f, "error = %s/err/%s/n", rerunDir, both);    fprintf(f, "output = %s/out/%s/n", rerunDir, both);    fprintf(f, "arguments = in/%s in/%s g2g /var/tmp/hg/h/11.ooc %s/psl/%s.psl/n",    	a, b, rerunDir, both);    fprintf(f, "queue 1/n/n");    }}

void loadIfNewSeq(char *nibDir, char *newName, char strand, 	char **pName, struct dnaSeq **pSeq, char *pStrand)/* Load sequence unless it is already loaded.  Reverse complement * if necessary. */{struct dnaSeq *seq;if (sameString(newName, *pName))    {    if (strand != *pStrand)        {	seq = *pSeq;	reverseComplement(seq->dna, seq->size);	*pStrand = strand;	}    }else    {    char fileName[512];    freeDnaSeq(pSeq);    snprintf(fileName, sizeof(fileName), "%s/%s.nib", nibDir, newName);    *pName = newName;    *pSeq = seq = nibLoadAllMasked(NIB_MASK_MIXED, fileName);    *pStrand = strand;    if (strand == '-')        reverseComplement(seq->dna, seq->size);    uglyf("Loaded %d bases in %s/n", seq->size, fileName);    }}

void fakeChromLinkage(char *database, char *chrom, FILE *f)/* Generate fake linkage data for one chromosome */{int size = hdbChromSize(database, chrom);int stepSize = 5000000;int pos;uglyf("faking %s %d/n", chrom, size);struct sqlConnection *conn = hAllocConn();for (pos=0; pos<size; pos += stepSize)    {    int rowOffset = 0;    char query[512];    sqlSafef(query, sizeof(query), "select name from stsMap where chrom='%s' and chromStart >= %d && chromStart < %d", chrom, pos, pos+stepSize);    struct sqlResult *sr = sqlGetResult(conn, query);    char **row = sqlNextRow(sr);    if (row != NULL)        {	double x;	if (rand()%250 == 0)	    {	    x = 3.5 + (double)rand()/RAND_MAX;	    }	else	    {	    x = (double)rand() / RAND_MAX + 0.001;	    x = log(x) + 1;	    if (x < -1)	       x = -1;	    }        fprintf(f, "%s/t%f/n", row[0], x);	}    sqlFreeResult(&sr);    }hFreeConn(&conn);}

static void getCloneDna(struct clone *clone, struct hash *fragHash)/* Read in clone DNA from file in format with one record per * clone contig.   Make clone->dna so that it is same as * non-fragmented clone file. */{struct dnaSeq *seqList = faReadAllDna(clone->faFile), *seq;int fragSize;clone->dna = needLargeMem(clone->size+1);clone->dna[clone->size] = 0;uglyf("GetCloneDna %s/n", clone->faFile);for (seq = seqList; seq != NULL; seq = seq->next)    {    struct frag *frag = hashFindVal(fragHash, seq->name);    if (frag == NULL)        errAbort("Couldn't find %s from %s in trans files", seq->name, clone->faFile);    assert(frag->end <= clone->size);    fragSize = frag->end - frag->start;    assert(fragSize >= 0);    if (fragSize != seq->size)        errAbort("Size mismatch (%d vs %d) between trans and .ffa files on %s", 		fragSize, seq->size, frag->name);    memcpy(clone->dna + frag->start,  seq->dna,  fragSize);    }freeDnaSeqList(&seqList);}

void doItPromoterBed(struct inInfo *in, struct bed *chiaList, double *out1, double *out2)/* Process overlaps with promoters defined by a gene bed file. */{struct genomeRangeTree *grt = grtFromOpenBed(in->lf, 12, TRUE);outputOverlappingGrt(chiaList, grt, out1, out2);uglyf("done %s/n", in->fileName);}

void testDbSorts(struct htmlPage *dbPage, char *org, char *db, 	char *accColumn, struct slName *geneList)/* Test on one database. */{struct htmlPage *emptyConfig;struct htmlFormVar *sortVar = htmlFormVarGet(dbPage->forms, orderVarName);struct slName *gene, *sort;uglyf("testDbSorts %s %s/n", org, db);if (sortVar == NULL)    errAbort("Couldn't find var %s", orderVarName);emptyConfig = emptyConfigPage(dbPage, org, db);if (emptyConfig != NULL)    {    for (sort = sortVar->values; sort != NULL; sort= sort->next)	{	for (gene = geneList; gene != NULL; gene = gene->next)	    {	    testSort(emptyConfig, org, db, sort->name, gene->name, accColumn);	    }	}    htmlPageFree(&emptyConfig);    }}

struct fullExperiment *getGoodExperiments(struct sqlConnection *conn, struct edwExperiment *eeList,    char *assembly)/* Get list of experiments that are good in the sense of being replicated and having * bam,broadPeak and so forth all from hotspot  in the same run */{uglyf("Got %d on eeList/n", slCount(eeList));struct fullExperiment *fullList = getFullExperimentList(conn, eeList, assembly, NULL);uglyf("Got %d on fullList/n", slCount(fullList));int replicatedCount = 0, goodCount = 0, goodIndividualRepCount = 0, totalRepCount = 0;struct fullExperiment *full, *next, *goodList = NULL, *badList = NULL;for (full = fullList; full != NULL; full = next)     {     next = full->next;     int repCount = slCount(full->repList);     totalRepCount += repCount;     if (repCount > 0)         {	 uglyf("%s %d/n", full->exp->accession, repCount);	 if (repCount > 1)	     ++replicatedCount;	 int goodRepCount = 0;	 struct replicate *r;	 for (r = full->repList; r != NULL; r = r->next)	     {	     if (replicateIsComplete(conn, r))	         {		 ++goodRepCount;		 ++goodIndividualRepCount;		 }	     }	 if (goodRepCount >= 2)	     {	     ++goodCount;	     slAddHead(&goodList, full);	     }         else	     slAddHead(&badList, full);	 }     }slReverse(&goodList);uglyf("%d replicates %d are good/n", totalRepCount, goodIndividualRepCount);uglyf("%d replicated experiments,  %d of which look good/n", replicatedCount, goodCount);return goodList;}

void chopFaLines(char *inName, char *outName)/* chopFaLines - Read in FA file with long lines and rewrite it with shorter lines. */{FILE *in = mustOpen(inName, "r");FILE *out = mustOpen(outName, "w");char *commentLine;struct dnaSeq *seq;while (faReadNext(in, NULL, TRUE, &commentLine, &seq))    {    commentLine = trimSpaces(commentLine+1);    uglyf(">%s/n", commentLine);    mustWrite(uglyOut, seq->dna, 100);    uglyf("/n");    uglyAbort("All for now");    faWriteNext(out, commentLine, seq->dna, seq->size);    }}

double paranoidSqrt(double x)/* There seems to be a bug in MS's square-root that enclosing it in * a subroutine avoids. */{double y = sqrt(x);if (fabs(y*y - x) > 0.001)    uglyf("sqrt(%f) = %f !?? /n", x, y);return y;}

void setupHugeGaps(char *insertFile)/* Setup things to lookup gaps. */{struct lineFile *lf;char *words[8];int wordCount;struct chromGaps *chromList = NULL, *cg;struct hugeGap *gap;char *chrom;char query[512];struct sqlResult *sr;char **row;struct ctgPos ctgPos;int start, size;struct hashEl *hel;struct sqlConnection *conn = sqlConnect("hg4");hugeHash = newHash(6);lf = lineFileOpen(insertFile, TRUE);while ((wordCount = lineFileChop(lf, words)) != 0)     {     chrom = words[0];     if (sameString(words[2], "-"))         continue;     if ((cg = hashFindVal(hugeHash, chrom)) == NULL)         {	 AllocVar(cg);	 slAddHead(&chromList, cg);	 hel = hashAdd(hugeHash, chrom, cg);	 cg->chrom = hel->name;	 }     size = atoi(words[3]);     sqlSafef(query, sizeof query, "select * from ctgPos where contig = '%s'", words[2]);     sr = sqlGetResult(conn, query);     if ((row = sqlNextRow(sr)) == NULL)        errAbort("Couldn't find %s from %s in database", words[2], lf->fileName);     ctgPosStaticLoad(row, &ctgPos);     if (!sameString(chrom, ctgPos.chrom))         errAbort("%s is in %s in database and %s in %s", ctgPos.contig, ctgPos.chrom,	 	chrom, lf->fileName);     start = ctgPos.chromStart;     uglyf("%s %s (%d size %d) %s /n", chrom, words[1], start, size, words[2]);     sqlFreeResult(&sr);     AllocVar(gap);     slAddHead(&cg->gapList, gap);     gap->offset = start;     gap->size = size;     }lineFileClose(&lf);sqlDisconnect(&conn);for (cg = chromList; cg != NULL; cg = cg->next)    {    slSort(&cg->gapList, cmpHugeGap);    }}

struct hash *hashPsls(char *fileName)/* Return hash of all psls in file. */{struct psl *pslList = pslLoadAll(fileName), *psl;struct hash *hash = newHash(20);for (psl = pslList; psl != NULL; psl = psl->next)    hashAdd(hash, psl->qName, psl);uglyf("Loaded %d psls from %s/n", slCount(pslList), fileName);return hash;}

void constraintsForBac(char *bacAcc, char *outDir)/* Generate a set of constraint files for bac. */{struct ggMrnaInput *ci = ggGetMrnaForBac(bacAcc);struct ggMrnaCluster *mc, *mcList = ggClusterMrna(ci);struct geneGraph *gg;uglyf("Got %d clusters/n", slCount(mcList));for (mc = mcList; mc != NULL; mc = mc->next)    {    uglyf("Initial input/n");    dumpMc(mc);    uglyf("/n");    gg = ggGraphCluster(mc, ci);    uglyf("Constraints/n");    traverseGeneGraph(gg, mc->tStart, mc->tEnd, dumpGgAliInfo);    uglyf("/n/n");    }}

void gifTest(){static char *labels[] = {"cerebellum", "thymus", "breast", "heart",			 "stomach", "cartilage", "kidney", "liver",			 "lung", "testis", "black hole" };int size = gifLabelMaxWidth(labels, ArraySize(labels));int gifLabelMaxWidth(char **labels, int labelCount)gifLabelVerticalText("../trash/foo.gif", labels, ArraySize(labels), size);uglyf("<IMG SRC=/"../trash/foo.gif/">");}

void printListVals(struct sageCounts *scList, int index){struct sageCounts *sc = NULL;struct sortable *s=NULL, *sList = NULL, *next = NULL;for(sc = scList; sc != NULL; sc = sc->next)    {    AllocVar(s);    s->val = sc->expCounts[index];    slAddHead(&sList,s);    }slSort(&sList,compSortable);for(s = sList; s!= NULL; s=s->next)    uglyf("%d,",s->val);uglyf("/n");for(s=sList; s != NULL; s = next)    {    next = s->next;    freez(&s);    }}