struct slName *subtractLists(struct slName *listA, struct slName *listB)
/* Subtract two lists. */
{
struct hash *theHash = hashList(listB);
struct slName *diffList = NULL, *cur;
for (cur = listA; cur != NULL; cur = cur->next)
{
if (hashLookup(theHash, cur->name) == NULL)
slNameAddHead(&diffList, cur->name);
}
freeHashAndVals(&theHash);
slReverse(&diffList);
return diffList;
}
void htmlPageFree(struct htmlPage **pPage)
/* Free up resources associated with htmlPage. */
{
struct htmlPage *page = *pPage;
if (page != NULL)
{
freez(&page->url);
htmlStatusFree(&page->status);
freeHashAndVals(&page->header);
htmlCookieFreeList(&page->cookies);
freez(&page->fullText);
htmlTagFreeList(&page->tags);
htmlFormFreeList(&page->forms);
freez(pPage);
}
}
void parseBoulderIo(char *fileName, struct cassetteSeq *cseq)
/* Open fileName and parse the information to fill in cseq */
{
struct hash *bioHash = newHash(10);
char *tmp = NULL;
fillInBioHash(fileName, bioHash);
cseq->leftPrimer = cloneString(hashFindVal(bioHash, "PRIMER_LEFT_SEQUENCE"));
cseq->rightPrimer = cloneString(hashFindVal(bioHash, "PRIMER_RIGHT_SEQUENCE"));
tmp = hashFindVal(bioHash, "PRIMER_LEFT");
if(tmp != NULL)
cseq->lpStart = atoi(tmp);
tmp = hashFindVal(bioHash, "PRIMER_RIGHT");
if(tmp != NULL)
cseq->rpStart = atoi(tmp);
freeHashAndVals(&bioHash);
}
void joinerFree(struct joiner **pJoiner)
/* Free up memory associated with joiner */
{
struct joiner *joiner = *pJoiner;
if (joiner != NULL)
{
freeMem(joiner->fileName);
joinerSetFreeList(&joiner->jsList);
freeHashAndVals(&joiner->symHash);
hashFreeList(&joiner->exclusiveSets);
freeHash(&joiner->databasesChecked);
freeHash(&joiner->databasesIgnored);
joinerDependencyFreeList(&joiner->dependencyList);
joinerIgnoreFreeList(&joiner->tablesIgnored);
freez(pJoiner);
}
}
static void freeMimeParts(struct mimePart **pMp)
/* free struct mimePart* recursively if needed */
{
struct mimePart *next = NULL, *mp = *pMp;
while (mp)
{
next = mp->next;
if (mp->multi)
freeMimeParts(&mp->multi);
freeHashAndVals(&mp->hdr);
freez(&mp->data);
freez(&mp->fileName);
freez(pMp);
mp = next;
pMp = ∓
}
}
struct slName *intersectFiles(struct slName *fileList)
/* Successively intersect files. */
{
struct slName *isectList = slNameLoadReal(fileList->name);
struct slName *curFile = fileList->next;
struct slName *cur;
while (curFile != NULL)
{
struct hash *isectHash = hashList(isectList);
struct slName *someWords = slNameLoadReal(curFile->name);
struct slName *bothWords = thoseInHash(isectHash, someWords, FALSE);
slNameFreeList(&someWords);
slNameFreeList(&isectList);
isectList = bothWords;
freeHashAndVals(&isectHash);
curFile = curFile->next;
}
return isectList;
}
struct lineFile *emblOpen(char *fileName, char type[256])
/* Open up embl file, verify format and optionally return
* type (VV line). Close this with lineFileClose(). */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
struct hash *hash = emblRecord(lf);
char *vv;
if (hash == NULL)
notEmbl(fileName);
if ((vv = hashFindVal(hash, "VV")) == NULL)
notEmbl(fileName);
if (type != NULL)
{
if (strlen(vv) >= 256)
notEmbl(fileName);
strcpy(type, vv);
}
freeHashAndVals(&hash);
return lf;
}
struct hash *ensPepToKnown(struct sqlConnection *conn, boolean chopVersion)
/* Create hash keyed by ensembl peptide with knownGene ID value. */
{
struct sqlResult *sr;
char **row;
struct hash *hash = newHash(16);
struct hash *tnToPep =
hashTwoColumn(conn, "NOSQLINJ select transcript,protein from ensGtp", chopVersion);
sr = sqlGetResult(conn, "NOSQLINJ select name,value from knownToEnsembl");
while ((row = sqlNextRow(sr)) != NULL)
{
char *protein;
if (chopVersion)
chopSuffix(row[1]);
protein = hashFindVal(tnToPep, row[1]);
if (protein != NULL)
hashAdd(hash, protein, cloneString(row[0]));
}
sqlFreeResult(&sr);
freeHashAndVals(&tnToPep);
return hash;
}
void wigToBedGraph(char *wigIn, char *bedOut)
/* wigToBedGraph - Convert wig files to bedGraph, merging adjacent items with identical values
* when possible.. */
{
struct lineFile *lf = lineFileOpen(wigIn, TRUE);
FILE *f = mustOpen(bedOut, "w");
struct bgOut *out = bgOutNew(f);
char *line;
while (lineFileNextReal(lf, &line))
{
char *firstWord = nextWord(&line);
struct hash *vars = hashVarLine(line, lf->lineIx);
if (sameString("fixedStep", firstWord))
convertFixedStepSection(lf, vars, out);
else if (sameString("variableStep", firstWord))
convertVariableStepSection(lf, vars, out);
else
errAbort("Expecting fixedStep or variableStep line %d of %s, got:\n\t%s", lf->lineIx,
lf->fileName, line);
freeHashAndVals(&vars);
}
bgOutFree(&out);
carefulClose(&f);
}
void processRefSeq(char *database, char *faFile, char *raFile, char *pslFile, char *loc2refFile,
char *pepFile, char *mim2locFile)
/* hgRefSeqMrna - Load refSeq mRNA alignments and other info into
* refSeqGene table. */
{
struct lineFile *lf;
struct hash *raHash, *rsiHash = newHash(0);
struct hash *loc2mimHash = newHash(0);
struct refSeqInfo *rsiList = NULL, *rsi;
char *s, *line, *row[5];
int wordCount, dotMod = 0;
int noLocCount = 0;
int rsiCount = 0;
int noProtCount = 0;
struct psl *psl;
struct sqlConnection *conn = hgStartUpdate(database);
struct hash *productHash = loadNameTable(conn, "productName", 16);
struct hash *geneHash = loadNameTable(conn, "geneName", 16);
char *kgName = "refGene";
FILE *kgTab = hgCreateTabFile(".", kgName);
FILE *productTab = hgCreateTabFile(".", "productName");
FILE *geneTab = hgCreateTabFile(".", "geneName");
FILE *refLinkTab = hgCreateTabFile(".", "refLink");
FILE *refPepTab = hgCreateTabFile(".", "refPep");
FILE *refMrnaTab = hgCreateTabFile(".", "refMrna");
struct exon *exonList = NULL, *exon;
char *answer;
char cond_str[200];
/* Make refLink and other tables table if they don't exist already. */
sqlMaybeMakeTable(conn, "refLink", refLinkTableDef);
sqlUpdate(conn, "NOSQLINJ delete from refLink");
sqlMaybeMakeTable(conn, "refGene", refGeneTableDef);
sqlUpdate(conn, "NOSQLINJ delete from refGene");
sqlMaybeMakeTable(conn, "refPep", refPepTableDef);
sqlUpdate(conn, "NOSQLINJ delete from refPep");
sqlMaybeMakeTable(conn, "refMrna", refMrnaTableDef);
sqlUpdate(conn, "NOSQLINJ delete from refMrna");
/* Scan through locus link to omim ID file and put in hash. */
{
char *row[2];
printf("Scanning %s\n", mim2locFile);
lf = lineFileOpen(mim2locFile, TRUE);
while (lineFileRow(lf, row))
{
hashAdd(loc2mimHash, row[1], intToPt(atoi(row[0])));
}
lineFileClose(&lf);
}
/* Scan through .ra file and make up start of refSeqInfo
* objects in hash and list. */
printf("Scanning %s\n", raFile);
lf = lineFileOpen(raFile, TRUE);
while ((raHash = hashNextRa(lf)) != NULL)
{
if (clDots > 0 && ++dotMod == clDots )
{
dotMod = 0;
dotOut();
}
AllocVar(rsi);
slAddHead(&rsiList, rsi);
if ((s = hashFindVal(raHash, "acc")) == NULL)
errAbort("No acc near line %d of %s", lf->lineIx, lf->fileName);
rsi->mrnaAcc = cloneString(s);
if ((s = hashFindVal(raHash, "siz")) == NULL)
errAbort("No siz near line %d of %s", lf->lineIx, lf->fileName);
rsi->size = atoi(s);
if ((s = hashFindVal(raHash, "gen")) != NULL)
rsi->geneName = cloneString(s);
//!!!else
//!!! warn("No gene name for %s", rsi->mrnaAcc);
if ((s = hashFindVal(raHash, "cds")) != NULL)
parseCds(s, 0, rsi->size, &rsi->cdsStart, &rsi->cdsEnd);
else
rsi->cdsEnd = rsi->size;
if ((s = hashFindVal(raHash, "ngi")) != NULL)
rsi->ngi = atoi(s);
rsi->geneNameId = putInNameTable(geneHash, geneTab, rsi->geneName);
s = hashFindVal(raHash, "pro");
if (s != NULL)
rsi->productName = cloneString(s);
rsi->productNameId = putInNameTable(productHash, productTab, s);
hashAdd(rsiHash, rsi->mrnaAcc, rsi);
freeHashAndVals(&raHash);
}
lineFileClose(&lf);
if (clDots) printf("\n");
/* Scan through loc2ref filling in some gaps in rsi. */
printf("Scanning %s\n", loc2refFile);
lf = lineFileOpen(loc2refFile, TRUE);
while (lineFileNext(lf, &line, NULL))
{
char *mrnaAcc;
if (line[0] == '#')
continue;
wordCount = chopTabs(line, row);
if (wordCount < 5)
errAbort("Expecting at least 5 tab-separated words line %d of %s",
lf->lineIx, lf->fileName);
mrnaAcc = row[1];
mrnaAcc = accWithoutSuffix(mrnaAcc);
if (mrnaAcc[2] != '_')
warn("%s is and odd name %d of %s",
mrnaAcc, lf->lineIx, lf->fileName);
if ((rsi = hashFindVal(rsiHash, mrnaAcc)) != NULL)
{
rsi->locusLinkId = lineFileNeedNum(lf, row, 0);
rsi->omimId = ptToInt(hashFindVal(loc2mimHash, row[0]));
rsi->proteinAcc = cloneString(accWithoutSuffix(row[4]));
}
}
lineFileClose(&lf);
/* Report how many seem to be missing from loc2ref file.
* Write out knownInfo file. */
printf("Writing %s\n", "refLink.tab");
for (rsi = rsiList; rsi != NULL; rsi = rsi->next)
{
++rsiCount;
if (rsi->locusLinkId == 0)
++noLocCount;
if (rsi->proteinAcc == NULL)
++noProtCount;
fprintf(refLinkTab, "%s\t%s\t%s\t%s\t%u\t%u\t%u\t%u\n",
emptyForNull(rsi->geneName),
emptyForNull(rsi->productName),
emptyForNull(rsi->mrnaAcc),
emptyForNull(rsi->proteinAcc),
rsi->geneNameId, rsi->productNameId,
rsi->locusLinkId, rsi->omimId);
}
if (noLocCount)
printf("Missing locusLinkIds for %d of %d\n", noLocCount, rsiCount);
if (noProtCount)
printf("Missing protein accessions for %d of %d\n", noProtCount, rsiCount);
/* Process alignments and write them out as genes. */
lf = pslFileOpen(pslFile);
dotMod = 0;
while ((psl = pslNext(lf)) != NULL)
{
if (hashFindVal(rsiHash, psl->qName) != NULL)
{
if (clDots > 0 && ++dotMod == clDots )
{
dotMod = 0;
dotOut();
}
sqlSafefFrag(cond_str, sizeof cond_str, "extAC='%s'", psl->qName);
answer = sqlGetField(proteinDB, "spXref2", "displayID", cond_str);
if (answer == NULL)
{
fprintf(stderr, "%s NOT FOUND.\n", psl->qName);
fflush(stderr);
}
if (answer != NULL)
{
struct genePred *gp = NULL;
exonList = pslToExonList(psl);
fprintf(kgTab, "%s\t%s\t%c\t%d\t%d\t",
psl->qName, psl->tName, psl->strand[0], psl->tStart, psl->tEnd);
rsi = hashMustFindVal(rsiHash, psl->qName);
gp = genePredFromPsl(psl, rsi->cdsStart, rsi->cdsEnd, genePredStdInsertMergeSize);
if (!gp)
errAbort("Cannot convert psl (%s) to genePred.\n", psl->qName);
fprintf(kgTab, "%d\t%d\t", gp->cdsStart, gp->cdsEnd);
fprintf(kgTab, "%d\t", slCount(exonList));
fflush(kgTab);
for (exon = exonList; exon != NULL; exon = exon->next)
fprintf(kgTab, "%d,", exon->start);
fprintf(kgTab, "\t");
for (exon = exonList; exon != NULL; exon = exon->next)
fprintf(kgTab, "%d,", exon->end);
fprintf(kgTab, "\n");
slFreeList(&exonList);
}
}
else
{
fprintf(stderr, "%s found in psl, but not in .fa or .ra data files.\n", psl->qName);
fflush(stderr);
}
}
if (clDots) printf("\n");
if (!clTest)
{
writeSeqTable(pepFile, refPepTab, FALSE, TRUE);
writeSeqTable(faFile, refMrnaTab, FALSE, FALSE);
}
carefulClose(&kgTab);
carefulClose(&productTab);
carefulClose(&geneTab);
carefulClose(&refLinkTab);
carefulClose(&refPepTab);
carefulClose(&refMrnaTab);
if (!clTest)
{
printf("Loading database with %s\n", kgName);
fflush(stdout);
hgLoadTabFile(conn, ".", kgName, NULL);
printf("Loading database with %s\n", "productName");
fflush(stdout);
hgLoadTabFile(conn, ".", "productName", NULL);
printf("Loading database with %s\n", "geneName");
fflush(stdout);
hgLoadTabFile(conn, ".", "geneName", NULL);
printf("Loading database with %s\n", "refLink");
fflush(stdout);
hgLoadTabFile(conn, ".", "refLink", NULL);
printf("Loading database with %s\n", "refPep");
fflush(stdout);
hgLoadTabFile(conn, ".", "refPep", NULL);
printf("Loading database with %s\n", "refMrna");
fflush(stdout);
hgLoadTabFile(conn, ".", "refMrna", NULL);
}
}
static struct linkedFeatures *cgapSageToLinkedFeatures(struct cgapSage *tag,
struct hash *libHash, struct hash *libTotHash, enum trackVisibility vis)
/* Convert a single CGAP tag to a list of linkedFeatures. */
{
struct linkedFeatures *libList = NULL;
struct linkedFeatures *skel = skeletonLf(tag);
int i;
if (vis == tvDense)
/* Just use the skeleton one. */
{
int tagTotal = 0;
int freqTotal = 0;
int libsUsed = 0;
for (i = 0; i < tag->numLibs; i++)
{
char libId[16];
char *libName;
safef(libId, sizeof(libId), "%d", tag->libIds[i]);
libName = hashMustFindVal(libHash, libId);
if (keepThisLib(libName, libId))
{
int libTotal = hashIntVal(libTotHash, libId);
tagTotal += libTotal;
freqTotal += tag->freqs[i];
libsUsed++;
}
}
if (libsUsed > 0)
{
skel->name = cloneString("whatever");
skel->score = (float)((double)freqTotal * (1000000/tagTotal));
skel->grayIx = grayIxForCgap(skel->score);
addSimpleFeature(skel);
libList = skel;
}
}
else if (vis == tvPack)
{
/* If it's pack mode, average tissues into one linkedFeature. */
struct hash *tpmHash = combineCgapSages(tag, libHash, libTotHash);
struct hashEl *tpmList = hashElListHash(tpmHash);
struct hashEl *tpmEl;
slSort(&tpmList, slNameCmp);
for (tpmEl = tpmList; tpmEl != NULL; tpmEl = tpmEl->next)
{
struct linkedFeatures *tiss = CloneVar(skel);
struct cgapSageTpmHashEl *tpm = (struct cgapSageTpmHashEl *)tpmEl->val;
char link[256];
char *encTissName = NULL;
double score = 0;
int len = strlen(tpmEl->name) + 32;
tiss->name = needMem(len);
safef(tiss->name, len, "%s (%d)", tpmEl->name, tpm->count);
encTissName = cgiEncode(tpmEl->name);
safef(link, sizeof(link), "i=%s&tiss=%s", tag->name, encTissName);
score = (double)tpm->freqTotal*(1000000/(double)tpm->libTotals);
tiss->score = (float)score;
tiss->grayIx = grayIxForCgap(score);
tiss->extra = cloneString(link);
freeMem(encTissName);
addSimpleFeature(tiss);
slAddHead(&libList, tiss);
}
hashElFreeList(&tpmList);
freeHashAndVals(&tpmHash);
}
else
/* full mode */
{
for (i = 0; i < tag->numLibs; i++)
{
char libId[16];
char *libName;
char link[256];
struct linkedFeatures *lf;
safef(libId, sizeof(libId), "%d", tag->libIds[i]);
libName = hashMustFindVal(libHash, libId);
if (keepThisLib(libName, libId))
{
lf = CloneVar(skel);
lf->name = cloneString(libName);
safef(link, sizeof(link), "i=%s&lib=%s", tag->name, libId);
lf->score = (float)tag->tagTpms[i];
lf->grayIx = grayIxForCgap(tag->tagTpms[i]);
lf->extra = cloneString(link);
addSimpleFeature(lf);
slAddHead(&libList, lf);
}
}
}
slSort(&libList, cgapLinkedFeaturesCmp);
slReverse(&libList);
return libList;
}
void execProc(char *managingHost, char *jobIdString, char *reserved,
char *user, char *dir, char *in, char *out, char *err, long long memLimit,
char *exe, char **params)
/* This routine is the child process of doExec.
* It spawns a grandchild that actually does the
* work and waits on it. It sends message to the
* main message loop here when done. */
{
if ((grandChildId = forkOrDie()) == 0)
{
char *homeDir = "";
/* Change to given user (if root) */
changeUid(user, &homeDir);
/* create output files just after becoming user so that errors in the rest
* of this proc will go to the err file and be available via para
* problems */
setupProcStdio(in, out, err);
if (chdir(dir) < 0)
errnoAbort("can't chdir to %s", dir);
setsid();
// setpgid(0,0);
umask(umaskVal);
struct rlimit rlim;
rlim.rlim_cur = rlim.rlim_max = memLimit;
if(setrlimit(RLIMIT_CORE, &rlim) < 0)
perror("setrlimit");
/* Update environment. */
{
struct hash *hash = environToHash(environ);
hashUpdate(hash, "JOB_ID", jobIdString);
hashUpdate(hash, "USER", user);
hashUpdate(hash, "HOME", homeDir);
hashUpdate(hash, "HOST", hostName);
hashUpdate(hash, "PARASOL", "7");
updatePath(hash, userPath, homeDir, sysPath);
addEnvExtras(hash);
environ = hashToEnviron(hash);
freeHashAndVals(&hash);
}
randomSleep(); /* Sleep a random bit before executing this thing
* to help spread out i/o when a big batch of jobs
* hit idle cluster */
execvp(exe, params);
errnoAbort("execvp'ing %s", exe);
}
else
{
/* Wait on executed job and send jobID and status back to
* main process. */
int status = -1;
int cid;
struct paraMessage pm;
struct rudp *ru = NULL;
struct tms tms;
unsigned long uTime = 0;
unsigned long sTime = 0;
if (grandChildId >= 0)
{
signal(SIGTERM, termHandler);
cid = waitpid(grandChildId, &status, 0);
if (cid < 0)
errnoAbort("wait on grandchild failed");
times(&tms);
uTime = ticksToHundreths*tms.tms_cutime;
sTime = ticksToHundreths*tms.tms_cstime;
}
ru = rudpOpen();
if (ru != NULL)
{
ru->maxRetries = 20;
pmInit(&pm, localIp, paraNodePort);
pmPrintf(&pm, "jobDone %s %s %d %lu %lu", managingHost,
jobIdString, status, uTime, sTime);
pmSend(&pm, ru);
rudpClose(&ru);
}
}
}
/* convolve() - perform the task on the input data
* I would like to rearrange this business here, and instead of
* reading in the data and leaving it in the hash for all other
* routines to work with, it would be best to get it immediately
* into an array. That makes the work of the other routines much
* easier.
*/
static void convolve(int argc, char *argv[])
{
int i;
struct lineFile *lf; /* for line file utilities */
for (i = 1; i < argc; ++i)
{
int lineCount = 0; /* counting input lines */
char *line = (char *)NULL; /* to receive data input line */
char *words[128]; /* to split data input line */
int wordCount = 0; /* result of split */
struct hash *histo0; /* first histogram */
struct hash *histo1; /* second histogram */
int medianBin0 = 0; /* bin at median for histo0 */
double medianLog_2 = -500.0; /* log at median */
int bin = 0; /* 0 to N-1 for N bins */
int convolutions = 0; /* loop counter for # of convolutions */
histo0 = newHash(0);
lf = lineFileOpen(argv[i], TRUE); /* input file */
verbose(1, "Processing %s\n", argv[1]);
while (lineFileNext(lf, &line, NULL))
{
int j; /* loop counter over words */
int inputValuesCount = 0;
struct histoGram *hg; /* an allocated hash element */
++lineCount;
chopPrefixAt(line, '#'); /* ignore any comments starting with # */
if (strlen(line) < 3) /* anything left on this line ? */
continue; /* no, go to next line */
wordCount = chopByWhite(line, words, 128);
if (wordCount < 1)
warn("Expecting at least a word at line %d, file: %s, found %d words",
lineCount, argv[i], wordCount);
if (wordCount == 128)
warn("May have more than 128 values at line %d, file: %s", lineCount, argv[i]);
verbose(2, "Input data read from file: %s\n", argv[i]);
for (j = 0; j < wordCount; ++j)
{
char binName[128];
double dataValue;
double probInput;
double log_2;
dataValue = strtod(words[j], NULL);
++inputValuesCount;
if (logs)
{
log_2 = dataValue;
probInput = pow(2.0,log_2);
} else {
if (dataValue > 0.0)
{
log_2 = log2(dataValue);
probInput = dataValue;
} else {
log_2 = -500.0; /* arbitrary limit */
probInput = pow(2.0,log_2);
}
}
if (log_2 > medianLog_2)
{
medianLog_2 = log_2;
medianBin0 = bin;
}
verbose(2, "bin %d: %g %0.5g\n",
inputValuesCount-1, probInput, log_2);
AllocVar(hg); /* the histogram element */
hg->bin = bin;
hg->prob = probInput;
hg->log_2 = log_2;
snprintf(binName, sizeof(binName), "%d", hg->bin);
hashAdd(histo0, binName, hg);
++bin;
} /* for each word on an input line */
} /* for each line in a file */
/* file read complete, echo input */
if (verboseLevel() >= 2)
printHistogram(histo0, medianBin0);
/* perform convolutions to specified count
* the iteration does histo0 with itself to produce histo1
* Then histo0 is freed and histo1 copied to it for the
* next loop.
*/
for (convolutions = 0; convolutions < convolve_count; ++convolutions)
{
int medianBin;
histo1 = newHash(0);
medianBin = iteration(histo0, histo1);
if (verboseLevel() >= 2)
printHistogram(histo1, medianBin);
freeHashAndVals(&histo0);
histo0 = histo1;
}
} /* for each input file */
} /* convolve() */
int main(int argc, char *argv[])
{
struct lineFile *cgf, *clf, *mkf, *nmf, *acf, *usf;
FILE *bacAlias, *bacXRef;
int verb = 0;
char *dir, errorFile[256], aliasFile[256], xRefFile[256];
verboseSetLevel(0);
optionInit(&argc, argv, optionSpecs);
if (argc != 8)
{
fprintf(stdout, "USAGE: formatZfishSts [-verbose=<level>] <contig file> <clone file> <marker file> <list of BACs and chroms> <accessions> <UniSTS IDs file><output directory>\n");
return 1;
}
verb = optionInt("verbose", 0);
verboseSetLevel(verb);
fprintf(stdout, "Opening and reading files ...\n");
cgf = lineFileOpen(argv[1], TRUE );
clf = lineFileOpen(argv[2], TRUE);
mkf = lineFileOpen(argv[3], TRUE);
nmf = lineFileOpen(argv[4], TRUE);
acf = lineFileOpen(argv[5], TRUE);
usf = lineFileOpen(argv[6], TRUE);
dir = cloneString(argv[7]);
sprintf(errorFile, "%s/error.log", dir);
sprintf(aliasFile, "%s/bacAlias.tab", dir);
sprintf(xRefFile, "%s/bacXRef.tab", dir);
fprintf(stdout, "files are error: %s, alias: %s and xRef: %s \n", errorFile, aliasFile, xRefFile);
stderr = mustOpen(errorFile, "w");
bacAlias = mustOpen(aliasFile, "w");
bacXRef = mustOpen(xRefFile, "w");
/* Read in contigs file with internal name, external name and FPC contig */
verbose(1, "Reading contig names file\n");
readContigs(cgf);
/* Read in internal BAC clone names and Sanger sts names */
verbose(1, "Reading BAC clone names and Sanger sts names\n");
readCloneNames(clf);
/* Read in BAC clone information: Sanger name, UniSTS ID and aliases */
verbose(1, "Reading markers file\n");
readMarkers(mkf);
/* Read in file of BAC clones names and chroms mapped to by blat */
verbose(1, "Reading file of BAC clone external names\n");
readBacNames(nmf);
/* Read in internal names and corresponding GenBank accessions */
verbose(1, "Reading accessions file\n");
readAccessions(acf);
/*Read file of UniSTS IDs and BAC Clone IDs */
verbose(1, "Reading UniSTS IDs file\n");
readUniStsIds(usf);
/* Print out the STS marker information to a file */
verbose(1, "Creating output file\n");
fprintf(stdout, "Printing tab files for bacCloneAlias and bacCloneXRef tables ...\n");
writeAliasTable(bacAlias);
writeXRefTable(bacXRef);
lineFileClose(&nmf);
lineFileClose(&cgf);
lineFileClose(&clf);
lineFileClose(&mkf);
lineFileClose(&acf);
lineFileClose(&usf);
carefulClose(&bacXRef);
carefulClose(&bacAlias);
carefulClose(&stderr);
freeHashAndVals(&bacHash);
freeHashAndVals(&extNameHash);
freeHashAndVals(&aliasHash);
freeHashAndVals(&sangerByExtNameHash);
return(0);
}
