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())); } }