int write_hp_group_c(ARGUMENTS *args, GWEN_XMLNODE *node,
GWEN_SYNCIO *sio)
{
int rv;
if (GWEN_XMLNode_GetType(node)==GWEN_XMLNodeTypeTag) {
if (strcasecmp(GWEN_XMLNode_GetData(node), "type")==0)
return write_h_struct_c(args, node, sio);
else if (strcasecmp(GWEN_XMLNode_GetData(node), "elem")==0) {
return write_h_elem_c(args, node, sio);
}
else if (strcasecmp(GWEN_XMLNode_GetData(node), "func")==0) {
return write_h_func_c(args, node, sio);
}
else if (strcasecmp(GWEN_XMLNode_GetData(node), "header")==0) {
return write_h_header(args, node, sio, "header");
}
else if (strcasecmp(GWEN_XMLNode_GetData(node), "group")==0) {
GWEN_XMLNODE *n;
n=GWEN_XMLNode_GetFirstTag(node);
while (n) {
rv=write_hp_group_c(args, n, sio);
if (rv)
return rv;
n=GWEN_XMLNode_GetNextTag(n);
} /* while */
} /* if group */
}
return 0;
}
GWEN_XMLNODE *GWEN_XMLNode_FindTag(const GWEN_XMLNODE *n,
const char *tname,
const char *pname,
const char *pvalue) {
while(n) {
if (-1!=GWEN_Text_ComparePattern(n->data, tname, 0)) {
if (pname) {
const char *p;
p=GWEN_XMLNode_GetProperty(n, pname, 0);
if (p) {
if (!pvalue)
return (GWEN_XMLNODE*)n;
if (-1!=GWEN_Text_ComparePattern(pvalue, p, 0))
return (GWEN_XMLNODE*)n;
}
else {
/* return this node if pvalue is 0 an the property does not exist */
if (!pvalue)
return (GWEN_XMLNODE*)n;
}
} /* if pname */
else
return (GWEN_XMLNODE*)n;
}
n=GWEN_XMLNode_GetNextTag(n);
} /* while */
return 0;
}
int GWEN_XMLNode__SetNameSpaces(GWEN_XMLNODE *n,
const char *prefix,
const char *nspace) {
GWEN_XMLNODE *nn;
int rv;
rv=GWEN_XMLNode__CheckAndSetNameSpace(n, prefix, nspace);
if (rv)
return rv;
nn=GWEN_XMLNode_GetFirstTag(n);
while(nn) {
rv=GWEN_XMLNode__CheckAndSetNameSpace(nn, prefix, nspace);
if (rv==-1)
return rv;
else if (rv==0) {
/* check children */
rv=GWEN_XMLNode__SetNameSpaces(nn, prefix, nspace);
if (rv)
return rv;
}
nn=GWEN_XMLNode_GetNextTag(nn);
}
return 0;
}
int GWEN_DBIO__XmlDb_ImportGroup(GWEN_DBIO *dbio,
uint32_t flags,
GWEN_DB_NODE *data,
GWEN_DB_NODE *cfg,
GWEN_XMLNODE *node) {
GWEN_XMLNODE *n;
assert(node);
n=GWEN_XMLNode_GetFirstTag(node);
while(n) {
const char *tname;
const char *s;
tname=GWEN_XMLNode_GetData(n);
assert(tname && *tname);
s=GWEN_XMLNode_GetProperty(n, "type", 0);
if (s) {
if (strcasecmp(s, "group")==0) {
GWEN_DB_NODE *db;
int rv;
db=GWEN_DB_GetGroup(data, flags, tname);
if (db==0) {
DBG_INFO(GWEN_LOGDOMAIN, "here");
return GWEN_ERROR_INVALID;
}
rv=GWEN_DBIO__XmlDb_ImportGroup(dbio, flags, db, cfg, n);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
}
else if (strcasecmp(s, "var")==0) {
int rv;
rv=GWEN_DBIO__XmlDb_ImportVar(dbio, flags, data, cfg, n);
if (rv) {
DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
return rv;
}
}
else {
DBG_ERROR(GWEN_LOGDOMAIN, "Unexpected type \"%s\"", s);
return GWEN_ERROR_INVALID;
}
}
n=GWEN_XMLNode_GetNextTag(n);
}
return 0;
}
GWEN_XMLNODE *GWEN_XMLNode_FindNextTag(const GWEN_XMLNODE *n,
const char *tname,
const char *pname,
const char *pvalue) {
GWEN_XMLNODE *nn;
nn=GWEN_XMLNode_GetNextTag(n);
if (!nn)
return 0;
return GWEN_XMLNode_FindTag(nn,
tname,
pname,
pvalue);
}
int GWEN_XMLNode__CheckNameSpaceDecls3(GWEN_XMLNODE *n) {
GWEN_XMLPROPERTY *pr;
GWEN_XMLNODE *nn;
int rv;
/* move all namespace declarations from this node to the nodes
* of first use */
pr=n->properties;
while(pr) {
GWEN_XMLPROPERTY *prNext;
prNext=pr->next;
if (strcasecmp(pr->name, "xmlns")==0 ||
strncasecmp(pr->name, "xmlns:", 6)==0) {
const char *prefix;
prefix=strchr(pr->name, ':');
if (prefix)
prefix++;
GWEN_XMLProperty_del(pr, &n->properties);
rv=GWEN_XMLNode__SetNameSpaces(n, prefix, pr->value);
DBG_DEBUG(GWEN_LOGDOMAIN, "Removing property \"%s\"",
pr->name);
GWEN_XMLProperty_free(pr);
if (rv==-1)
return rv;
}
pr=prNext;
} /* while */
/* do the same on all sub nodes */
nn=GWEN_XMLNode_GetFirstTag(n);
while(nn) {
rv=GWEN_XMLNode__CheckNameSpaceDecls3(nn);
if (rv) {
return rv;
}
nn=GWEN_XMLNode_GetNextTag(nn);
}
return 0;
}
int write_h_struct_c(ARGUMENTS *args, GWEN_XMLNODE *node,
GWEN_SYNCIO *sio)
{
GWEN_XMLNODE *n;
const char *id;
const char *acc;
const char *prefix;
id=get_struct_property(node, "id", 0);
if (!id) {
DBG_ERROR(0, "No id for struct");
return -1;
}
prefix=get_struct_property(node, "prefix", 0);
if (!prefix) {
DBG_ERROR(0, "No prefix for struct");
return -1;
}
if (write_h_enums(args, node, sio, "private")) {
DBG_ERROR(0, "Error writing enum types");
return -1;
}
if (write_h_funcs(args, node, sio, "private")) {
DBG_ERROR(0, "Error writing function types");
return -1;
}
acc=get_struct_property(node, "access", "public");
if (strcasecmp(acc, "private")==0) {
GWEN_SyncIo_WriteString(sio, "typedef struct ");
GWEN_SyncIo_WriteString(sio, id);
GWEN_SyncIo_WriteString(sio, " ");
GWEN_SyncIo_WriteString(sio, id);
GWEN_SyncIo_WriteLine(sio, ";");
}
GWEN_SyncIo_WriteString(sio, "struct ");
GWEN_SyncIo_WriteString(sio, id);
GWEN_SyncIo_WriteLine(sio, " {");
if (get_struct_property(node, "inherit", 0)) {
GWEN_SyncIo_WriteString(sio, " GWEN_INHERIT_ELEMENT(");
GWEN_SyncIo_WriteString(sio, id);
GWEN_SyncIo_WriteLine(sio, ")");
}
if (get_struct_property(node, "list", 0)) {
GWEN_SyncIo_WriteString(sio, " GWEN_LIST_ELEMENT(");
GWEN_SyncIo_WriteString(sio, id);
GWEN_SyncIo_WriteLine(sio, ")");
}
GWEN_SyncIo_WriteLine(sio, " int _usage;");
GWEN_SyncIo_WriteLine(sio, " int _modified;");
GWEN_SyncIo_WriteLine(sio, "");
n=GWEN_XMLNode_GetFirstTag(node);
while (n) {
int rv;
rv=write_hp_group_c(args, n, sio);
if (rv)
return rv;
n=GWEN_XMLNode_GetNextTag(n);
} /* while */
GWEN_SyncIo_WriteLine(sio, "};");
return 0;
}
int GWEN_XMLNode__CheckNameSpaceDecls1(GWEN_XMLNODE *n,
GWEN_STRINGLIST2 *sl,
const char *currentNameSpace) {
GWEN_XMLPROPERTY *pr;
GWEN_XMLNODE *nn;
char *localNameSpace;
localNameSpace=0;
/* remove all unnecessary namespace declarations from this node */
pr=n->properties;
while(pr) {
GWEN_XMLPROPERTY *prNext;
prNext=pr->next;
if (strcasecmp(pr->name, "xmlns")==0) {
/* default namespace changed ? */
if (localNameSpace) {
if (strcasecmp(pr->value, localNameSpace)==0) {
/* already mentioned name space, remove duplicate property */
GWEN_XMLProperty_del(pr, &n->properties);
GWEN_XMLProperty_free(pr);
}
else {
/* current namespace changed */
GWEN_Memory_dealloc(localNameSpace);
localNameSpace=GWEN_Memory_strdup(pr->value);
}
}
else if (currentNameSpace) {
if (strcasecmp(pr->value, currentNameSpace)==0) {
/* already active name space, remove property */
GWEN_XMLProperty_del(pr, &n->properties);
GWEN_XMLProperty_free(pr);
}
else {
/* current namespace changed */
GWEN_Memory_dealloc(localNameSpace);
localNameSpace=GWEN_Memory_strdup(pr->value);
}
}
else {
/* set current namespace */
GWEN_Memory_dealloc(localNameSpace);
localNameSpace=GWEN_Memory_strdup(pr->value);
}
}
else if (strncasecmp(pr->name, "xmlns:", 6)==0) {
const char *prefix;
const char *x;
prefix=strchr(pr->name, ':');
prefix++;
/* check for redefinition */
x=GWEN_XML_FindNameSpaceByName(sl, prefix);
if (x) {
const char *p;
/* prefix already in use, check whether it is the same namespace */
p=strchr(x, ':');
assert(p);
p++;
if (strcasecmp(p, pr->value)!=0) {
GWEN_BUFFER *xpath;
/* same prefix, different namespace */
xpath=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_XMLNode_GetXPath(0, n, xpath);
DBG_ERROR(GWEN_LOGDOMAIN,
"Redefinition of namespace prefix \"%s\" in \"%s\"",
prefix, GWEN_Buffer_GetStart(xpath));
GWEN_Buffer_free(xpath);
return -1;
} /* if different namespace for same prefix */
else {
/* already in list, remove property here */
GWEN_XMLProperty_del(pr, &n->properties);
GWEN_XMLProperty_free(pr);
}
}
else {
GWEN_XML_AddNameSpace(sl, prefix, pr->value);
}
}
pr=prNext;
} /* while */
/* do the same on all sub nodes */
nn=GWEN_XMLNode_GetFirstTag(n);
while(nn) {
int rv;
rv=GWEN_XMLNode__CheckNameSpaceDecls1(nn, sl,
localNameSpace?localNameSpace:
currentNameSpace);
if (rv) {
GWEN_Memory_dealloc(localNameSpace);
return rv;
}
nn=GWEN_XMLNode_GetNextTag(nn);
}
GWEN_Memory_dealloc(localNameSpace);
return 0;
}
