void addClusterMapItem(struct hacTree *ht, int x1, int y1, int x2, int y2, struct titleHelper *helper)
/* If using imageV2, add mouseover text (no link) with info about this cluster. */
{
if (theImgBox && curImgTrack)
{
struct dyString *dy = dyStringNew(0);
struct hapCluster *c = (struct hapCluster *)ht->itemOrCluster;
dyStringPrintf(dy, "N=%d ", c->leafCount);
while (dyStringLen(dy) < 7)
dyStringAppendC(dy, ' ');
if (helper->startIx > 0)
dyStringAppend(dy, "...");
int i, nHapsForClustering = helper->endIx - helper->startIx;
for (i=0; i < nHapsForClustering; i++)
{
boolean isCenter = (helper->startIx+i == helper->centerIx);
char *allele = isRef(c, i) ? helper->refs[i] : helper->alts[i];
if (isCenter)
dyStringAppendC(dy, '[');
int altCount = c->leafCount - c->refCounts[i] - c->unkCounts[i];
if (c->refCounts[i] > 0 && altCount > 0)
dyStringAppendC(dy, '*');
else if (strlen(allele) == 1)
dyStringAppendC(dy, allele[0]);
else
dyStringPrintf(dy, "(%s)", allele);
if (isCenter)
dyStringAppendC(dy, ']');
}
if (helper->endIx < helper->nRecords)
dyStringAppend(dy, "...");
imgTrackAddMapItem(curImgTrack, TITLE_BUT_NO_LINK, dy->string,
x1, y1, x2, y2, helper->track);
}
}
void mapBoxForCenterVariant(struct vcfRecord *rec, struct hvGfx *hvg, struct track *tg,
int xOff, int yOff, int width)
/* Special mouseover for center variant */
{
struct dyString *dy = dyStringNew(0);
unsigned int chromStartMap = vcfRecordTrimIndelLeftBase(rec);
unsigned int chromEndMap = vcfRecordTrimAllelesRight(rec);
gtSummaryString(rec, dy);
dyStringAppend(dy, " Haplotypes sorted on ");
char *centerChrom = cartOptionalStringClosestToHome(cart, tg->tdb, FALSE, "centerVariantChrom");
if (centerChrom == NULL || !sameString(chromName, centerChrom))
dyStringAppend(dy, "middle variant by default. ");
else
dyStringAppend(dy, "this variant. ");
dyStringAppend(dy, "To anchor sorting to a different variant, click on that variant and "
"then click on the 'Use this variant' button below the variant name.");
const double scale = scaleForPixels(width);
int x1 = round((double)(rec->chromStart-winStart)*scale) + xOff;
int x2 = round((double)(rec->chromEnd-winStart)*scale) + xOff;
int w = x2-x1;
if (w <= 1)
{
x1--;
w = 3;
}
mapBoxHgcOrHgGene(hvg, chromStartMap, chromEndMap, x1, yOff, w, tg->height, tg->track,
rec->name, dy->string, NULL, TRUE, NULL);
}
char *getDescription(struct hash *ra,char *alternateSetting)
// Returns allocated string that is description. Will include DEPRECATED if appropriate
{
struct dyString *dyDescription = dyStringNew(256);
char *deprecated = hashFindVal(ra, "deprecated");
if (deprecated != NULL)
dyStringPrintf(dyDescription,"DEPRECATED - %s",deprecated);
char *description = hashFindVal(ra, CV_DESCRIPTION);
if (description == NULL && alternateSetting != NULL)
description = hashFindVal(ra, alternateSetting);
if (description == NULL)
description = hashFindVal(ra, CV_TITLE);
if (description == NULL)
description = hashFindVal(ra, CV_LABEL);
if (description != NULL)
{
if (dyStringLen(dyDescription) > 0)
dyStringAppend(dyDescription,"<BR>");
dyStringAppend(dyDescription,description);
}
if (dyStringLen(dyDescription) > 0)
return dyStringCannibalize(&dyDescription);
dyStringFree(&dyDescription);
return NULL;
}
static char *getPartPslFile(char *outDir, int partNum)
/* compute the name for the partition psl file, creating directories.
* freeMem result */
{
struct dyString *partPath = dyStringNew(128);
char partStr[64];
int i, partStrLen;
/* part number, with leading zeros */
safef(partStr, sizeof(partStr), "%0*d", gOutLevels, partNum);
partStrLen = strlen(partStr);
dyStringAppend(partPath, outDir);
makeDir(partPath->string);
/* create with multiple levels of directories, with least-signficant part of
* number being lowest directory */
for (i = 0; i < gOutLevels; i++)
{
dyStringAppendC(partPath, '/');
dyStringAppendC(partPath, partStr[(partStrLen-gOutLevels)+i]);
makeDir(partPath->string);
}
dyStringAppendC(partPath, '/');
dyStringAppend(partPath, partStr);
dyStringAppend(partPath, ".psl");
return dyStringCannibalize(&partPath);
}
static void appendMimeTerminus(struct dyString *dy, char *boundary)
/* Append MIME boundary terminator to dy. */
{
dyStringAppend(dy, "\r\n--");
dyStringAppend(dy, boundary);
dyStringAppend(dy, "--\r\n");
}
void writeGap(struct dyString *aRes, int aGap, char *aSeq, struct dyString *bRes, int bGap, char *bSeq)
/* Write double - gap. Something like:
* ....123.... or --c
* ...4123.... ag- */
{
char abbrev[16];
int minToAbbreviate = 16;
if (doShort && (aGap >= minToAbbreviate || bGap >= minToAbbreviate))
{
fillShortGapString(abbrev, aGap, '.', 13);
dyStringAppend(aRes, abbrev);
fillShortGapString(abbrev, bGap, '.', 13);
dyStringAppend(bRes, abbrev);
}
else
{
#ifdef OLD
dyStringAppendMultiC(aRes, '-', aGap);
dyStringAppendN(bRes, bSeq, aGap);
dyStringAppendN(aRes, aSeq, bGap);
dyStringAppendMultiC(bRes, '-', bGap);
#endif /* OLD */
dyStringAppendMultiC(aRes, '-', bGap);
dyStringAppendN(bRes, bSeq, bGap);
dyStringAppendN(aRes, aSeq, aGap);
dyStringAppendMultiC(bRes, '-', aGap);
}
}
int main(int argc, char *argv[])
/* Process command line. */
{
optionInit(&argc, argv, options);
if (argc != 5)
usage();
acceptString = optionVal("A", NULL);
if (acceptString)
{
acceptExtensionsCount = chopByChar(acceptString, ',', NULL, 0);
AllocArray(acceptExtensions, acceptExtensionsCount);
chopByChar(acceptString, ',', acceptExtensions, acceptExtensionsCount);
verbose(1, "accept-option count: %d\n", acceptExtensionsCount);
int i = 0;
for(i=0; i<acceptExtensionsCount; ++i)
{
verbose(2, "accept-option: %s\n", acceptExtensions[i]);
}
}
struct dyString *url = dyStringNew(4096);
struct dyString *outPath = dyStringNew(4096);
dyStringAppend(url, argv[3]);
dyStringAppend(outPath, argv[4]);
if (!paraSync(atoi(argv[1]), atoi(argv[2]), url, outPath, optionExists("newer"), optionExists("progress")))
exit(1);
return 0;
}
char *menuBarAddUiVars(char *oldString, char *cgiPrefix, char *uiVars)
/* Look for CGI program calls in oldString, and add session vars hgsid to them */
{
int len = strlen(oldString);
char buf[4096];
/* Create a regular expression and compile it */
regex_t re;
regmatch_t match[2];
safef(buf, sizeof(buf), "%s[A-Za-z]+(%c%c?)", cgiPrefix, '\\', '?');
int err = regcomp(&re, buf, REG_EXTENDED);
if(err)
errAbort("regcomp failed; err: %d", err);
/* Search through oldString with regex, and build up new string in dy */
struct dyString *dy = newDyString(0);
int offset;
for(offset = 0; offset < len && !regexec(&re, oldString + offset, ArraySize(match), match, 0);
offset += match[0].rm_eo)
{
dyStringAppendN(dy, oldString + offset, match[0].rm_eo);
if(match[1].rm_so == match[1].rm_eo)
dyStringAppend(dy, "?");
dyStringAppend(dy, uiVars);
if(match[1].rm_so != match[1].rm_eo)
dyStringAppend(dy, "&");
}
if(offset < len)
dyStringAppend(dy, oldString + offset);
return dyStringCannibalize(&dy);
}
void doLog()
{
FILE *logFileHandle = mustOpen("snpGetSeqDup.log", "w");
struct hashCookie cookie = hashFirst(uniqHash);
char *rsId = NULL;
int count = 0;
struct hashEl *hel = NULL;
char *fileName = NULL;
struct dyString *dy = newDyString(1024);
while ((rsId = hashNextName(&cookie)) != NULL)
{
count = 0;
for (hel = hashLookup(snpHash, rsId); hel != NULL; hel = hashLookupNext(hel))
count++;
if (count == 1) continue;
for (hel = hashLookup(snpHash, rsId); hel != NULL; hel = hashLookupNext(hel))
{
fileName = (char *)hel->val;
dyStringAppend(dy, fileName);
dyStringAppend(dy, " ");
}
fprintf(logFileHandle, "%s\t%s\n", rsId, dy->string);
dyStringClear(dy);
}
carefulClose(&logFileHandle);
}
static void xpLookup(struct xp *xp, struct dyString *temp, struct dyString *text)
/* Parse after '&' until ';' and look up symbol. Put result into text. */
{
char c;
char *s;
dyStringClear(temp);
for (;;)
{
if ((c = xpGetChar(xp)) == 0)
xpError(xp, "End of file in after & and before ;");
if (isspace(c))
xpError(xp, "& without ;");
if (c == ';')
break;
dyStringAppendC(temp, c);
}
s = temp->string;
if (s[0] == '#')
{
c = atoi(s+1);
dyStringAppendC(text, c);
}
else if ((s = hashFindVal(xp->symHash, s)) == NULL)
{
dyStringAppendC(text, '&');
dyStringAppend(text, temp->string);
dyStringAppendC(text, ';');
}
else
{
dyStringAppend(text, s);
}
}
struct dyString *unrepFileName(char *fileName, boolean isSingle)
/* Return string with Rep# in fileName replaced with "Merged" */
{
char *s = strstr(fileName, "Rep");
struct dyString *dy = dyStringNew(0);
if (s == NULL)
{
if (isSingle)
dyStringAppend(dy, fileName);
else
errAbort("No 'Rep' in fileName %s", fileName);
}
else
{
char *pastRep = s + strlen("Rep");
int digitCount = countLeadingDigits(pastRep);
if (digitCount < 1)
errAbort("No digits after 'Rep' in filename %s", fileName);
pastRep += digitCount;
dyStringAppendN(dy, fileName, s-fileName);
dyStringAppend(dy, "Merged");
int len = strlen(pastRep);
if (!isSingle && endsWith(pastRep, ".gz"))
len -= strlen(".gz");
dyStringAppendN(dy, pastRep, len);
}
return dy;
}
char *replaceRegEx(char *str, char *replace, char *regEx, int flags)
{
/* Replace text matching regEx in str with replace string.
flags is passed through to regcomp as the cflags argument.
Returned string should be free'ed after use. */
regex_t re;
regmatch_t match[1];
int err = regcomp(&re, regEx, flags);
if(err)
errAbort("regcomp failed; err: %d", err);
struct dyString *dy = newDyString(0);
size_t len = strlen(str);
size_t offset = 0;
while(offset < len && !regexec(&re, str + offset, 1, match, 0))
{
dyStringAppendN(dy, str + offset, match[0].rm_so);
if(replace != NULL)
dyStringAppend(dy, replace);
offset += match[0].rm_eo;
}
if(offset < len)
{
dyStringAppend(dy, str + offset);
}
regfree(&re);
return dyStringCannibalize(&dy);
}
static struct slName *getListFromCgapSageLibs(struct sqlConnection *conn, char *column, boolean returnIds, boolean distinct)
/* Return [unique] list of tissues sorted alphabetically. */
{
struct slName *list = NULL;
struct dyString *dy = dyStringNew(0);
char **row;
struct sqlResult *sr;
sqlDyStringPrintf(dy, "select ");
if (distinct)
dyStringAppend(dy, "distinct ");
sqlDyStringPrintf(dy, "%s", column);
if (returnIds)
dyStringAppend(dy, ",libId");
sqlDyStringPrintf(dy, " from cgapSageLib order by %s", column);
sr = sqlGetResult(conn, dy->string);
while ((row = sqlNextRow(sr)) != NULL)
{
char *word = (returnIds) ? row[1] : row[0];
slNameAddHead(&list, word);
}
slReverse(&list);
sqlFreeResult(&sr);
dyStringFree(&dy);
return list;
}
struct dyString *readAndReplaceTableName(char *fileName, char *table)
/* Read file into string. While doing so strip any leading comments
* and insist that the first non-comment line contain the words
* "create table" followed by a table name. Replace the table name,
* and copy the rest of the file verbatem. */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
struct dyString *dy = dyStringNew(0);
char *line, *word;
if (!lineFileNextReal(lf, &line))
errAbort("No real lines in %s\n", fileName);
word = nextWord(&line);
if (!sameWord(word, "create"))
errAbort("Expecting first word in file to be CREATE. Got %s", word);
word = nextWord(&line);
if (word == NULL || !sameWord(word, "table"))
errAbort("Expecting second word in file to be table. Got %s", emptyForNull(word));
word = nextWord(&line);
if (word == NULL)
errAbort("Expecting table name on same line as CREATE TABLE");
sqlDyStringPrintf(dy, "CREATE TABLE %s ", table);
if (line != NULL)
dyStringAppend(dy, line);
dyStringAppendC(dy, '\n');
while (lineFileNext(lf, &line, NULL))
{
dyStringAppend(dy, line);
dyStringAppendC(dy, '\n');
}
lineFileClose(&lf);
return dy;
}
void gensatFixFull(char *captionFile)
/* Fix missing captions. */
{
struct lineFile *lf = lineFileOpen(captionFile, TRUE);
char *row[2];
struct dyString *sql = dyStringNew(0);
struct sqlConnection *conn = sqlConnect(database);
struct hash *capHash = newHash(16);
while (lineFileRowTab(lf, row))
{
int captionId;
char *submitId = row[0];
char *caption = row[1];
captionId = hashIntValDefault(capHash, caption, 0);
if (captionId == 0)
{
dyStringClear(sql);
dyStringAppend(sql, "insert into caption values(default, \"");
dyStringAppend(sql, caption);
dyStringAppend(sql, "\")");
sqlUpdate(conn, sql->string);
verbose(1, "%s\n", sql->string);
captionId = sqlLastAutoId(conn);
hashAddInt(capHash, caption, captionId);
}
dyStringClear(sql);
dyStringPrintf(sql, "update imageFile set caption=%d ", captionId);
dyStringPrintf(sql, "where submissionSet=%d ", gensatId);
dyStringPrintf(sql, "and submitId = \"%s\"", submitId);
sqlUpdate(conn, sql->string);
verbose(1, "%s\n", sql->string);
}
dyStringFree(&sql);
}
char *identifierWhereClause(char *idField, struct hash *idHash)
/* If the number of pasted IDs is reasonably low, return a where-clause component for the IDs. */
{
if (idHash == NULL || idField == NULL)
return NULL;
int numIds = hashNumEntries(idHash);
int maxIdsInWhere = cartUsualInt(cart, "hgt_maxIdsInWhere", DEFAULT_MAX_IDS_IN_WHERE);
if (numIds > 0 && numIds <= maxIdsInWhere)
{
struct dyString *dy = dyStringNew(16 * numIds);
dyStringPrintf(dy, "%s in (", idField);
struct hashCookie hc = hashFirst(idHash);
boolean first = TRUE;
char *id;
while ((id = hashNextName(&hc)) != NULL)
{
if (first)
first = FALSE;
else
dyStringAppend(dy, ", ");
dyStringPrintf(dy, "'%s'", id);
}
dyStringAppend(dy, ")");
return dyStringCannibalize(&dy);
}
return NULL;
}
static void getItemLabel(struct sqlConnection *conn,
char *retroInfoTbl,
unsigned labelSet,
struct linkedFeatures *lf)
/* get label for a retro item */
{
struct ucscRetroInfo *info = NULL;
info = ucscRetroInfoQuery(conn, retroInfoTbl, lf->name);
char *geneSymbol = getRetroParentSymbol(info, lf->name);
//lf->extra = geneSymbol;
struct dyString *label = dyStringNew(64);
dyStringAppend(label, "retro-");
if ((labelSet & useGene) && (retroInfoTbl != NULL))
{
if ((geneSymbol != NULL) && (strlen(geneSymbol) > 0))
dyStringAppend(label, geneSymbol);
else
labelSet |= useAcc; // no gene, so force acc
}
/* if both accession and gene are selected, add to item label */
if (labelSet & useAcc)
{
if (labelSet & useGene)
{
dyStringAppend(label, "/");
dyStringAppend(label, lf->name);
}
else
dyStringAppend(label, lf->name);
}
ucscRetroInfoFree(&info);
lf->extra = dyStringCannibalize(&label);
}
static boolean parseBlockLine(struct blastFile *bf, int *startRet, int *endRet,
struct dyString *seq)
/* read and parse the next target or query line, like:
* Query: 26429 taccttgacattcctcagtgtgtcatcatcgttctctcctccaaacggcgagagtccgga 26488
*
* also handle broken NCBI tblastn output like:
* Sbjct: 1181YYGEQRSTNGQTIQLKTQVFRRFPDDDDESEDHDDPDNAHESPEQEGAEGHFDLHYYENQ 1360
*
* Ignores and returns FALSE on bogus records generated by PSI BLAST, such as
* Query: 0 --------------------------
* Sbjct: 38 PPGPPGVAGGNQTTVVVIYGPPGPPG 63
* Query: 0
* Sbjct: 63 63
* If FALSE is returned, the output parameters will be unchanged.
*/
{
char* line = bfNeedNextLine(bf);
int a, b, s, e;
char *words[16];
int wordCount = chopLine(line, words);
if ((wordCount < 2) || (wordCount > 4) || !(sameString("Query:", words[0]) || sameString("Sbjct:", words[0])))
bfSyntax(bf);
/* look for one of the bad formats to ignore, as described above */
if (((wordCount == 2) && isAllDigits(words[1]))
|| ((wordCount == 3) && isAllDigits(words[1]) && isAllDigits(words[2]))
|| ((wordCount == 3) && isAllDigits(words[1]) && isAllDashes(words[2])))
{
bfWarn(bf, "Ignored invalid alignment format for aligned sequence pair");
return FALSE;
}
/* special handling for broken output with no space between start and
* sequence */
if (wordCount == 3)
{
char *p;
if (!isdigit(words[1][0]) || !isdigit(words[2][0]))
bfSyntax(bf);
a = atoi(words[1]);
b = atoi(words[2]);
p = words[1];
while ((*p != '\0') && (isdigit(*p)))
p++;
dyStringAppend(seq, p);
}
else
{
if (!isdigit(words[1][0]) || !isdigit(words[3][0]))
bfSyntax(bf);
a = atoi(words[1]);
b = atoi(words[3]);
dyStringAppend(seq, words[2]);
}
s = min(a,b);
e = max(a,b);
*startRet = min(s, *startRet);
*endRet = max(e, *endRet);
return TRUE;
}
static void addWhereOrAnd(struct dyString *query, int clauseCnt)
/* add a `where' or `and' to the query as indicated by clauseCnt */
{
if (clauseCnt == 0)
dyStringAppend(query, " where");
else
dyStringAppend(query, " and");
}
static void maybeBedGraph(int col, struct dyString *dy, char *colDefinition)
/* output definition "default" for column "col" when not bedGraph */
{
if (col == bedGraph)
dyStringAppend(dy, " dataValue float not null,\n");
else
dyStringAppend(dy, colDefinition);
}
static void visiGeneMatchContributor(struct visiSearcher *searcher,
struct sqlConnection *conn, struct slName *wordList)
/* Put images from contributors in wordList into searcher.
* We want the behavior to be such that if you give it two names
* say "Smith Mahoney" it will weigh those that match both
* names. We also want it so that if you include the initials
* after the last name either with or without periods that will
* set those matching the last name and initials. For
* instance "Smith JJ" or "Smith J.J." or "Smith J. J." all would
* match a particular John Jacob Smith, but not Francis K. Smith.
* Making this a little more interesting is a case like
* "smith li" which could either be two last names, or a last
* name followed by initials. We would want to match both
* cases. Finally, making it even more interesting, is the
* case where the last name is compound, like "Van Koppen" or
* "de la Cruz" and the like. Also don't forget the apostrophe
* containing names like O'Shea. */
{
struct slName *word;
struct dyString *query = dyStringNew(0);
int wordIx;
for (word = wordList, wordIx=0; word != NULL; wordIx++)
{
struct slName *nameList, *name;
int maxWordsUsed = 0;
dyStringClear(query);
dyStringPrintf(query, "select name from contributor where name like \"");
dyStringAppend(query, word->name);
dyStringAppend(query, " %\"");
nameList = sqlQuickList(conn, query->string);
if (nameList != NULL)
{
for (name = nameList; name != NULL; name = name->next)
{
int wordsUsed = countPartsUsedInName(name->name, word);
if (wordsUsed > maxWordsUsed)
maxWordsUsed = wordsUsed;
}
for (name = nameList; name != NULL; name = name->next)
{
if (countPartsUsedInName(name->name, word) == maxWordsUsed)
addImagesMatchingName(searcher, conn, query, name->name,
wordIx, maxWordsUsed);
}
while (--maxWordsUsed >= 0)
word = word->next;
}
else
word = word->next;
slFreeList(&nameList);
}
dyStringFree(&query);
}
static char *onChangeOrg()
/* Return javascript executed when they change organism. */
{
struct dyString *dy = onChangeStart();
jsDropDownCarryOver(dy, "clade");
jsDropDownCarryOver(dy, "org");
jsDropDownCarryOver(dy, hgtaTable);
dyStringAppend(dy, " document.hiddenForm.db.value=0;");
dyStringAppend(dy, " document.hiddenForm.position.value='';");
return jsOnChangeEnd(&dy);
}
void dyJoin(struct dyString *dy, char *delim, char **words, int wordCount)
/* Clear dy and append wordCount words interspersed with delim. */
{
dyStringClear(dy);
int i;
for (i = 0; i < wordCount; i++)
{
if (i > 0)
dyStringAppend(dy, delim);
dyStringAppend(dy, words[i]);
}
}
void calc(int wordCount, char *words[])
/* calc - Little command line calculator. */
{
struct dyString *dy = newDyString(128);
int i;
for (i=0; i<wordCount; ++i)
{
if (i != 0)
dyStringAppend(dy, " ");
dyStringAppend(dy, words[i]);
}
double result = doubleExp(dy->string);
if (!humanReadable)
{
printf("%s = %f\n", dy->string, result);
return;
}
// make human readable
char* resQual = "";
int intRes = 0;
if (result>=1E12)
{
intRes = round(result/1E12);
resQual = "t";
}
else if (result>=1E9)
{
intRes = round(result/1E9);
resQual = "g";
}
else if (result>=1E6)
{
intRes = round(result/1E6);
resQual = "m";
}
else if (result>=1E3)
{
intRes = round(result/1E3);
resQual = "k";
}
else
{
intRes = round(result);
resQual = "";
}
printf("%s = %d%s\n", dy->string, intRes, resQual);
}
static void visiGeneMatchMultiWord(struct visiSearcher *searcher,
struct sqlConnection *conn, struct slName *wordList,
char *table, char *field, AdderFunc adder)
/* This helps cope with matches that may involve more than
* one word. It will preferentially match as many words
* as possible, and if there is a multiple-word match it
* will take that over a single-word match. */
{
struct slName *word;
struct dyString *query = dyStringNew(0);
int wordIx;
for (word = wordList, wordIx=0; word != NULL; ++wordIx)
{
struct slName *nameList = NULL, *name;
int maxWordsUsed = 0;
if (strlen(word->name) >= 3) /* Logic could be expensive on small words */
{
dyStringClear(query);
dyStringPrintf(query, "select %s from %s where %s like \"",
field, table, field);
dyStringAppend(query, word->name);
dyStringAppend(query, "%\"");
nameList = sqlQuickList(conn, query->string);
if (nameList != NULL)
{
for (name = nameList; name != NULL; name = name->next)
{
int wordsUsed = countWordsUsedInPhrase(name->name, word);
if (wordsUsed > maxWordsUsed)
maxWordsUsed = wordsUsed;
}
}
}
if (maxWordsUsed > 0)
{
for (name = nameList; name != NULL; name = name->next)
{
if (countWordsUsedInPhrase(name->name, word) == maxWordsUsed)
(*adder)(searcher, conn, query, name->name,
wordIx, maxWordsUsed);
}
while (--maxWordsUsed >= 0)
word = word->next;
}
else
word = word->next;
slFreeList(&nameList);
}
dyStringFree(&query);
}
static char* joinCmd(char **cmd)
/* join an cmd vector into a space separated string */
{
struct dyString *str = dyStringNew(512);
int i;
for (i = 0; cmd[i] != NULL; i++)
{
if (i > 0)
dyStringAppend(str, " ");
dyStringAppend(str, cmd[i]);
}
return dyStringCannibalize(&str);
}
static void appendCgiVar(struct dyString *dy, char *name, char *value)
/* Append cgiVar with cgi-encoded value to dy. */
{
char *enc = NULL;
if (value == NULL)
value = "";
enc = cgiEncode(value);
if (dy->stringSize != 0)
dyStringAppendC(dy, '&');
dyStringAppend(dy, name);
dyStringAppendC(dy, '=');
dyStringAppend(dy, enc);
freez(&enc);
}
void printSections(struct section *sectionList, struct sqlConnection *conn,
char *geneId)
/* Print each section in turn. */
{
struct section *section;
for (section = sectionList; section != NULL; section = section->next)
{
boolean isOpen = sectionIsOpen(section);
char *otherState = (isOpen ? "1" : "0");
char *indicator = (isOpen ? "-" : "+");
char *indicatorImg = (isOpen ? "../images/remove.gif" : "../images/add.gif");
struct dyString *header = dyStringNew(0);
//keep the following line for future debugging need
//printf("<br>printing %s section\n", section->name);fflush(stdout);
dyStringPrintf(header, "<A NAME=\"%s\"></A>", section->name);
char *closeVarName = sectionCloseVar(section->name);
dyStringPrintf(header, "<A HREF=\"%s?%s&%s=%s#%s\" class=\"bigBlue\"><IMG src=\"%s\" alt=\"%s\" class=\"bigBlue\"></A> ",
geneCgi, cartSidUrlString(cart), closeVarName, otherState, section->name, indicatorImg, indicator);
dyStringAppend(header, section->longLabel);
webNewSection("%s",header->string);
if (isOpen)
{
long startTime = clock1000();
section->print(section, conn, geneId);
section->printTime = clock1000() - startTime;
}
else
{
printf("Press \"+\" in the title bar above to open this section.");
}
dyStringFree(&header);
}
}
char *updateDescription(char *description, char *orf,
struct hash *orfToGene, struct hash *classDesc, struct hash *geneDesc)
/* The descriptions I got from Lincoln of known genes are quite
* poor - only containing the gene name. Here we update the
* description with something better if possible. */
{
char *update = NULL;
char *geneName = hashFindVal(orfToGene, orf);
if (geneName != NULL)
{
update = hashFindVal(geneDesc, geneName);
/* if this does not exist in the hash or the entry is "NULL" */
if ((update == NULL) || sameString(update, "NULL") )
{
char *class = cloneString(geneName);
char *desc;
subChar(class, '-', 0);
desc = hashFindVal(classDesc, class);
if (desc != NULL)
{
struct dyString *dy = dyStringNew(0);
dyStringPrintf(dy, "%s - a member of the gene class ", geneName);
dyStringAppend(dy, desc);
update = cloneString(dy->string);
dyStringFree(&dy);
}
}
struct hash *readDescriptionFile(char *fileName)
/* Return two column file keyed by first column with
* values in second column. Strip any tabs from values. */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
char *line;
struct hash *hash = newHash(16);
while (lineFileNextReal(lf, &line))
{
char *key = nextWord(&line);
char *val = skipLeadingSpaces(line);
if (val != NULL && val[0] != 0)
{
char *desc = hashFindVal(hash, key);
subChar(val, '\t', ' ');
stripChar(val, '\r');
/* if gene exists in hash */
if (desc != NULL)
{
struct dyString *dy = dyStringNew(1024);
dyStringPrintf(dy, "%s ", desc);
dyStringAppend(dy, val);
val = cloneString(dy->string);
dyStringFree(&dy);
}
/* add to gene and description to hash */
hashAdd(hash, key, cloneString(val));
}
}
lineFileClose(&lf);
return hash;
}
