int gen_nc_xml(const struct nc_state_t *nc_state_param)
{
int ret = EUCA_ERROR;
char path[MAX_PATH] = "";
xmlDocPtr doc = NULL;
xmlNodePtr nc = NULL;
xmlNodePtr version = NULL;
xmlNodePtr enabled = NULL;
INIT();
pthread_mutex_lock(&xml_mutex);
{
doc = xmlNewDoc(BAD_CAST "1.0");
nc = xmlNewNode(NULL, BAD_CAST "nc");
xmlDocSetRootElement(doc, nc);
version = xmlNewChild(nc, NULL, BAD_CAST "version", BAD_CAST(nc_state_param->version));
enabled = xmlNewChild(nc, NULL, BAD_CAST "enabled", BAD_CAST(nc_state_param->is_enabled ? "true" : "false"));
snprintf(path, sizeof(path), EUCALYPTUS_NC_STATE_FILE, nc_state.home);
ret = write_xml_file(doc, "global", path, "nc");
xmlFreeDoc(doc);
}
pthread_mutex_unlock(&xml_mutex);
return (ret);
}
BOOL CLibXmlXmlParser::SetElementValue( LPCTSTR strElementName, LPCTSTR strValue )
{
BOOL bResult = FALSE;
if( this->m_pXMLRootNode )
{
xmlNodePtr pChild = this->m_pXMLRootNode->children;
while( pChild )
{
if( xmlStrcmp( pChild->name , BAD_CAST(strElementName) ) == 0 )
{
break;
}
pChild = pChild->next;
}
if( !pChild )
{
// pChild = xmlNewNode(NULL , BAD_CAST ( strEleName ));
pChild = xmlNewChild( this->m_pXMLRootNode, NULL, BAD_CAST(strElementName), BAD_CAST(strValue) );
}
if( pChild )
{
xmlNodeSetContent( pChild, BAD_CAST( strValue ) );
//pChild->content = BAD_CAST( strValue );
}
bResult = ( NULL != pChild );
}
// 写完保存。
bResult &= this->SaveXML();
return bResult;
}
static int parseHttpStyle(xmlDocPtr doc, xmlNodePtr cur)
{
xmlChar * temp;
int ret=1;
cur = cur->xmlChildrenNode;
while(cur!=NULL){
if(!xmlStrcmp(cur->name,(const xmlChar *)"packetLength")){
temp = xmlNodeListGetString(doc,cur->xmlChildrenNode,1);
if(temp!=NULL){
httpConTemp->packetLength=atoi((char *)temp);
if(httpConTemp->packetLength>MAXLENGTH)
httpConTemp->packetLength=MAXLENGTH;
}
else{
printf("X Error: read xml 'style.packetLength' Wrong.\n");
ret &= 0;
}
xmlFree(temp);
}
else if(!xmlStrcmp(cur->name,(const xmlChar *)"dataHeader")){
parseHttpDataHeader(doc,cur);
}
else if(!xmlStrcmp(cur->name,(const xmlChar *)"data")){
temp = xmlGetProp(cur,BAD_CAST("random"));
if(xmlStrcmp(temp,BAD_CAST("true"))==0)
httpConTemp->dataRandom = 1;
else
httpConTemp->dataRandom = 2;
xmlFree(temp);
parseHttpData(doc,cur,httpConTemp->dataRandom);
}
cur = cur->next;
}
return ret;
}
/**\brief Save this Planet to an xml node
*/
xmlNodePtr Planet::ToXMLNode(string componentName) {
char buff[256];
xmlNodePtr section = xmlNewNode(NULL, BAD_CAST componentName.c_str() );
xmlNewChild(section, NULL, BAD_CAST "name", BAD_CAST this->GetName().c_str() );
xmlNewChild(section, NULL, BAD_CAST "alliance", BAD_CAST this->GetAlliance()->GetName().c_str() );
snprintf(buff, sizeof(buff), "%d", (int)this->GetWorldPosition().GetX() );
xmlNewChild(section, NULL, BAD_CAST "x", BAD_CAST buff );
snprintf(buff, sizeof(buff), "%d", (int)this->GetWorldPosition().GetY() );
xmlNewChild(section, NULL, BAD_CAST "y", BAD_CAST buff );
xmlNewChild(section, NULL, BAD_CAST "landable", BAD_CAST (this->GetLandable()?"1":"0") );
snprintf(buff, sizeof(buff), "%d", this->GetTraffic() );
xmlNewChild(section, NULL, BAD_CAST "traffic", BAD_CAST buff );
xmlNewChild(section, NULL, BAD_CAST "image", BAD_CAST this->GetImage()->GetPath().c_str() );
snprintf(buff, sizeof(buff), "%d", this->GetMilitiaSize() );
xmlNewChild(section, NULL, BAD_CAST "militia", BAD_CAST buff );
snprintf(buff, sizeof(buff), "%d", this->GetInfluence() );
xmlNewChild(section, NULL, BAD_CAST "sphereOfInfluence", BAD_CAST buff );
list<Technology*> techs = this->GetTechnologies();
for( list<Technology*>::iterator it = techs.begin(); it!=techs.end(); ++it ){
xmlNewChild(section, NULL, BAD_CAST "technology", BAD_CAST (*it)->GetName().c_str() );
}
return section;
}
/**
* Prepare XSLT stylesheet based on command line options
*/
int
selPrepareXslt(xmlDocPtr style, selOptionsPtr ops, xmlChar *ns_arr[],
int start, int argc, char **argv)
{
int i, t, ns, use_inputfile = 0, use_value_of = 0;
xmlNodePtr root, root_template = NULL;
xmlNsPtr xslns;
xmlBufferPtr attr_buf;
root = xmlNewDocRawNode(style, NULL, BAD_CAST "stylesheet", NULL);
xmlDocSetRootElement(style, root);
xmlNewProp(root, BAD_CAST "version", BAD_CAST "1.0");
xslns = xmlNewNs(root, XSLT_NAMESPACE, BAD_CAST "xsl");
xmlSetNs(root, xslns);
ns = 0;
while(ns_arr[ns])
{
xmlNewNs(root, ns_arr[ns+1], xmlStrlen(ns_arr[ns])?ns_arr[ns] : NULL);
ns += 2;
}
cleanupNSArr(ns_arr);
{
xmlNodePtr output;
output = xmlNewChild(root, xslns, BAD_CAST "output", NULL);
xmlNewProp(output, BAD_CAST "omit-xml-declaration",
BAD_CAST ((ops->no_omit_decl)?"no":"yes"));
xmlNewProp(output, BAD_CAST "indent",
BAD_CAST ((ops->indent)?"yes":"no"));
if (ops->encoding) xmlNewProp(output, BAD_CAST "encoding", ops->encoding);
if (ops->outText) xmlNewProp(output, BAD_CAST "method", BAD_CAST "text");
}
for (i = start, t = 0; i < argc; i++)
if(!strcmp(argv[i], "-t") || !strcmp(argv[i], "--template"))
t++;
/*
* At least one -t option must be found
*/
if (t == 0)
{
fprintf(stderr, "error in arguments:");
fprintf(stderr, " no -t or --template options found\n");
exit(EXIT_BAD_ARGS);
}
if (t > 1)
root_template = xmlNewChild(root, xslns, BAD_CAST "template", NULL);
t = 0;
i = start;
while(i < argc)
{
if(!strcmp(argv[i], "-t") || !strcmp(argv[i], "--template"))
{
xmlNodePtr call_template, template;
int lastTempl = 0;
t++;
static void
xml_out_string (xmlTextWriterPtr xml, const char *name, const char *value)
{
xmlTextWriterStartElement (xml, BAD_CAST ("option"));
xmlTextWriterWriteAttribute (xml, BAD_CAST ("name"), BAD_CAST (name));
xmlTextWriterWriteAttribute (xml, BAD_CAST ("value"), BAD_CAST (value));
xmlTextWriterEndElement (xml);
}
History::Contact::Contact (boost::shared_ptr<Ekiga::ContactCore> _contact_core,
boost::shared_ptr<xmlDoc> _doc,
xmlNodePtr _node):
contact_core(_contact_core), doc(_doc), node(_node)
{
xmlChar* xml_str = NULL;
xml_str = xmlGetProp (node, (const xmlChar *)"type");
if (xml_str != NULL) {
m_type = (call_type)(xml_str[0] - '0'); // FIXME: I don't like it!
xmlFree (xml_str);
}
xml_str = xmlGetProp (node, (const xmlChar *)"uri");
if (xml_str != NULL) {
uri = (const char *)xml_str;
xmlFree (xml_str);
}
for (xmlNodePtr child = node->children ;
child != NULL ;
child = child->next) {
if (child->type == XML_ELEMENT_NODE
&& child->name != NULL) {
if (xmlStrEqual (BAD_CAST ("name"), child->name)) {
xml_str = xmlNodeGetContent (child);
if (xml_str != NULL)
name = (const char *)xml_str;
xmlFree (xml_str);
}
if (xmlStrEqual (BAD_CAST ("call_start"), child->name)) {
xml_str = xmlNodeGetContent (child);
if (xml_str != NULL)
call_start = (time_t) atoi ((const char *) xml_str);
xmlFree (xml_str);
}
if (xmlStrEqual (BAD_CAST ("call_duration"), child->name)) {
xml_str = xmlNodeGetContent (child);
if (xml_str != NULL)
call_duration = (const char *) xml_str;
xmlFree (xml_str);
}
}
}
}
void
xen_init(void)
{
responsePath =
xmlXPathCompile(
BAD_CAST(
"/methodResponse/params/param/value/struct/member/value"));
faultPath =
xmlXPathCompile(
BAD_CAST("/methodResponse/fault/value/struct/member/value"));
}
static void
xml_out_binding (xmlTextWriterPtr xml, const char *name, unsigned int value)
{
char string[1024];
snprintf (string, 1024, "%u", value);
xmlTextWriterStartElement (xml, BAD_CAST ("binding"));
xmlTextWriterWriteAttribute (xml, BAD_CAST ("name"), BAD_CAST (name));
xmlTextWriterWriteAttribute (xml, BAD_CAST ("binding"), BAD_CAST (string));
xmlTextWriterEndElement (xml);
}
static int parsePacketTime (xmlDocPtr doc, xmlNodePtr cur)
{
xmlChar * temp;
int flag_ptime_random;
int ptime_value,ptime_meth;
int ret=1;
temp = xmlGetProp(cur,BAD_CAST("random"));
if(temp!=NULL){
if(xmlStrcmp(temp,BAD_CAST("false"))==0)
flag_ptime_random = 2;
else
flag_ptime_random = 1;
xmlFree(temp);
cur = cur->xmlChildrenNode;
while(cur!=NULL){
if(flag_ptime_random==2&&!xmlStrcmp(cur->name,(const xmlChar *)"value")){
temp=xmlNodeListGetString(doc,cur->xmlChildrenNode,1);
if(temp!=NULL){
ptime_value = atoi((char *)temp);
}
else{
printf("X Error: read xml 'packetTime.value' Wrong.\n");
ret &= 0;
}
xmlFree(temp);
}
else if(flag_ptime_random==1&&!xmlStrcmp(cur->name,(const xmlChar *)"scope")){
ret &= parsePacketTimeScope(doc,cur);
}
else if(flag_ptime_random==1&&!xmlStrcmp(cur->name,(const xmlChar *)"meth")){
temp=xmlNodeListGetString(doc,cur->xmlChildrenNode,1);
if(temp!=NULL){
ptime_meth = atoi((char *)temp);
}
else{
printf("X Error: read xml 'packetTime.meth' Wrong.\n");
ret &= 0;
}
xmlFree(temp);
}
cur = cur->next;
}
ddosc->packetTimels = get_packetTime(flag_ptime_random,
ptime_value,
ptime_from,ptime_to,ptime_meth);
}
else{
printf("X Error: read xml 'packetTime.random' Wrong.\n");
xmlFree(temp);
return 0;
}
return ret;
}
History::Contact::Contact (Ekiga::ServiceCore &_core,
xmlNodePtr _node):
core(_core), node(_node)
{
xmlChar *xml_str;
contact_core
= dynamic_cast<Ekiga::ContactCore*>(core.get ("contact-core"));
xml_str = xmlGetProp (node, (const xmlChar *)"type");
if (xml_str != NULL)
m_type = (call_type)(xml_str[0] - '0'); // FIXME: I don't like it!
xmlFree (xml_str);
xml_str = xmlGetProp (node, (const xmlChar *)"uri");
if (xml_str != NULL)
uri = (const char *)xml_str;
xmlFree (xml_str);
for (xmlNodePtr child = node->children ;
child != NULL ;
child = child->next) {
if (child->type == XML_ELEMENT_NODE
&& child->name != NULL) {
if (xmlStrEqual (BAD_CAST ("name"), child->name)) {
xml_str = xmlNodeGetContent (child);
if (xml_str != NULL)
name = (const char *)xml_str;
xmlFree (xml_str);
}
if (xmlStrEqual (BAD_CAST ("call_start"), child->name)) {
xml_str = xmlNodeGetContent (child);
if (xml_str != NULL)
call_start = (time_t) atoi ((const char *) xml_str);
xmlFree (xml_str);
}
if (xmlStrEqual (BAD_CAST ("call_duration"), child->name)) {
xml_str = xmlNodeGetContent (child);
if (xml_str != NULL)
call_duration = (const char *) xml_str;
xmlFree (xml_str);
}
}
}
}
static xar_file_t xar_link_lookup(xar_t x, dev_t dev, ino_t ino, xar_file_t f) {
char key[32];
xar_file_t ret;
memset(key, 0, sizeof(key));
snprintf(key, sizeof(key)-1, "%08" DEV_HEXSTRING "%08" INO_HEXSTRING, DEV_CAST dev, INO_CAST ino);
ret = xmlHashLookup(XAR(x)->ino_hash, BAD_CAST(key));
if( ret == NULL ) {
xmlHashAddEntry(XAR(x)->ino_hash, BAD_CAST(key), XAR_FILE(f));
return NULL;
}
return ret;
}
/*------------------------------------------------------------------------------*/
static void
cluster_getparam(int thr_nb, void *data, cl_error_desc_t *err_desc)
{
xmlDocPtr doc = NULL;
xmlNodePtr exanodes_node;
int ret;
exalog_debug("getparam");
/* Create XML document */
doc = xmlNewDoc(BAD_CAST("1.0"));
if (doc == NULL)
{
set_error(err_desc, -EXA_ERR_XML_INIT, "Failed to create result document");
return;
}
exanodes_node = xmlNewNode(NULL, BAD_CAST("Exanodes"));
if (exanodes_node == NULL)
{
set_error(err_desc, -EXA_ERR_XML_INIT,
"Failed to create node in result document");
xmlFreeDoc(doc);
return;
}
xmlDocSetRootElement(doc, exanodes_node);
ret = build_response(exanodes_node);
if (ret == EXA_SUCCESS)
{
xmlChar *xmlchar_doc;
int buf_size;
xmlDocDumpFormatMemory(doc, &xmlchar_doc, &buf_size, 1);
send_payload_str((char *)xmlchar_doc);
xmlFree(xmlchar_doc);
}
xmlFreeDoc(doc);
set_error(err_desc, ret, NULL);
}
tstring CLibXmlXmlParser::GetElementValue(LPCTSTR strElementName)
{
tstring strResult;
if( this->m_pXMLRootNode )
{
xmlNodePtr pChild = this->m_pXMLRootNode->children;
while( pChild )
{
if( xmlStrcmp( pChild->name , BAD_CAST(strElementName) ) == 0 )
{
break;
}
pChild = pChild->next;
}
if( pChild )
{
// !Content of the node can't be read directly!
strResult = (LPCTSTR)xmlNodeGetContent( pChild );//(LPCTSTR)pChild->content;
// mcu::tlog << "read config: " << strResult << endl;
}
}
return strResult;
}
const char * config_get_value(const char * _xpath) {
xmlXPathObjectPtr xmlobject = NULL;
const xmlChar * xpath = BAD_CAST(_xpath);
const xmlChar * value = NULL;
/* Rquete XPath*/
xmlobject = xmlXPathEval(xpath, config->context);
if (!xmlobject)
return NULL;
if (xmlobject->type == XPATH_NODESET) {
if (xmlobject->nodesetval) {
/* nodeNr = nb nodes in struct nodesetval */
if (xmlobject->nodesetval->nodeNr > 0) {
xmlNodePtr n;
n = xmlobject->nodesetval->nodeTab[0];
if ((n->type == XML_TEXT_NODE) ||
(n->type == XML_CDATA_SECTION_NODE))
value = n->content;
}
}
}
xmlXPathFreeObject(xmlobject);
return (char *)value;
}
xmlNodeSetPtr getXNodes(xmlXPathContextPtr context, const gchar *xpath) {
xmlXPathObjectPtr xobj = xmlXPathEvalExpression(BAD_CAST(xpath), context);
xmlNodeSetPtr ret = xobj->nodesetval;
xmlXPathFreeNodeSetList(xobj);
return ret;
}
LM::Bank::Bank (boost::shared_ptr<Ekiga::PersonalDetails> details_,
boost::shared_ptr<Dialect> dialect_,
boost::shared_ptr<Cluster> cluster_):
details(details_), cluster(cluster_), dialect(dialect_), doc (NULL)
{
gchar* c_raw = gm_conf_get_string (JABBER_KEY);
if (c_raw != NULL) { // we already have it in store
const std::string raw = c_raw;
doc = xmlRecoverMemory (raw.c_str (), raw.length ());
xmlNodePtr root = xmlDocGetRootElement (doc);
if (root == NULL) {
root = xmlNewDocNode (doc, NULL, BAD_CAST "list", NULL);
xmlDocSetRootElement (doc, root);
}
for (xmlNodePtr child = root->children; child != NULL; child = child->next) {
if (child->type == XML_ELEMENT_NODE && child->name != NULL && xmlStrEqual (BAD_CAST ("entry"), child->name)) {
boost::shared_ptr<Account> account (new Account (details, dialect, cluster, child));
add (account);
}
}
g_free (c_raw);
} else { // create a new XML document
doc = xmlNewDoc (BAD_CAST "1.0");
xmlNodePtr root = xmlNewDocNode (doc, NULL, BAD_CAST "list", NULL);
xmlDocSetRootElement (doc, root);
}
}
void
Local::Presentity::rename_group (const std::string old_name,
const std::string new_name)
{
bool old_name_present = false;
bool already_in_new_name = false;
std::set<xmlNodePtr> nodes_to_remove;
/* remove the old name's node
* and check if we aren't already in the new name's group
*/
for (xmlNodePtr child = node->children ;
child != NULL ;
child = child->next) {
if (child->type == XML_ELEMENT_NODE
&& child->name != NULL) {
if (xmlStrEqual (BAD_CAST ("group"), child->name)) {
xmlChar* xml_str = xmlNodeGetContent (child);
if (xml_str != NULL) {
if (!xmlStrcasecmp ((const xmlChar*)old_name.c_str (), xml_str)) {
nodes_to_remove.insert (child); // don't free what we loop on!
old_name_present = true;
}
if (!xmlStrcasecmp ((const xmlChar*)new_name.c_str (), xml_str)) {
already_in_new_name = true;
}
xmlFree (xml_str);
}
}
}
}
// ok, now we can clean up!
for (std::set<xmlNodePtr>::iterator iter = nodes_to_remove.begin ();
iter != nodes_to_remove.end ();
++iter) {
xmlUnlinkNode (*iter);
xmlFreeNode (*iter);
}
if (old_name_present && !already_in_new_name) {
xmlNewChild (node, NULL,
BAD_CAST "group",
BAD_CAST robust_xmlEscape (node->doc,
new_name).c_str ());
}
updated ();
trigger_saving ();
}
void
RL::Heap::parse_doc (std::string raw)
{
doc = std::tr1::shared_ptr<xmlDoc> (xmlRecoverMemory (raw.c_str (), raw.length ()), xmlFreeDoc);
if ( !doc)
doc = std::tr1::shared_ptr<xmlDoc> (xmlNewDoc (BAD_CAST "1.0"), xmlFreeDoc);
xmlNodePtr doc_root = xmlDocGetRootElement (doc.get ());
if (doc_root == NULL
|| doc_root->name == NULL
|| !xmlStrEqual (BAD_CAST "resource-lists", doc_root->name)) {
std::cout << "Invalid document in " << __PRETTY_FUNCTION__ << std::endl;
// FIXME: warn the user somehow?
doc.reset ();
} else {
for (xmlNodePtr child = doc_root->children;
child != NULL;
child = child->next)
if (child->type == XML_ELEMENT_NODE
&& child->name != NULL
&& xmlStrEqual (BAD_CAST ("list"), child->name)) {
parse_list (child);
break; // read only one!
}
}
}
const std::string
Local::Presentity::get_name () const
{
std::string name;
xmlChar* xml_str = NULL;
for (xmlNodePtr child = node->children ;
child != NULL ;
child = child->next) {
if (child->type == XML_ELEMENT_NODE
&& child->name != NULL) {
if (xmlStrEqual (BAD_CAST ("name"), child->name)) {
xml_str = xmlNodeGetContent (child);
if (xml_str != NULL) {
name = (const char*)xml_str;
xmlFree (xml_str);
} else {
name = _("Unnamed");
}
}
}
}
return name;
}
const std::set<std::string>
Local::Presentity::get_groups () const
{
std::set<std::string> groups;
for (xmlNodePtr child = node->children ;
child != NULL ;
child = child->next) {
if (child->type == XML_ELEMENT_NODE
&& child->name != NULL) {
if (xmlStrEqual (BAD_CAST ("group"), child->name)) {
xmlChar* xml_str = xmlNodeGetContent (child);
if (xml_str != NULL) {
groups.insert ((const char*) xml_str);
xmlFree (xml_str);
}
}
}
}
return groups;
}
static xmlNodePtr analyze_board(Board *b)
{
xmlNodePtr anaNode;
anaNode = xmlNewNode(NULL, BAD_CAST("analysis"));
(void)b; /* TODO */
return anaNode;
}
libvisio::VSDXRelationships::VSDXRelationships(librevenge::RVNGInputStream *input)
: m_relsByType(), m_relsById()
{
if (input)
{
const std::shared_ptr<xmlTextReader> reader(
xmlReaderForStream(input, nullptr, nullptr, XML_PARSE_NOBLANKS|XML_PARSE_NOENT|XML_PARSE_NONET|XML_PARSE_RECOVER),
xmlFreeTextReader);
if (reader)
{
bool inRelationships = false;
int ret = xmlTextReaderRead(reader.get());
while (ret == 1)
{
const xmlChar *name = xmlTextReaderConstName(reader.get());
if (name)
{
if (xmlStrEqual(name, BAD_CAST("Relationships")))
{
if (xmlTextReaderNodeType(reader.get()) == 1)
{
// VSD_DEBUG_MSG(("Relationships ON\n"));
inRelationships = true;
}
else if (xmlTextReaderNodeType(reader.get()) == 15)
{
// VSD_DEBUG_MSG(("Relationships OFF\n"));
inRelationships = false;
}
}
else if (xmlStrEqual(name, BAD_CAST("Relationship")))
{
if (inRelationships)
{
VSDXRelationship relationship(reader.get());
m_relsByType[relationship.getType()] = relationship;
m_relsById[relationship.getId()] = relationship;
}
}
}
ret = xmlTextReaderRead(reader.get());
}
}
}
}
xmlXPathObjectPtr evalXPath(xmlXPathContextPtr context, const gchar *xpath) {
xmlXPathObjectPtr result = xmlXPathEvalExpression(BAD_CAST(xpath), context);
if(result == NULL) {
g_warning("xmlXPathEvalExpression '%s' failed!\n", xpath);
exit(1);
}
return result;
}
xml_doc_info * SACONFIG_API xml_CreateDoc(char const * const xml_root, char const * const xml_base)
{
xml_doc_info * docinfo = NULL;
xmlDocPtr doc = NULL;
xmlNodePtr curNode = NULL;
xmlInitParser();
doc = xmlNewDoc(BAD_CAST("1.0"));
curNode = xmlNewNode(NULL, BAD_CAST(xml_root));
xmlDocSetRootElement(doc, curNode);
curNode = xmlNewChild(curNode, NULL, BAD_CAST(xml_base), NULL);
docinfo = (xml_doc_info *)malloc(sizeof(xml_doc_info));
memset(docinfo, 0, sizeof(xml_doc_info));
docinfo->isInitParser = true;
docinfo->doc = doc;
strcpy(docinfo->xml_root, xml_root);
strcpy(docinfo->xml_base, xml_base);
return docinfo;
}
std::string tiary::xml_make (const XMLNode *root)
{
/**
* I have considered directly generating the XML text, which should
* not be difficult to implement and obviously more efficient than
* using libxml2.
*
* However, considering there are many details in XML that I may
* easily forget, (say, always remember to replace special characters
* with escape sequences starting with "&")
* I decide to stick to libxml2.
*/
std::string ret;
if (const XMLNodeTree *iroot = dynamic_cast <const XMLNodeTree *> (root)) {
libxml2_init ();
xmlDocPtr doc = xmlNewDoc (BAD_CAST "1.0"); // "1.0" - XML version
xmlNodePtr oroot = xmlNewNode(0, BAD_CAST (iroot->name.c_str()));
xmlDocSetRootElement(doc, oroot);
// "(a,b) in stk" means "a's children should be copied as b's children"
std::stack<std::pair<const XMLNodeTree *, xmlNodePtr>, std::vector<std::pair<const XMLNodeTree *, xmlNodePtr> > > stk;
xmlNodePtr optr = oroot; // Current working output node
const XMLNodeTree *iptr = iroot; // Current working input node
for (;;) {
// Shallow copy all children of current node
for (XMLNode *child_ptr = iptr->children; child_ptr; child_ptr = child_ptr->next) {
if (xmlNodePtr nptr = shallow_copy (child_ptr)) {
xmlAddChild (optr, nptr);
if (const XMLNodeTree *ip = dynamic_cast <const XMLNodeTree *> (child_ptr)) {
stk.push (std::make_pair (ip, nptr));
}
}
}
if (stk.empty ()) {
break;
}
iptr = stk.top().first;
optr = stk.top().second;
stk.pop ();
}
xmlChar *str;
int len;
xmlDocDumpMemoryEnc (doc, &str, &len, "UTF-8");
xmlFreeDoc (doc);
ret.assign ((const char*)str, len);
xmlFree (str);
}
return ret;
}
xmlNodePtr Lua::ConvertToXML( lua_State *L, int value_index, int key_index) {
int t;
char buff[1024];
xmlNodePtr section = xmlNewNode(NULL, BAD_CAST "value");
// Using lua_tostring will convert a value into a string.
// Never use this on a table key.
lua_pushvalue(L, key_index);
t = lua_type(L, key_index);
// Save the Key and keytype
xmlSetProp( section, BAD_CAST "key", BAD_CAST lua_tostring(L, lua_gettop(L)) );
xmlSetProp( section, BAD_CAST "keytype", BAD_CAST lua_typename(L, t));
lua_pop(L,1); // Pop the copied key now that we're done with it.
// Save the type
t = lua_type(L, value_index);
xmlSetProp( section, BAD_CAST "type", BAD_CAST lua_typename(L, t));
// Save the value
switch (t) {
case LUA_TBOOLEAN:
xmlNodeSetContent( section, BAD_CAST (lua_toboolean(L, value_index) ? "true" : "false"));
break;
case LUA_TNUMBER:
snprintf(buff, sizeof(buff), "%f", lua_tonumber(L, value_index) );
xmlNodeSetContent( section, BAD_CAST buff);
break;
case LUA_TSTRING:
xmlNodeSetContent( section, BAD_CAST lua_tostring(L, value_index) );
break;
case LUA_TTABLE:
lua_pushnil(L);
while(lua_next(L, value_index)) {
xmlAddChild( section, Lua::ConvertToXML(L, lua_gettop(L), lua_gettop(L)-1));
// Pop off this value
lua_pop(L, 1);
}
break;
case LUA_TNIL:
case LUA_TLIGHTUSERDATA:
case LUA_TFUNCTION:
case LUA_TUSERDATA:
case LUA_TTHREAD:
xmlAddChild( section, xmlNewComment( BAD_CAST "Cannot convert to XML"));
break;
default:
assert(0);
break;
}
return section;
}
int getsempkey(void* lpxmlDoc,int* lpResult)
{
xmlDocPtr pxmlDoc;
xmlNodePtr cur;
xmlNodePtr curpath;
xmlXPathContextPtr context = NULL;
xmlXPathObjectPtr result = NULL;
xmlNodeSetPtr nodeset;
xmlAttrPtr attrPtr;
xmlChar *key;
xmlChar *xpath = BAD_CAST("/application/semkey");
pxmlDoc = (xmlDocPtr)lpxmlDoc;
cur = xmlDocGetRootElement(pxmlDoc);
if (cur == NULL)
{
printf("Can't get the root element\n");
return 0;
}
context = xmlXPathNewContext(pxmlDoc);
result = xmlXPathEvalExpression(xpath, context);
xmlXPathFreeContext(context);
if (result != NULL)
{
if (xmlXPathNodeSetIsEmpty(result->nodesetval) == 0)
{
nodeset = result->nodesetval;
if(nodeset->nodeNr > 0)
{
curpath = nodeset->nodeTab[0];
if(curpath != NULL)
{
attrPtr = curpath->properties;
while (attrPtr != NULL)
{
if (!xmlStrcmp(attrPtr->name, BAD_CAST "value"))
{
key = xmlGetProp(curpath,(const xmlChar *)"value");
printf("semid: %s\n", key);
*lpResult = atoi((char*)key);
xmlFree(key);
}
attrPtr = attrPtr->next;
}
}
}
}
xmlXPathFreeObject(result);
}
return 0;
}
/**\brief Converts the Model to an XML node.
*/
xmlNodePtr Model::ToXMLNode(string componentName) {
char buff[256];
xmlNodePtr section = xmlNewNode(NULL, BAD_CAST componentName.c_str());
xmlNewChild(section, NULL, BAD_CAST "name", BAD_CAST this->GetName().c_str() );
xmlNewChild(section, NULL, BAD_CAST "description", BAD_CAST this->GetDescription().c_str() );
xmlNewChild(section, NULL, BAD_CAST "image", BAD_CAST this->GetImage()->GetPath().c_str() );
xmlNewChild(section, NULL, BAD_CAST "engine", BAD_CAST this->GetDefaultEngine()->GetName().c_str() );
snprintf(buff, sizeof(buff), "%1.2f", this->GetMass() );
xmlNewChild(section, NULL, BAD_CAST "mass", BAD_CAST buff );
snprintf(buff, sizeof(buff), "%1.2f", this->GetRotationsPerSecond() );
xmlNewChild(section, NULL, BAD_CAST "rotationsPerSecond", BAD_CAST buff );
snprintf(buff, sizeof(buff), "%d", this->GetThrustOffset() );
xmlNewChild(section, NULL, BAD_CAST "thrustOffset", BAD_CAST buff );
snprintf(buff, sizeof(buff), "%1.1f", this->GetMaxSpeed() );
xmlNewChild(section, NULL, BAD_CAST "maxSpeed", BAD_CAST buff );
snprintf(buff, sizeof(buff), "%d", this->GetHullStrength() );
xmlNewChild(section, NULL, BAD_CAST "hullStrength", BAD_CAST buff );
snprintf(buff, sizeof(buff), "%d", this->GetShieldStrength() );
xmlNewChild(section, NULL, BAD_CAST "shieldStrength", BAD_CAST buff );
snprintf(buff, sizeof(buff), "%d", this->GetMSRP() );
xmlNewChild(section, NULL, BAD_CAST "msrp", BAD_CAST buff );
snprintf(buff, sizeof(buff), "%d", this->GetCargoSpace() );
xmlNewChild(section, NULL, BAD_CAST "cargoSpace", BAD_CAST buff );
char *ntos = (char*)malloc(256);
xmlNodePtr wsPtr = xmlNewNode(NULL, BAD_CAST "weaponSlots");
for(unsigned int w=0;w<weaponSlots.size();w++){
WeaponSlot *slot = &weaponSlots[w];
xmlNodePtr slotPtr = xmlNewNode(NULL, BAD_CAST "slot");
xmlNewChild(slotPtr, NULL, BAD_CAST "name", BAD_CAST slot->name.c_str() );
xmlNodePtr coordPtr = xmlNewNode(NULL, BAD_CAST "coord");
snprintf(ntos, 256, "%d", slot->x);
xmlNewChild(coordPtr, NULL, BAD_CAST "x", BAD_CAST ntos);
snprintf(ntos, 256, "%d", slot->y);
xmlNewChild(coordPtr, NULL, BAD_CAST "y", BAD_CAST ntos);
xmlAddChild(slotPtr, coordPtr);
snprintf(ntos, 256, "%.1f", slot->angle);
xmlNewChild(slotPtr, NULL, BAD_CAST "angle", BAD_CAST ntos);
snprintf(ntos, 256, "%.1f", slot->motionAngle);
xmlNewChild(slotPtr, NULL, BAD_CAST "motionAngle", BAD_CAST ntos);
xmlNewChild(slotPtr, NULL, BAD_CAST "content", BAD_CAST ((slot->content == NULL)
? ""
: slot->content->GetName().c_str()) );
snprintf(ntos, 256, "%d", slot->firingGroup);
xmlNewChild(slotPtr, NULL, BAD_CAST "firingGroup", BAD_CAST ntos);
xmlAddChild(wsPtr, slotPtr);
}
xmlAddChild(section, wsPtr);
free(ntos);
return section;
}
libvisio::VSDXRelationship::VSDXRelationship(xmlTextReaderPtr reader)
: m_id(), m_type(), m_target()
{
if (reader)
// TODO: check whether we are actually parsing "Relationship" element
{
while (xmlTextReaderMoveToNextAttribute(reader))
{
const xmlChar *name = xmlTextReaderConstName(reader);
const xmlChar *value = xmlTextReaderConstValue(reader);
if (xmlStrEqual(name, BAD_CAST("Id")))
m_id = (const char *)value;
else if (xmlStrEqual(name, BAD_CAST("Type")))
m_type = (const char *)value;
else if (xmlStrEqual(name, BAD_CAST("Target")))
m_target = (const char *)value;
}
// VSD_DEBUG_MSG(("Relationship : %s type: %s target: %s\n", m_id.c_str(), m_type.c_str(), m_target.c_str()));
}
}
