/*! * \brief Save an XML document to a file. * @param filename The file to save to. * @param cur The XML document structure. * @return The return value of xmlSaveFormatFileEnc. * @todo Get the proper defn of the return value from libxml2. * \ingroup DiagramXmlIo */ int xmlDiaSaveFile (const char *filename, xmlDocPtr cur) { int old, ret; old = xmlKeepBlanksDefault (0); ret = xmlSaveFormatFileEnc (filename,cur, "UTF-8", 1); xmlKeepBlanksDefault (old); return ret; }
/** Save an XML document to a file. * @param filename The file to save to. * @param cur The XML document structure. * @return The return value of xmlSaveFormatFileEnc. * @bug Get the proper defn of the return value from libxml2. */ int xmlDiaSaveFile(const char *filename, xmlDocPtr cur) { int old = 0, ret; if (pretty_formated_xml) old = xmlKeepBlanksDefault (0); ret = xmlSaveFormatFileEnc (filename,cur, "UTF-8", pretty_formated_xml ? 1 : 0); if (pretty_formated_xml) xmlKeepBlanksDefault (old); return ret; }
// A modified version of XmlSAXParseFile in gnome-xml. This one lets us set // the user_data that is passed to the various callbacks, to make it possible // to avoid lots of global variables. gboolean oreganoXmlSAXParseFile (xmlSAXHandlerPtr sax, gpointer user_data, const gchar *filename) { g_return_val_if_fail (filename != NULL, FALSE); gboolean parser_failed, ret = TRUE; xmlParserCtxtPtr ctxt; ctxt = xmlCreateFileParserCtxt (filename); if (ctxt == NULL) return FALSE; ctxt->sax = sax; ctxt->userData = user_data; #if defined(LIBXML_VERSION) && LIBXML_VERSION >= 20000 xmlKeepBlanksDefault (0); #endif parser_failed = FALSE; if (xmlParseDocument (ctxt) < 0) { // FIXME post a message to the log buffer with as much details as possible g_message ("Failed to parse \"%s\"", filename); ret = FALSE; parser_failed = TRUE; } else { ret = ctxt->wellFormed ? TRUE : FALSE; if (sax != NULL) ctxt->sax = NULL; } if (!parser_failed) xmlFreeParserCtxt (ctxt); return ret; }
int resetQuery() { int ret; xmlDocPtr doc; xmlNodePtr video_node, message_node; xmlKeepBlanksDefault(0); doc = xmlNewDoc(BAD_CAST "1.0"); /* create pod node as root node */ video_node = xmlNewNode(NULL, BAD_CAST "video"); xmlDocSetRootElement(doc, video_node); message_node = xmlNewChild(video_node, NULL, BAD_CAST "message", BAD_CAST NULL); xmlNewChild(message_node, NULL, BAD_CAST "query", BAD_CAST NULL); // Save blank XML RESPONSE to File ret = xmlSaveFormatFileEnc(XML_QUERY, doc, "UTF-8", 1); // Dump to Console // xmlSaveFormatFileEnc("-", doc, "UTF-8", 1); xmlFreeDoc(doc); return ret; }
void save_languages_to_xml (language * languages, int size) { xmlDocPtr doc; xmlNodePtr parent, child; xmlXPathContextPtr xpathCtx; xmlXPathObjectPtr xpathObj; int i; xmlKeepBlanksDefault(0); doc = xmlNewDoc (BAD_CAST "1.0"); parent = xmlNewNode(NULL, "languages"); xmlDocSetRootElement(doc, parent); for(i=0; i<size; i++) { child = xmlNewTextChild (parent, NULL, "lang", NULL); xmlNewTextChild (child, NULL, "name", languages->name); xmlNewTextChild (child, NULL, "code", languages->code); xmlNewTextChild (child, NULL, "flag", languages->flag); languages++; } xmlSaveFormatFile ("src/config/languages.xml", doc, 1); xmlFreeDoc(doc); }
void saveCterms(CIndexer *indexer) { CConnbas_dbox *connbas = indexer->connbas; xmlNodePtr root = xmlDocGetRootElement(indexer->DocCterms); char moddate[16]; // date de m�j time_t timer; time(&timer); struct tm *today; today = localtime(&timer); strftime((char *)moddate, 15, "%Y%m%d%H%M%S", today); xmlSetProp(root, (const xmlChar*)"modification_date", (const xmlChar *)moddate ); xmlChar *out; int outsize; xmlKeepBlanksDefault(0); xmlDocDumpFormatMemory(indexer->DocCterms, &out, &outsize, 1); // zSyslog.log(CSyslog::LOG_INFO, "\n/=================================== Saving CTERMS ========================="); // zSyslog.log(CSyslog::LOG_INFO, "root = %s", root->name); // for(int i=0; i<outsize && i<300; i++) // { // putchar(out[i]); // } zSyslog.log(CSyslog::LOGL_INFO, CSyslog::LOGC_THESAURUS, "#%d : CTERMS saved", connbas->sbas_id); connbas->updatePref_cterms((char *)out, outsize, moddate ); xmlFree(out); indexer->current_cterms_moddate = timer; }
bool gpl::xml::openXPath(const char* fileName, int blank /*= 1*/) { if (m_xml->doc != NULL) closeXPath(); xmlLoadExtDtdDefaultValue |= XML_DETECT_IDS; xmlLoadExtDtdDefaultValue |= XML_COMPLETE_ATTRS; xmlSubstituteEntitiesDefaultValue = 1; xmlKeepBlanksDefault(blank); if (xmlAddEncodingAlias("ISO-8859-1", "GBK") < 0 || xmlAddEncodingAlias("ISO-8859-1", "GB2312") < 0) return false; m_xml->doc = xmlParseFile(fileName); if (m_xml->doc == NULL) return false; m_xml->context = xmlXPathNewContext(m_xml->doc); m_xml->context->node = xmlDocGetRootElement(m_xml->doc); if (m_xml->context->node == NULL) { xmlFreeDoc(m_xml->doc); return false; } m_xml->resource = NULL; m_fileName = fileName; m_xml->isOnlyEntityName = false; return true; }
int irislwz_Validate(IRISLWZ_HANDLE *handle, const char *xml, char **beautified) /*!\brief Do an XML validation against a text * * This function takes the given \p xml test an tries to validate it with the XML * library (xmlReadMemory). If the XML is valid, a \p beautified version, which can * be better read by humans, can be stored optionally. * * \param[in] handle pointer to an IRISLWZ_HANDLE object * \param[in] xml pointer to the text which should be validated * \param[out] beautified optional pointer to which a beautified version of the xml * is written. The Memory for this is allocated by the library, but must be freed by the * client using \p free. * * \returns If the XML is valid, the function returns 1, otherwise 0. * * \example \code const char *xml="<iris1:request xmlns:iris1=\"urn:ietf:params:xml:ns:iris1\">" "<iris1:searchSet><iris1:lookupEntity registryType=\"dchk1\" " "entityClass=\"domain-name\" entityName=\"denic.de\"/>" "</iris1:searchSet></iris1:request>"; char *beautified=NULL; if (irislwz_Validate(handle,xml,&beautified)) { printf ("Original XML code:\n"); printf ("%s\n",xml); printf ("Beautified version:\n"); printf ("%s\n",beautified); } if (beautified) free(beautified); \endcode * * \ingroup DCHK_API_IRISLWZ */ { xmlSetGenericErrorFunc(handle,irislwz_xmlGenericErrorFunc); xmlDoc *doc = NULL; //xmlNode *root_element = NULL; int size=(int)strlen(xml); //printf ("Query: >>%s<<\n",xml); //printf ("Size: %i Bytes\n",size); doc = xmlReadMemory (xml, size, NULL, "UTF-8", XML_PARSE_NONET); if (doc == NULL) { irislwz_SetError(handle,74044,NULL); return 0; } if (beautified) { xmlChar *mem; int size; xmlKeepBlanksDefault(0); xmlDocDumpFormatMemoryEnc(doc, &mem, &size, handle->localcharset,1); *beautified=strdup((char*)mem); xmlFree(mem); } xmlFreeDoc(doc); return 1; }
XDocument* XParser::Parse(const char* szPath, bool keep_blank/*=false*/) { if(szPath==NULL) return NULL; xmlKeepBlanksDefault(keep_blank?1:0); xmlDoValidityCheckingDefaultValue =0; xmlParserCtxtPtr pxParseCtxt = NULL; pxParseCtxt = xmlCreateFileParserCtxt(szPath); if(pxParseCtxt==NULL) { return NULL; } if(pxParseCtxt->directory == NULL) { char* directory = xmlParserGetDirectory(szPath); pxParseCtxt->directory = (char*)xmlStrdup((xmlChar*)directory); } if(!ParseContext(pxParseCtxt)) { xmlFreeParserCtxt(pxParseCtxt); return NULL; } XDocument* pagXmlDoc = NULL; pagXmlDoc = new XDocument(pxParseCtxt->myDoc); xmlFreeParserCtxt(pxParseCtxt); return pagXmlDoc; }
Hardware::MinorType getHardwareType(string name, HardwareType ht, const Database *const pDB) throw (Error) { xmlKeepBlanksDefault(0); xmlDocPtr doc; try { doc = xmlParseFile(pDB->getHWPath(name, ht).c_str()); } catch (...) { throw; } if (doc == 0) throw Error("Cannot initialize XML parser"); xmlNodePtr cur = xmlDocGetRootElement(doc); if (cur == 0) { xmlFreeDoc(doc); throw Error("XML document is empty, invalid hardware file"); } string strIFace("NA"); bool bFound = false; cur = cur->xmlChildrenNode; while (cur != 0 && !bFound) { if (IsNode(cur, "hardware")) { xmlNodePtr save = cur; cur = cur->xmlChildrenNode; while (cur != 0) { if (IsNode(cur, "interface")) { strIFace = GetVal(doc, cur); bFound = true; break; } cur = cur->next; } cur = save; } cur = cur->next; } xmlFreeDoc(doc); xmlCleanupParser(); if (strIFace == "ethernet") return Hardware::BBEth; if (strIFace == "usb") return Hardware::BBUSB; if (strIFace == "usb||ethernet") return Hardware::BBDual; return Hardware::Unknown; }
xmlDocPtr getFvdlDoc(char* docname){ xmlDocPtr doc; xmlNodePtr cur; xmlKeepBlanksDefault(0); doc=xmlParseFile(docname); if(NULL==doc){ fprintf(stderr,"Document not parsed successfully. \n"); exit(1); } cur=xmlDocGetRootElement(doc); if(NULL==cur){ fprintf(stderr,"empty document\n"); xmlFreeDoc(doc); return NULL; } //printf("%d\n",xmlStrcmp(cur->name,(const xmlChar*)"FVDL")); FVDL->0 same->0 if(xmlStrcmp(cur->name,(const xmlChar*)"FVDL")){ fprintf(stderr,"%s is not a FVDL file!\n",docname); xmlFreeDoc(doc); return NULL; } return doc; }
void saveCterms(CIndexer *indexer) { CConnbas_dbox *connbas = indexer->connbas; xmlNodePtr root = xmlDocGetRootElement(indexer->DocCterms); char moddate[16]; // date de maj time_t timer; time(&timer); struct tm *today; today = localtime(&timer); strftime((char *)moddate, 15, "%Y%m%d%H%M%S", today); xmlSetProp(root, (const xmlChar*)"modification_date", (const xmlChar *)moddate ); xmlChar *out; int outsize; xmlKeepBlanksDefault(0); xmlDocDumpFormatMemory(indexer->DocCterms, &out, &outsize, 1); zSyslog._log(CSyslog::LOGL_THESAURUS, CSyslog::LOGC_THESAURUS, "#%d : CTERMS saved", connbas->sbas_id); connbas->updatePref_cterms((char *)out, outsize, moddate ); xmlFree(out); indexer->current_cterms_moddate = timer; }
xmlChar* read_auth(unsigned int* port_remote_control, unsigned int* port_actionner){ xmlDocPtr doc; xmlNodePtr auth_node; xmlNodePtr user_node; xmlNodePtr telnet_node; xmlNodePtr actionner_node; xmlKeepBlanksDefault(0); // Ignore les noeuds texte composant la mise en forme doc = xmlParseFile("config/auth.xml"); if (doc == NULL) { perror("read_auth xmlParseFile"); return NULL; } auth_node = children_XML_ELEMENT_NODE((xmlNodePtr)doc); user_node = auth_node->children->children; telnet_node = auth_node->children->next; actionner_node = telnet_node->next; xmlChar* port_rc = xmlGetProp(telnet_node,(const xmlChar*)"port"); xmlChar* port_a = xmlGetProp(actionner_node,(const xmlChar*)"port"); sscanf((char*) port_rc, "%u", port_remote_control); sscanf((char*) port_a, "%u", port_actionner); return xmlGetProp(telnet_node,(xmlChar*)"pass"); }
int main(int argc, char **argv) { int ret; xmlDocPtr doc; ret = EXIT_SUCCESS; if (3 != argc) { usage(); } xmlKeepBlanksDefault(0); // Ignore les noeuds texte composant la mise en forme // Ouverture du fichier XML et transformation de celui-ci en un arbre DOM if (NULL == (doc = xmlParseFile(argv[1]))) { printf("Document XML invalide\n"); return EXIT_FAILURE; } // Validation if (VALID == validation_dtd(doc, argv[2], 1)) { printf("Le document est valide\n"); } else { fprintf(stderr, "Le document n'est pas valide ou une erreur interne est survenue\n"); ret = EXIT_FAILURE; } // Libération de la mémoire xmlFreeDoc(doc); return ret; }
/* * Parse file with path * if error occurs, the error message saves in error buffer with length maxErrDesct and returns NULL */ xml_data *parseConfigData(const char *path, char *error, int maxErrDescr) { if (path) { xml_data *xml = calloc(1, sizeof(xml_data)); if (xml) { xmlKeepBlanksDefault(0); xml->doc = xmlReadFile(path, NULL, 0); if (xml->doc) { xml->root = (void *) xmlDocGetRootElement(xml->doc); if (xml->root) { strncpy(xml->path, path, MAX_XML_PATH); return xml; } else { xmlFreeDoc((xmlDocPtr) xml->doc); free(xml); snprintf(error, maxErrDescr, "Document is empty %s", path); } } else { free(xml); snprintf(error, maxErrDescr, "Can't parse file %s", path); } } else { snprintf(error, maxErrDescr, "Can't allocate data for xml parsing"); } } else { snprintf(error, maxErrDescr, "Path to config file shouldn't be empty"); } return NULL; }
XDocument* XParser::ParseMemory(const char* content, bool keep_blank/*=false*/) { xmlParserCtxtPtr pxParseCtxt = NULL; xmlKeepBlanksDefault(keep_blank?1:0); xmlDoValidityCheckingDefaultValue =0; pxParseCtxt = xmlCreateMemoryParserCtxt((const char*)content, strlen(content)); if(pxParseCtxt==NULL) { return NULL; } if(!ParseContext(pxParseCtxt)) { xmlFreeParserCtxt(pxParseCtxt); return NULL; } XDocument* pagXmlDoc = NULL; pagXmlDoc = new XDocument(pxParseCtxt->myDoc); xmlFreeParserCtxt(pxParseCtxt); return pagXmlDoc; }
int gtodo_client_save_xml_to_file(GTodoClient *cl, GFile *file, GError **error) { xmlChar *buffer; GError *tmp_error = NULL; int size; /* Test if there is actually a client to save */ if(cl == NULL) { g_set_error(&tmp_error,LIBGTODO_ERROR,LIBGTODO_ERROR_GENERIC,_("No Gtodo Client to save.") ); g_propagate_error(error, tmp_error); return TRUE; } /* dump the xml to memory */ /* xmlIndentTreeOutput = 1; */ xmlKeepBlanksDefault(0); xmlDocDumpFormatMemory(cl->gtodo_doc, &buffer, &size, TRUE); if (!g_file_replace_contents (file, (char *)buffer, size, NULL, FALSE, G_FILE_CREATE_NONE, NULL, NULL, &tmp_error)) { g_propagate_error(error, tmp_error); xmlFree(buffer); return TRUE; } xmlFree(buffer); /* return that everything is ok */ return FALSE; }
bool CXmlTree::CreateNewTree(const char *name, const char *value /* = NULL */) { CServerIo::trace(3,"CXmlTree::CreateNewTree(%s,%s)",(name)?name:"NULL",(value)?value:"NULL"); DiscardTree(); CServerIo::trace(3,"CXmlTree::CreateNewTree() - xmlSetStructuredErrorFunc()"); xmlSetStructuredErrorFunc(this, errorFunc); CServerIo::trace(3,"CXmlTree::CreateNewTree() - xmlKeepBlanksDefault(0)"); xmlKeepBlanksDefault(0); CServerIo::trace(3,"CXmlTree::CreateNewTree() - xmlLineNumbersDefault(1)"); xmlLineNumbersDefault(1); CServerIo::trace(3,"CXmlTree::CreateNewTree() - xmlNewDoc()"); m_doc = xmlNewDoc((const xmlChar *)"1.0"); if(!m_doc) return false; CServerIo::trace(3,"CXmlTree::CreateNewTree() - xmlNewDocNode()"); xmlNodePtr node = xmlNewDocNode(m_doc, NULL, (const xmlChar *)name, (const xmlChar *)value); if(!node) return false; CServerIo::trace(3,"CXmlTree::CreateNewTree() - xmlDocSetRootElement()"); xmlDocSetRootElement (m_doc, node); CServerIo::trace(3,"CXmlTree::CreateNewTree() - return"); return true; }
int main (int argc, char *argv[]) { gboolean ret; gboolean debug_mode = FALSE; GOptionContext *ctx; GError *err = NULL; GOptionEntry options[] = { {"debug-mode", 'd', 0, G_OPTION_ARG_NONE, &debug_mode, "debug mode", NULL}, {NULL} }; gtk_init (&argc, &argv); ctx = g_option_context_new (" -codecanalyzer options"); g_option_context_add_main_entries (ctx, options, NULL); if (!g_option_context_parse (ctx, &argc, &argv, &err)) { if (err) g_printerr ("Failed to initialize: %s\n", err->message); else g_printerr ("Failed to initialize, Unknown error\n"); g_clear_error (&err); g_option_context_free (ctx); exit (1); } g_option_context_free (ctx); if (debug_mode) { g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL, g_log_default_handler, NULL); g_setenv ("G_MESSAGES_DEBUG", "all", TRUE); g_debug ("Codecanalyzer is in DEBUG_MODE.."); } xmlKeepBlanksDefault (0); ret = analyzer_ui_init (); if (!ret) { g_printerr ("Failed to activate the gtk+-3.x backend\n"); goto done; } ret = analyzer_create_dirs (); if (!ret) { g_printerr ("Failed to create the necessary dir names\n"); goto done; } gtk_builder_connect_signals (ui->builder, NULL); gtk_widget_show_all (ui->main_window); gtk_main (); done: g_printf ("Closing Codecanalyzer....\n"); return 0; }
char *osync_xml_write_to_string(xmlDoc *doc) { xmlChar *temp = NULL; int size = 0; xmlKeepBlanksDefault(0); xmlDocDumpFormatMemoryEnc(doc, &temp, &size, NULL, 1); return (char *)temp; }
int unpack_xml(char *xmltype,char *filename) { int shmid = 0,i=0; xmlDocPtr doc; char loop[5]; memset(loop,0x00,sizeof(loop)); xmlNodePtr curNode; size_t shmsize = MAXXMLCFG*sizeof(_xmlcfg); /** 初始化循环path登记表 **/ for(i=0;i<100;i++) { memset(preg[i].path,0x00,sizeof(preg[i].path)); preg[i].loop=1; } if((shmid = getshmid(6,shmsize))==-1) { SysLog(LOG_APP_ERR,"获取XML报文配置区共享内存失败\n"); return -1; } if((xmlcfg = shmat(shmid,NULL,0))==(void *)-1) { SysLog(LOG_APP_ERR,"链接XML报文配置区共享内存失败\n"); return -1; } xmlKeepBlanksDefault(0); doc = xmlReadFile(filename,"UTF-8",XML_PARSE_RECOVER); if(doc == NULL) { SysLog(LOG_APP_ERR,"解析XML文件[%s]失败[%s]\n",filename,strerror(errno)); return -1; } curNode = xmlDocGetRootElement(doc); if(curNode == NULL) { SysLog(LOG_APP_ERR,"获取根节点失败\n"); xmlFreeDoc(doc); return -1; } if(prtvalue(curNode,xmltype)!=-1) { sprintf(loop,"%d",getmaxloop()); SysLog(LOG_APP_SHOW,"解包到变量成功,解包循环深度[%s]\n",loop); put_var_value("V_LOOP",strlen(loop)+1,1,loop); }else { SysLog(LOG_APP_ERR,"解包到变量失败\n"); } xmlFreeDoc(doc); xmlCleanupParser(); xmlMemoryDump(); shmdt(xmlcfg); return 0; }
void XMLTree::initialize() { if (!initialized) { #ifndef PUGIXML xmlInitParser(); xmlKeepBlanksDefault(false); #endif initialized = true; } }
std::string XMLConfObj::toString() { xmlIndentTreeOutput = 1; xmlKeepBlanksDefault(0); xmlBufferPtr xmlBufPtr = xmlBufferCreate(); xmlNodeDump(xmlBufPtr, documentTree, currentLevel, 0, 1); std::string ret = std::string((char *)xmlBufPtr->content, xmlBufPtr->use); xmlBufferFree(xmlBufPtr); return ret; }
static xmlDocPtr getDocPtr(char* docname) { xmlDocPtr doc = NULL; xmlKeepBlanksDefault(0); doc = xmlParseFile(docname); if(NULL == doc) { fprintf(stderr, "document cannot be parsed!\n"); exit(1); } return doc; }
bool Settings::load() { XOJ_CHECK_TYPE(Settings); xmlKeepBlanksDefault(0); if (!g_file_test(filename.c_str(), G_FILE_TEST_EXISTS)) { g_warning("configfile does not exist %s\n", filename.c_str()); return false; } xmlDocPtr doc = xmlParseFile(filename.c_str()); if (doc == NULL) { g_warning("Settings::load:: doc == null, could not load Settings!\n"); return false; } xmlNodePtr cur = xmlDocGetRootElement(doc); if (cur == NULL) { g_message("The settings file \"%s\" is empty", filename.c_str()); xmlFreeDoc(doc); return false; } if (xmlStrcmp(cur->name, (const xmlChar*) "settings")) { g_message("File \"%s\" is of the wrong type", filename.c_str()); xmlFreeDoc(doc); return false; } cur = xmlDocGetRootElement(doc); cur = cur->xmlChildrenNode; while (cur != NULL) { parseItem(doc, cur); cur = cur->next; } xmlFreeDoc(doc); loadButtonConfig(); return true; }
/* If we use G_MODULE_EXPORT, *only* thusly marked functions will be * exported, and xml-test uses other ones, too. */ G_MODULE_EXPORT #endif const gchar* g_module_check_init (GModule *module) { gconf_log(GCL_DEBUG, _("Initializing XML backend module")); LIBXML_TEST_VERSION; xmlKeepBlanksDefault(1); return NULL; }
/*函数功能:打开xml文件 *函数参数:doc:打开xml文件存放的句柄 cPath:文件路径 *函数返回值:成功返回0 失败返回-1 */ inline int CConfig::XmlParserFile(xmlDocPtr *doc, const char cPath[]) { LIBXML_TEST_VERSION xmlKeepBlanksDefault(0); *doc = xmlParseFile(cPath); if (*doc == NULL ) { fprintf(stderr,"Document not parsed successfully. \n"); return FAULT; } return TURE; }
int main(int argc, char **argv) { if (argc != 3){ g_print ("Usage: formatXml inputfile outputfile\n\n"); return -1; } xmlKeepBlanksDefault(0); formatFile (argv [1], argv [2]); return 0; }
bool XmlBuilder::Save(const iStringT& fileName) { if ( doc_ == 0 ) throw XmlBuilderException(); xmlKeepBlanksDefault( 0 ); //xmlIndentTreeOutput = 1; CvtTA<> fNameA( fileName.CStr() ); int bytes = xmlSaveFormatFile( fNameA, doc_, 1 ); return bytes != 0; }
virDomainSnapshotDefPtr virDomainSnapshotDefParseString(const char *xmlStr, virCapsPtr caps, virDomainXMLOptionPtr xmlopt, unsigned int expectedVirtTypes, unsigned int flags) { virDomainSnapshotDefPtr ret = NULL; xmlDocPtr xml; int keepBlanksDefault = xmlKeepBlanksDefault(0); if ((xml = virXMLParse(NULL, xmlStr, _("(domain_snapshot)")))) { xmlKeepBlanksDefault(keepBlanksDefault); ret = virDomainSnapshotDefParseNode(xml, xmlDocGetRootElement(xml), caps, xmlopt, expectedVirtTypes, flags); xmlFreeDoc(xml); } xmlKeepBlanksDefault(keepBlanksDefault); return ret; }