void metaTreeWrite(int level, int minLevel, int maxLevel, boolean isFile,
char *parent, struct metaNode *node, struct hash *suppress, FILE *f)
/* Write out self and children to file recursively. */
{
if (level >= minLevel && level < maxLevel)
{
int indent = (level-minLevel)*3;
spaceOut(f, indent);
fprintf(f, "meta %s\n", node->name);
if (withParent && parent != NULL)
{
spaceOut(f, indent);
fprintf(f, "parent %s\n", parent);
}
struct mdbVar *v;
for (v = node->vars; v != NULL; v = v->next)
{
if (!hashLookup(suppress, v->var))
{
spaceOut(f, indent);
fprintf(f, "%s %s\n", v->var, v->val);
}
}
fprintf(f, "\n");
}
struct metaNode *child;
for (child = node->children; child != NULL; child = child->next)
metaTreeWrite(level+1, minLevel, maxLevel, isFile, node->name, child, suppress, f);
}
static void rMetaListWrite(struct meta *metaList, struct meta *parent,
boolean level, int indent, boolean withParent, FILE *f)
/* Write out list of stanzas at same level to file, their children too. */
{
int totalIndent = level * indent;
struct meta *meta;
for (meta = metaList; meta != NULL; meta = meta->next)
{
struct metaTagVal *mtv;
boolean gotParent = FALSE;
for (mtv = meta->tagList; mtv != NULL; mtv = mtv->next)
{
if (sameString(mtv->tag, "parent"))
{
if (withParent)
gotParent = TRUE;
else
continue;
}
spaceOut(f, totalIndent);
fprintf(f, "%s %s\n", mtv->tag, mtv->val);
}
if (withParent && !gotParent && parent != NULL)
{
spaceOut(f, totalIndent);
fprintf(f, "%s %s\n", "parent", parent->name);
}
fprintf(f, "\n");
if (meta->children)
rMetaListWrite(meta->children, meta, level+1, indent, withParent, f);
}
}
static void printScopeInfo(FILE *f, int level, struct pfParse *pp)
/* Print out info on each new scope. */
{
switch (pp->type)
{
case pptProgram:
case pptMainModule:
case pptFor:
case pptForeach:
case pptForEachCall:
case pptToDec:
case pptFlowDec:
case pptCompound:
{
char *name = pp->name;
if (name == NULL)
name = "";
spaceOut(f, 2*level);
fprintf(f, "scope %d %s %s: ", pp->scope->id,
pfParseTypeAsString(pp->type), name);
pfScopeDump(pp->scope, f);
fprintf(f, "\n");
break;
}
}
for (pp = pp->children; pp != NULL; pp = pp->next)
printScopeInfo(f, level+1, pp);
}
void rqlParseDump(struct rqlParse *p, int depth, FILE *f)
/* Dump out rqlParse tree and children. */
{
spaceOut(f, 3*depth);
fprintf(f, "%s ", rqlOpToString(p->op));
rqlValDump(p->val, p->type, f);
fprintf(f, "\n");
struct rqlParse *child;
for (child = p->children; child != NULL; child= child->next)
rqlParseDump(child, depth+1, f);
}
/**
* Check if {word} is contained in {keywords}. If yes, erase {word} with
* white spaces. {len} indicates the length of {word}, and {num} indicates
* the length of the keyword list.
*/
void checkWord(char* word, int len, char** keywords, int num) {
for(int i=0; i<num;i++)
for (int j=0;j<len;j++)
{if ((*(*(keywords+i)+j))!=*(word+j))
return;}
for(int k=0;k<len;k++)
spaceOut(word,len);
/* FILL IN HERE */
// Please remove the abort() when you implement this function
}
void fillOut(FILE *f, struct fill *fill, char *oChrom, int depth,
int subSize, double subScore)
/* Output fill. */
{
struct chain *chain = fill->chain;
spaceOut(f, depth);
fprintf(f, "fill %d %d %s %c %d %d id %d score %1.0f ali %d\n",
fill->start, fill->end - fill->start,
oChrom, chain->qStrand,
fill->oStart, fill->oEnd - fill->oStart, chain->id,
subScore, subSize);
}
static void rTreeDump(struct rbTreeNode *n)
/* Recursively dump. */
{
if (n == NULL)
return;
spaceOut(dumpFile, ++dumpLevel * 3);
fprintf(dumpFile, "%c ", (n->color == rbTreeRed ? 'r' : 'b'));
dumpIt(n->item, dumpFile);
fprintf(dumpFile, "\n");
rTreeDump(n->left);
rTreeDump(n->right);
--dumpLevel;
}
void cnFillWrite(struct cnFill *fillList, FILE *f, int depth)
/* Recursively write out fill list. */
{
struct cnFill *fill;
for (fill = fillList; fill != NULL; fill = fill->next)
{
char *type = (fill->chainId ? "fill" : "gap");
spaceOut(f, depth);
fprintf(f, "%s %d %d %s %c %d %d", type, fill->tStart, fill->tSize,
fill->qName, fill->qStrand, fill->qStart, fill->qSize);
if (fill->chainId)
fprintf(f, " id %d", fill->chainId);
if (fill->score > 0)
fprintf(f, " score %1.0f", fill->score);
if (fill->ali > 0)
fprintf(f, " ali %d", fill->ali);
if (fill->qOver >= 0)
fprintf(f, " qOver %d", fill->qOver);
if (fill->qFar >= 0)
fprintf(f, " qFar %d", fill->qFar);
if (fill->qDup >= 0)
fprintf(f, " qDup %d", fill->qDup);
if (fill->type != NULL)
fprintf(f, " type %s", fill->type);
if (fill->tN >= 0)
fprintf(f, " tN %d", fill->tN);
if (fill->qN >= 0)
fprintf(f, " qN %d", fill->qN);
if (fill->tR >= 0)
fprintf(f, " tR %d", fill->tR);
if (fill->qR >= 0)
fprintf(f, " qR %d", fill->qR);
if (fill->tNewR >= 0)
fprintf(f, " tNewR %d", fill->tNewR);
if (fill->qNewR >= 0)
fprintf(f, " qNewR %d", fill->qNewR);
if (fill->tOldR >= 0)
fprintf(f, " tOldR %d", fill->tOldR);
if (fill->qOldR >= 0)
fprintf(f, " qOldR %d", fill->qOldR);
if (fill->tTrf >= 0)
fprintf(f, " tTrf %d", fill->tTrf);
if (fill->qTrf >= 0)
fprintf(f, " qTrf %d", fill->qTrf);
fputc('\n', f);
if (fill->children)
cnFillWrite(fill->children, f, depth+1);
}
}
static void rOutputGap(struct fill *parent, struct gap *gap, FILE *f)
/* Recursively output gap and it's fillers. */
{
struct fill *fill;
struct chain *chain = parent->chain;
char *oChrom = (rOutQ ? chain->tName : chain->qName);
++rOutDepth;
spaceOut(f, rOutDepth);
fprintf(f, "gap %d %d %s %c %d %d\n",
gap->start, gap->end - gap->start,
oChrom, chain->qStrand, gap->oStart, gap->oEnd - gap->oStart);
for (fill = gap->fillList; fill != NULL; fill = fill->next)
rOutputFill(fill, f);
--rOutDepth;
}
void detab(char *inFile, char *outFile)
/* detab - remove tabs from program. */
{
struct lineFile *lf = lineFileOpen(inFile, FALSE);
FILE *f = mustOpen(outFile, "w");
char *line;
int lineSize, i;
while (lineFileNext(lf, &line, &lineSize))
{
for (i=0; i<lineSize; ++i)
{
char c = line[i];
if (c == '\t')
spaceOut(f, tabSize);
else
fputc(c, f);
}
}
}
void rWriteTree(FILE *f, struct type *type, boolean isOptional,
boolean isList, struct hash *uniqHash,
boolean withAttributes, int level)
/* Write out type and it's children. */
{
struct attribute *att;
struct element *el;
static struct type *parentStack[256];
int i;
spaceOut(f, level*2);
if (withAttributes && type->textAttribute != NULL)
writeAttValType(f, type->textAttribute);
fprintf(f, "%s", type->name);
if (isList)
if (isOptional)
fprintf(f, "*");
else
fprintf(f, "+");
else
if (isOptional)
fprintf(f, "?");
if (withAttributes)
{
for (att = type->attributes; att != NULL; att = att->next)
writeAttribute(f, att);
}
fprintf(f, "\n");
if (level >= ArraySize(parentStack))
errAbort("Recursion too deep in rWriteTree");
parentStack[level] = type;
for (i=level-1; i>= 0; i -= 1)
if (type == parentStack[i])
return; /* Avoid cycling on self. */
for (el = type->elements; el != NULL; el = el->next)
rWriteTree(f, el->type, el->isOptional, el->isList,
uniqHash, withAttributes, level+1);
}
void wordTreeDump(int level, struct wordTree *wt, int maxChainSize, FILE *f)
/* Write out wordTree to file. */
{
static char *words[64];
int i;
assert(level < ArraySize(words));
words[level] = wt->info->word;
if (!fullOnly || level == maxChainSize)
{
fprintf(f, "%d\t%d\t%d\t%d\t%f\t",
level, wt->useCount, wt->outTarget, wt->outCount, wt->normVal);
for (i=1; i<=level; ++i)
{
spaceOut(f, level*2);
fprintf(f, "%s ", words[i]);
}
fprintf(f, "\n");
}
struct wordTree *child;
for (child = wt->children; child != NULL; child = child->next)
wordTreeDump(level+1, child, maxChainSize, f);
}
