struct table *elsIntoTables(struct elStat *elList, struct hash *dtdHash)
/* Create table and field data structures from element/attribute
* data structures. */
{
struct elStat *el;
struct attStat *att;
struct table *tableList = NULL, *table;
struct field *field = NULL;
for (el = elList; el != NULL; el = el->next)
{
struct dtdElement *dtdElement = hashFindVal(dtdHash, el->name);
int attCount = 0;
if (dtdElement == NULL)
errAbort("Element %s is in .stats but not in .dtd file", el->name);
table = tableNew(dtdElement->mixedCaseName, el, dtdElement);
for (att = el->attList; att != NULL; att = att->next)
{
char *name = att->name;
char *mixedName = NULL;
if (sameString(name, "<text>"))
name = mixedName = textField;
else
{
struct dtdAttribute *dtdAtt = findDtdAttribute(dtdElement, name);
if (dtdAtt == NULL)
errAbort("Element %s attribute %s is in .stats but not in .dtd file",
el->name, name);
mixedName = dtdAtt->mixedCaseName;
}
field = addFieldToTable(table, name, mixedName, att,
FALSE, TRUE, attIsString(att), textField);
attCount += 1;
}
/* If the table is real simple we'll just promote it */
if (attCount == 1 && sameString(field->name, textField)
&& (field->attStat->maxLen < maxPromoteSize || !field->isString))
{
table->promoted = TRUE;
table->primaryKey = field;
}
else
makePrimaryKey(table);
slAddHead(&tableList, table);
}
slReverse(&tableList);
return tableList;
}
table* findAllWords (_node** tree, char** grid)
{
table* allWords = tableNew();
int i;
int j;
for (i = 0; i < SIZE_MAX_GRID; ++i)
{
for (j = 0; j < SIZE_MAX_GRID; ++j)
{
if (DEBUG) tablePrint(allWords);
position* p = malloc(sizeof(position));
p->x = i;
p->y = j;
stack* s = stackNew();
stackPush(s,p);
looking (tree, grid, &(grid[i][j]), s, allWords);
}
}
}
static void xmlCloneTree(void* Pool,PXMLNode x,PXMLNode nx)
{
nx->eType=x->eType;
if(x->szCont)nx->szCont=xstrdup(Pool,x->szCont);
if(x->tAttrs)
{
pchar k,v;
tableFirst(x->tAttrs);
nx->tAttrs=tableNew(Pool,TABLE_FLAG_ALLOCNAME);
while(tableNext(x->tAttrs,&k,&v))
{
tableSet(nx->tAttrs,k,v);
}
}
if(x->hChildren)
{
PXMLNode p=x->pChildren;
PXMLNode np=NULL,c;
PHashLink l;
nx->hChildren=hashNewEx(Pool,x->hChildren->iCount);
while(p)
{
c=xmlNewChild(Pool,nx,p->eType);
if(np)np->pNext=c;
else nx->pChildren=c;
np=c;
//c->pParent=nx;
if(p->szName)
{
l=hashAdd(nx->hChildren,p->szName,c);
c->szName=l->szKey;
}
xmlCloneTree(Pool,p,c);
p=p->pNext;
}
}
}
static int xmlParseTag(void* Pool,PXMLNode x,PXMLNode* p,pchar src,int i)
{
int st,j,q;
for(;;)
{
i=xmlSkipSpace(src,i);CHK;
if(src[i]=='/')
{
if(src[i+1]!='>')return 0;
x->eType=xmlEmpty;
return i+2;
}
if(src[i]=='>')
{
*p=x;
return i+1;
}
st=i;
i=xmlGetWordEnd(src,i);CHK;
if(src[i]!='=')return 0;
if(src[i+1]!='"' && src[i+1]!='\'')return 0;
q=src[i+1];
src[i]=0;
i+=2;
j=i;
i=xmlSkipTill(src,i,(xchar)q);
if(i==-1)
{
src[j-2]='=';
return 0;
}
if(x->tAttrs==NULL)x->tAttrs=tableNew(Pool,TABLE_FLAG_ALLOCNAME);
tableAdd(x->tAttrs,src+st,xmlSubst(xstrndup(Pool,src+j,i-j)));
src[j-2]='=';
i++;
}
// return i;
}
void xmlSetItemAttr(void* Pool,PXMLNode x,pchar Name,pchar Value)
{
if(!x)return;
if(!x->tAttrs)x->tAttrs=tableNew(Pool,TABLE_FLAG_ALLOCNAME);
tableSet(x->tAttrs,Name,xstrdup(Pool,Value));
}
void rAddParentKeys(struct dtdElement *parent, struct dtdElChild *elAsChild,
struct hash *tableHash, struct table **pTableList, int level)
/* Recursively add parentKeys. */
{
struct dtdElement *element = elAsChild->el;
struct dtdElChild *child;
struct table *table = hashMustFindVal(tableHash, element->mixedCaseName);
struct table *parentTable = hashMustFindVal(tableHash, parent->mixedCaseName);
struct field *field;
char linkUniqName[256];
int i;
static struct dtdElChild *parentStack[256];
if (level >= ArraySize(parentStack))
errAbort("Recursion too deep in rAddParentKeys");
parentStack[level] = elAsChild;
for (i=level-1; i>= 0; i -= 1)
if (elAsChild == parentStack[i])
return; /* Avoid cycling on self. */
/* Add new field in parent. */
safef(linkUniqName, sizeof(linkUniqName), "%s.%s",
parentTable->name, table->name);
if (!hashLookup(rUniqParentLinkHash, linkUniqName))
{
hashAdd(rUniqParentLinkHash, linkUniqName, NULL);
verbose(3, "Linking %s to parent %s\n", table->name, parentTable->name);
if (elAsChild->copyCode == '1' || elAsChild->copyCode == '?')
{
struct fieldRef *ref;
char *fieldName = renameUnique(parentTable->fieldHash, element->name);
char *fieldMixedName = renameUnique(parentTable->fieldMixedHash,
element->mixedCaseName);
field = addFieldToTable(parentTable,
fieldName, fieldMixedName,
table->primaryKey->attStat, TRUE, TRUE,
table->primaryKey->isString, textField);
AllocVar(ref);
ref->field = field;
slAddHead(&table->parentKeys, ref);
}
else
{
/* Need to handle association here. */
struct table *assocTable;
struct assocRef *ref;
char joinedName[256];
char *assocTableName;
int upperAt;
safef(joinedName, sizeof(joinedName), "%sTo%s", parentTable->name,
table->name);
upperAt = strlen(parentTable->name) + 2;
joinedName[upperAt] = toupper(joinedName[upperAt]);
assocTableName = renameUnique(tableHash, joinedName);
assocTable = tableNew(joinedName, NULL, NULL);
assocTable->isAssoc = TRUE;
addFieldToTable(assocTable, parentTable->name, parentTable->name,
parentTable->primaryKey->attStat, TRUE, TRUE,
parentTable->primaryKey->isString, textField);
addFieldToTable(assocTable, table->name, table->name,
table->primaryKey->attStat, TRUE, TRUE,
table->primaryKey->isString, textField);
slAddHead(pTableList, assocTable);
AllocVar(ref);
ref->assoc = assocTable;
ref->parent = parentTable;
slAddHead(&table->parentAssocs, ref);
}
table->linkedParents = TRUE;
}
else
verbose(3, "skipping link %s to parent %s\n", table->name, parentTable->name);
for (child = element->children; child != NULL; child = child->next)
rAddParentKeys(element, child, tableHash, pTableList, level+1);
}
