char *aliasString(char *id, struct sqlConnection *conn)
/* return alias string as it would be printed in html, can free after use */
{
char query[256];
struct sqlResult *sr = NULL;
char **row;
int totalCount;
int cnt = 0;
totalCount = countAlias(id,conn);
if (totalCount > 0)
{
struct dyString *aliasReturn = dyStringNew(0);
dyStringPrintf(aliasReturn, "<B>Alternate Gene Symbols:</B> ");
safef(query, sizeof(query), "select alias from kgAlias where kgId = '%s' order by alias", id);
sr = sqlGetResult(conn, query);
row = sqlNextRow(sr);
while (cnt < totalCount)
{
/* skip kgId and the maint gene symbol (curGeneName) */
if ((!sameWord(id, row[0])) && (!sameWord(row[0], curGeneName)))
{
dyStringPrintf(aliasReturn, "%s", row[0]);
if (cnt < (totalCount-1)) dyStringPrintf(aliasReturn, ", ");
cnt++;
}
row = sqlNextRow(sr);
}
dyStringPrintf(aliasReturn, "<BR>");
sqlFreeResult(&sr);
return dyStringCannibalize(&aliasReturn);
}
return 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;
}
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);
}
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 boolean mdbSelectsAddFoundComposites(struct slPair **pMdbSelects,struct trackDb *tdbsFound)
// Adds a composite mdbSelect (if found in tdbsFound) to the head of the pairs list.
// If tdbsFound is NULL, then add dummy composite search criteria
{
// create comma separated list of composites
struct dyString *dyComposites = dyStringNew(256);
struct trackDb *tdb = tdbsFound;
for (;tdb != NULL; tdb = tdb->next)
{
if (tdbIsComposite(tdb))
dyStringPrintf(dyComposites,"%s,",tdb->track);
else if (tdbIsCompositeChild(tdb))
{
struct trackDb *composite = tdbGetComposite(tdb);
dyStringPrintf(dyComposites,"%s,",composite->track);
}
}
if (dyStringLen(dyComposites) > 0)
{
char *composites = dyStringCannibalize(&dyComposites);
composites[strlen(composites) - 1] = '\0'; // drop the last ','
slPairAdd(pMdbSelects,MDB_VAR_COMPOSITE,composites);
// Composite should not already be in the list, because it is only indirectly sortable
return TRUE;
}
//warn("No composites found");
dyStringFree(&dyComposites);
return FALSE;
}
static char *gvfItemName(struct track *tg, void *item)
/* ISCA requested that we append abbreviated variant origin to the item names. */
{
struct bed8Attrs *gvf = item;
struct dyString *name = dyStringNew(0);
int ix = stringArrayIx("var_origin", gvf->attrTags, gvf->attrCount);
if (ix >= 0)
{
char *origin = gvf->attrVals[ix];
if (sameWord(origin, "Not tested") || sameWord(origin, "Not reported") ||
sameWord(origin, "Tested - inconclusive") || sameWord(origin, "Not Provided"))
dyStringPrintf(name, "%s_unk", gvf->name);
else if (sameWord(origin, "De novo"))
dyStringPrintf(name, "%s_dnovo", gvf->name);
else if (sameWord(origin, "Maternal"))
dyStringPrintf(name, "%s_mat", gvf->name);
else if (sameWord(origin, "Paternal"))
dyStringPrintf(name, "%s_pat", gvf->name);
else if (sameWord(origin, "Biparental"))
dyStringPrintf(name, "%s_bip", gvf->name);
else if (sameWord(origin, "Uniparental"))
dyStringPrintf(name, "%s_unip", gvf->name);
else if (sameWord(origin, "Germline"))
dyStringPrintf(name, "%s_germ", gvf->name);
else if (sameWord(origin, "Somatic"))
dyStringPrintf(name, "%s_som", gvf->name);
else
dyStringPrintf(name, "%s_%s", gvf->name, origin);
}
else
dyStringPrintf(name, "%s_unk", gvf->name);
return dyStringCannibalize(&name);
}
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);
}
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 addExtras(char *extraFile, struct trackHubCheckOptions *checkOptions)
/* Add settings from extra file (e.g. for specific hub display site) */
{
verbose(2, "Accepting extra settings in '%s'\n", extraFile);
checkOptions->extraFile = extraFile;
checkOptions->extra = hashNew(0);
struct lineFile *lf = NULL;
if (startsWith("http", extraFile))
{
struct dyString *ds = netSlurpUrl(extraFile);
char *s = dyStringCannibalize(&ds);
lf = lineFileOnString(extraFile, TRUE, s);
}
else
{
lf = lineFileOpen(extraFile, TRUE);
}
char *line;
while (lineFileNextReal(lf, &line))
{
hashAdd(checkOptions->extra, line, NULL);
}
lineFileClose(&lf);
verbose(3, "Found %d extra settings\n", hashNumEntries(checkOptions->extra));
}
char *dsPrintCannibalizeAndClose(int token)
// Closes the top stack buffer returning content. Returned string should be freed.
{
dsAssertToken(token);
struct dyString *ds = slPopHead(&dsStack);
return dyStringCannibalize(&ds);
}
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);
}
char *bamGetCigar(const bam1_t *bam)
/* Return a BAM-enhanced CIGAR string, decoded from the packed encoding in bam. */
{
const bam1_core_t *core = &bam->core;
struct dyString *dyCigar = dyStringNew(min(8, core->n_cigar*4));
bamUnpackCigar(bam, dyCigar);
return dyStringCannibalize(&dyCigar);
}
char *userRegionsParse(char *db, char *regionsText, int maxRegions, int maxErrs,
int *retRegionCount, char **retWarnText)
/* Parse user regions entered as BED3, BED4 or chr:start-end optionally followed by name.
* Return name of trash file containing BED for parsed regions if regionsText contains
* valid regions; otherwise NULL.
* If maxRegions <= 0, it is ignored; likewise for maxErrs.
* If retRegionCount is non-NULL, it will be set to the number of valid parsed regions
* in the trash file.
* If retWarnText is non-NULL, it will be set to a string containing warning and error
* messages encountered while parsing input. */
{
char *trashFileName = NULL;
if (isNotEmpty(regionsText))
{
char *copy = cloneString(regionsText);
struct dyString *dyWarn = dyStringNew(0);
struct bed4 *bedList = parseRegionInput(db, copy, maxRegions, maxErrs, dyWarn);
if (retWarnText != NULL)
{
if (dyWarn->stringSize > 0)
*retWarnText = dyStringCannibalize(&dyWarn);
else
{
*retWarnText = NULL;
dyStringFree(&dyWarn);
}
}
int regionCount = slCount(bedList);
if (retRegionCount != NULL)
*retRegionCount = regionCount;
if (regionCount > 0)
{
struct tempName tn;
trashDirFile(&tn, "hgtData", "user", ".region");
trashFileName = cloneString(tn.forCgi);
FILE *f = mustOpen(trashFileName, "w");
struct bed4 *bed;
for (bed = bedList; bed; bed = bed->next )
{
char *name = bed->name ? bed->name : "";
fprintf(f, "%s\t%d\t%d\t%s\n",
bed->chrom, bed->chromStart, bed->chromEnd, name);
}
carefulClose(&f);
}
freeMem(copy);
}
else
{
if (retRegionCount != NULL)
*retRegionCount = 0;
if (retWarnText != NULL)
*retWarnText = NULL;
}
return trashFileName;
}
char *createCtgInfoKey(char *acc, int start, int end)
/* Create a unique hash key for a ctgInfo using the contig accession and the
scaffold start and end positions */
{
struct dyString *dy = dyStringNew(256);
dyStringPrintf(dy, "%s_%d_%d", acc, start, end);
return dyStringCannibalize(&dy);
}
void bedSqlFieldsExceptForChrom(struct hTableInfo *hti,
int *retFieldCount, char **retFields)
/* Given tableInfo figure out what fields are needed to
* add to a database query to have information to create
* a bed. The chromosome is not one of these fields - we
* assume that is already known since we're processing one
* chromosome at a time. Return a comma separated (no last
* comma) list of fields that can be freeMem'd, and the count
* of fields (this *including* the chromosome). */
{
struct dyString *fields = dyStringNew(128);
int fieldCount = fieldCount = hTableInfoBedFieldCount(hti);
dyStringPrintf(fields, "%s,%s", hti->startField, hti->endField);
if (fieldCount >= 4)
{
if (hti->nameField[0] != 0)
dyStringPrintf(fields, ",%s", hti->nameField);
else /* Put in . as placeholder. */
dyStringPrintf(fields, ",'.'");
}
if (fieldCount >= 5)
{
if (hti->scoreField[0] != 0)
dyStringPrintf(fields, ",%s", hti->scoreField);
else
dyStringPrintf(fields, ",0", hti->startField);
}
if (fieldCount >= 6)
{
if (hti->strandField[0] != 0)
dyStringPrintf(fields, ",%s", hti->strandField);
else
dyStringPrintf(fields, ",'.'");
}
if (fieldCount >= 8)
{
if (hti->cdsStartField[0] != 0)
dyStringPrintf(fields, ",%s,%s", hti->cdsStartField, hti->cdsEndField);
else
dyStringPrintf(fields, ",%s,%s", hti->startField, hti->endField);
}
if (fieldCount >= 12)
{
dyStringPrintf(fields, ",%s,%s,%s", hti->countField,
hti->endsSizesField, hti->startsField);
}
if (htiIsPsl(hti))
{
/* For psl format we need to know chrom size as well
* to handle reverse strand case. */
dyStringPrintf(fields, ",tSize");
}
*retFieldCount = fieldCount;
*retFields = dyStringCannibalize(&fields);
}
char *sqlShortArrayToString( short *array, int arraySize)
{
int i;
struct dyString *string = newDyString(256);
for( i = 0 ; i < arraySize; i++ )
{
dyStringPrintf(string, "%d,", array[i]);
}
return dyStringCannibalize(&string);
}
char *sqlLongLongArrayToString( long long *array, int arraySize)
{
int i;
struct dyString *string = newDyString(256);
for( i = 0 ; i < arraySize; i++ )
{
dyStringPrintf(string, "%lld,", array[i]);
}
return dyStringCannibalize(&string);
}
char *sqlUbyteArrayToString( unsigned char *array, int arraySize)
{
int i;
struct dyString *string = newDyString(256);
for( i = 0 ; i < arraySize; i++ )
{
dyStringPrintf(string, "%u,", array[i]);
}
return dyStringCannibalize(&string);
}
static void printGenomeList(struct slName *genomes)
/* print supported assembly names from sl list */
{
/* List of associated genomes. */
struct dyString *dy = newDyString(100);
for(; genomes; genomes = genomes->next)
dyStringPrintf(dy,"%s, ", trackHubSkipHubName(genomes->name));
ourPrintCell(removeLastComma( dyStringCannibalize(&dy)));
}
char *lineFileReadAll(struct lineFile *lf)
/* Read remainder of lineFile and return it as a string. */
{
struct dyString *dy = dyStringNew(1024*4);
lf->zTerm = 0;
int size;
char *line;
while (lineFileNext(lf, &line, &size))
dyStringAppendN(dy, line, size);
return dyStringCannibalize(&dy);
}
void pf_lineIn(_pf_Stack *stack)
/* Get next line of input from stdin. In general
* you do not want to mix calls to keyIn and lineIn,
* since keyIn is unbuffered and lineIn is buffered.
* Returns nil at EOF. */
{
char buf[256];
int i, c;
FILE *f = stdin;
for (i=0; i<sizeof(buf)-1; ++i)
{
c = fgetc(f);
if (c < 0)
{
if (i == 0)
stack[0].String = NULL;
else
{
buf[i] = 0;
stack[0].String = _pf_string_from_const(buf);
}
return;
}
buf[i] = c;
if (c == '\n')
{
buf[i] = 0;
stack[0].String = _pf_string_dupe(buf, i);
return;
}
}
/* Well, looks like it's a pretty long string!
* Let's convert to dyString based capture rather
* than using the fixed size buffer on stack. */
{
struct dyString *dy = dyStringNew(512);
struct _pf_string *string;
dyStringAppendN(dy, buf, i);
for (;;)
{
c = fgetc(f);
if (c < 0)
break;
dyStringAppendC(dy, c);
if (c == '\n')
break;
}
string = _pf_string_new(dy->string, dy->bufSize);
string->size = dy->stringSize;
dyStringCannibalize(&dy);
stack[0].String = string;
}
}
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);
}
void jsonErrPrintf(struct dyString *ds, char *format, ...)
// Printf a json error to a dyString for communicating with ajax code; format is:
// {"error": error message here}
{
va_list args;
va_start(args, format);
dyStringPrintf(ds, "{\"error\": \"");
struct dyString *buf = newDyString(1000);
dyStringVaPrintf(buf, format, args);
dyStringAppend(ds, jsonStringEscape(dyStringCannibalize(&buf)));
dyStringPrintf(ds, "\"}");
va_end(args);
}
static char *encodePeakFilter(char *trackName, struct trackDb *tdb, boolean isCustom)
{
struct dyString *extraWhere = newDyString(128);
boolean and = FALSE;
extraWhere = dyAddFilterAsInt(cart,tdb,extraWhere,SCORE_FILTER,"0:1000","score",&and);
extraWhere = dyAddFilterAsDouble(cart,tdb,extraWhere,SIGNAL_FILTER,NULL,"signalValue",&and);
extraWhere = dyAddFilterAsDouble(cart,tdb,extraWhere,PVALUE_FILTER,NULL,"pValue",&and);
extraWhere = dyAddFilterAsDouble(cart,tdb,extraWhere,QVALUE_FILTER,NULL,"qValue",&and);
if (sameString(extraWhere->string, ""))
return NULL;
return dyStringCannibalize(&extraWhere);
}
static char *mkChimeraPyScript(char *scriptFile)
/* create chimera python script from commands in scriptFile */
{
struct dyString *buf = dyStringNew(0);
dyStringAppend(buf, "from chimera import runCommand\n");
struct lineFile *lf = lineFileOpen(scriptFile, TRUE);
char *line;
while (lineFileNextReal(lf, &line))
dyStringPrintf(buf, "runCommand(\"%s\")\n", line);
lineFileClose(&lf);
return dyStringCannibalize(&buf);
}
static struct customTrack *beginCustomTrack(char *table, int fields,
boolean doCt, boolean doWigHdr, boolean doDataPoints)
/* If doCt, return a new custom track object from TB cart settings and params;
* if !doCt, return NULL but print out a header line. */
{
char *ctName = cgiUsualString(hgtaCtName, table);
char *ctDesc = cgiUsualString(hgtaCtDesc, table);
char *ctUrl = cgiUsualString(hgtaCtUrl, "");
char *ctVis = cgiUsualString(hgtaCtVis, "dense");
int visNum = (int) hTvFromStringNoAbort(ctVis);
struct customTrack *ctNew = NULL;
if (visNum < 0)
visNum = 0;
if (doCt)
{
ctNew = newCt(ctName, ctDesc, visNum, ctUrl, fields);
if (doDataPoints)
{
struct dyString *wigSettings = newDyString(0);
struct tempName tn;
trashDirFile(&tn, "ct", hgtaCtTempNamePrefix, ".wib");
ctNew->wibFile = cloneString(tn.forCgi);
char *wiggleFile = cloneString(ctNew->wibFile);
chopSuffix(wiggleFile);
strcat(wiggleFile, ".wia");
ctNew->wigAscii = cloneString(wiggleFile);
chopSuffix(wiggleFile);
/* .wig file will be created upon encoding in customFactory */
/*strcat(wiggleFile, ".wig");
ctNew->wigFile = cloneString(wiggleFile);
*/
ctNew->wiggle = TRUE;
dyStringPrintf(wigSettings,
"type wiggle_0\nwibFile %s\n", ctNew->wibFile);
ctNew->tdb->settings = dyStringCannibalize(&wigSettings);
freeMem(wiggleFile);
}
}
else
{
if (doWigHdr)
hPrintf("track type=wiggle_0 name=\"%s\" description=\"%s\" "
"visibility=%d url=%s \n",
ctName, ctDesc, visNum, ctUrl);
else
hPrintf("track name=\"%s\" description=\"%s\" visibility=%d url=%s \n",
ctName, ctDesc, visNum, ctUrl);
}
return ctNew;
}
char *dsPrintCannibalizeAndCloseAll()
// Closes all stack buffers and returns a single string that is the full content.
// Returned string should be freed.
{
while (dsStack != NULL && dsStack->next != NULL)
{
int token = dsPointerToToken(dsStack);
dsPrintFlushAndClose(token); // Flushes each to the next lower buffer
}
if (dsStack == NULL)
return NULL;
else
return dyStringCannibalize(&dsStack);
}
void genotypeAndStrainFromKey(char *genotypeKey, struct sqlConnection *conn,
char **retGenotype, char **retStrain)
/* Return dynamically allocated string describing genotype */
{
int key = atoi(genotypeKey);
char *genotype = NULL, *strain = NULL;
if (key > 0)
{
struct dyString *query = dyStringNew(0);
struct dyString *geno = dyStringNew(256);
struct sqlResult *sr;
char **row;
/* Figure out genotype. Create string that looks something like:
* adh:cheap date,antp:+,
* That is a comma separated list gene:allele. */
sqlDyStringPrintf(query,
"select MRK_Marker.symbol,ALL_Allele.symbol "
"from GXD_AlleleGenotype,MRK_Marker,ALL_Allele "
"where GXD_AlleleGenotype._Genotype_key = %s "
"and GXD_AlleleGenotype._Marker_key = MRK_Marker._Marker_key "
"and GXD_AlleleGenotype._Allele_key = ALL_Allele._Allele_key "
, genotypeKey);
sr = sqlGetResultVerbose(conn, query->string);
while ((row = sqlNextRow(sr)) != NULL)
dyStringPrintf(geno, "%s:%s,", row[0], row[1]);
sqlFreeResult(&sr);
genotype = dyStringCannibalize(&geno);
/* Figure out strain */
dyStringClear(query);
sqlDyStringPrintf(query,
"select PRB_Strain.strain from GXD_Genotype,PRB_Strain "
"where GXD_Genotype._Genotype_key = %s "
"and GXD_Genotype._Strain_key = PRB_Strain._Strain_key"
, genotypeKey);
strain = sqlQuickStringVerbose(conn, query->string);
if (isUnknown(strain))
freez(&strain);
dyStringFree(&query);
}
if (genotype == NULL)
genotype = cloneString("");
if (strain == NULL)
strain = cloneString("");
*retGenotype = genotype;
*retStrain = strain;
}
char *docIdGetPath(char *docId, char *docIdDir, char *type, char *submitPath)
{
char *ptr = docId + strlen(docId) - 1;
struct dyString *dy = newDyString(20);
char *suffix = docDecorateType(type);
dyStringPrintf(dy, "%s/", docIdDir);
for (; ptr != docId; ptr--)
{
dyStringPrintf(dy, "%c/", *ptr);
}
dyStringPrintf(dy, "%s.%s", docId, suffix);
return dyStringCannibalize(&dy);
}
char *hashToRaString(struct hash *hash)
/* Convert hash to string in ra format. */
{
struct hashEl *el, *list = hashElListHash(hash);
struct dyString *dy = dyStringNew(0);
slSort(&list, hashElCmp);
for (el = list; el != NULL; el = el->next)
{
dyStringAppend(dy, el->name);
dyStringAppendC(dy, ' ');
dyStringAppend(dy, el->val);
dyStringAppendC(dy, '\n');
}
hashElFreeList(&list);
return dyStringCannibalize(&dy);
}
