int main(void) { xmlDocPtr doc; xmlNodePtr cur; char *docmem; docmem = createdoc(); doc = xmlParseMemory(docmem, strlen(docmem)); if (doc == NULL) { return; } cur = xmlDocGetRootElement(doc); cur = cur->xmlChildrenNode; while (cur != NULL) { if ((!xmlStrcmp(cur->name, (const xmlChar *) "entry"))) { parseStory(doc, cur); } cur = cur->next; } xmlSaveFormatFile("spread.xml", doc, 1); xmlFreeDoc(doc); xmlCleanupParser(); }
void ofcds_free(void *UNUSED(data)) { ofc_destroy(); /* dump startup to persistent storage */ if (gds_startup) { xmlSaveFormatFile(OFC_DATADIR "/startup.xml", gds_startup, 1); } else { /* erase the file */ truncate(OFC_DATADIR "/startup.xml", 0); } /* cleanup locks */ free(locks.running_sid); free(locks.startup_sid); free(locks.cand_sid); if (rollback.doc) { xmlFreeDoc(rollback.doc); rollback.doc = NULL; } return; }
int write_volumeindex(opendcp_t *opendcp) { xmlIndentTreeOutput = 1; xmlDocPtr doc; xmlTextWriterPtr xml; int rc; dcp_log(LOG_INFO,"Writing VOLINDEX file %.256s",opendcp->volindex.filename); /* create XML document */ xml = xmlNewTextWriterDoc(&doc,0); /* volumeindex XML Start */ rc = xmlTextWriterStartDocument(xml, NULL, XML_ENCODING, NULL); if (rc < 0) { dcp_log(LOG_ERROR,"xmlTextWriterStartDocument failed"); return DCP_FATAL; } xmlTextWriterStartElement(xml, BAD_CAST "VolumeIndex"); xmlTextWriterWriteAttribute(xml, BAD_CAST "xmlns", BAD_CAST NS_AM[opendcp->ns]); xmlTextWriterWriteFormatElement(xml, BAD_CAST "Index","%d",1); xmlTextWriterEndElement(xml); rc = xmlTextWriterEndDocument(xml); if (rc < 0) { dcp_log(LOG_ERROR,"xmlTextWriterEndDocument failed %s",opendcp->volindex.filename); return DCP_FATAL; } xmlFreeTextWriter(xml); xmlSaveFormatFile(opendcp->volindex.filename, doc, 1); xmlFreeDoc(doc); return DCP_SUCCESS; }
gint writePalettes (void) { gint ret = -1; xmlDocPtr doc; xmlNodePtr parent, child; gchar *localpal = NULL; localpal = g_build_filename (get_user_data_dir (TRUE), "actions", "palettes.xml", NULL); doc = xmlNewDoc ((xmlChar *) "1.0"); doc->xmlRootNode = parent = xmlNewDocNode (doc, NULL, (xmlChar *) "Denemo", NULL); GList *g; for( g = Denemo.palettes; g; g = g->next) { child = xmlNewChild (parent, NULL, (xmlChar *) "palette", NULL); save_palette (child, g->data); } if (xmlSaveFormatFile (localpal, doc, 1) < 0) { g_warning ("Could not save file %s", localpal); ret = -1; } else ret = 0; xmlFreeDoc (doc); return ret; }
/* =========== QE_SaveProject TTimo: whenever QE_SaveProject is called, prefs are updated and saved with the path to the project =========== */ qboolean QE_SaveProject( const char* filename ){ Sys_Printf( "Save project file '%s'\n", filename ); xmlNodePtr node; xmlDocPtr doc = xmlNewDoc( (xmlChar *)"1.0" ); // create DTD node xmlCreateIntSubset( doc, (xmlChar *)"project", NULL, (xmlChar *)"project.dtd" ); // create project node doc->children->next = xmlNewDocNode( doc, NULL, (xmlChar *)"project", NULL ); for ( epair_t* epair = g_qeglobals.d_project_entity->epairs; epair != NULL; epair = epair->next ) { node = xmlNewChild( doc->children->next, NULL, (xmlChar *)"key", NULL ); xmlSetProp( node, (xmlChar*)"name", (xmlChar*)epair->key ); xmlSetProp( node, (xmlChar*)"value", (xmlChar*)epair->value ); } CreateDirectoryPath( filename ); if ( xmlSaveFormatFile( filename, doc, 1 ) != -1 ) { xmlFreeDoc( doc ); Sys_Printf( "Setting current project in prefs to \"%s\"\n", filename ); g_PrefsDlg.m_strLastProject = filename; g_PrefsDlg.SavePrefs(); return TRUE; } else { xmlFreeDoc( doc ); Sys_FPrintf( SYS_ERR, "failed to save project file: \"%s\"\n", filename ); return FALSE; } }
void gb_doc_xml_save (gbDoc *doc, const gchar *filename, gbDocXMLStatus *status) { xmlDocPtr xmldoc; gint xml_ret; gb_debug (DEBUG_XML, "START"); xmldoc = doc_to_xml (doc, status); xml_ret = xmlSaveFormatFile (filename, xmldoc, TRUE); xmlFreeDoc (xmldoc); if (xml_ret == -1) { g_warning (_("Problem saving xml file.")); *status = GB_DOC_XML_ERROR_SAVE_FILE; } else { gb_doc_set_filename (doc, filename); gb_doc_clear_modified (doc); } gb_debug (DEBUG_XML, "END"); }
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 gaim_save_accounts_file(void) { xmlDoc* doc = gaim_new_accounts_file(); char* accounts_file; asprintf(&accounts_file, "%s/%s/%s/%s", to_location, "home", to_user, ".purple/accounts.xml"); xmlSaveFormatFile(accounts_file, doc, 1); }
//--------------------------------------------------------------------------- void Policy::export_schema(const char* filename) { xmlDocPtr new_doc = create_doc(); xmlSaveFormatFile(filename, new_doc, 2); xmlFreeDoc(new_doc); saved = true; }
int xmlelf_write_info( xmlelf_t * xe ) { if(!xe || !xe->doc || !xe->name ) error_ret("null args",-1); xmlSaveFormatFile(xe->name,xe->doc,0); xmlFreeDoc(xe->doc); return(0); }
bool CXmlTree::WriteXmlFile(const char *file) const { if(xmlSaveFormatFile(file,m_doc,1)<0) { CServerIo::error("Unable to create %s\n",file); return false; } return true; }
gboolean snippets_store_lcb(gpointer data) { DEBUG_SIG("snippets_store_lcb, priority=%d\n",G_PRIORITY_DEFAULT_IDLE); DEBUG_MSG("snippets_store_lcb, started\n"); if (snippets_v.doc) { gchar *snipfile = get_snipfile(FALSE); xmlSaveFormatFile(snipfile, snippets_v.doc, 1); g_free(snipfile); } return FALSE; }
int Page::SaveTemplate(void) { if(templatefile) { xmlSaveFormatFile((const char*)templatefile.mb_str(), templates, 1); return true; } else return false; //failure }
int CXML::SaveDoc(const char *a_chPath, int a_nIndent) { int nRet = 0; nRet = xmlSaveFormatFile(a_chPath, m_stDoc, a_nIndent); if(nRet < 0){ return XML_SAVE_FAILED; } return XML_OK; }
gboolean mrp_parser_save (MrpStorageMrproject *module, const gchar *uri, gboolean force, GError **error) { gchar *real_filename; gint ret; gboolean file_exist; xmlDocPtr doc; g_return_val_if_fail (MRP_IS_STORAGE_MRPROJECT (module), FALSE); g_return_val_if_fail (uri != NULL && uri[0] != 0, FALSE); if (!strstr (uri, ".mrproject") && !strstr (uri, ".planner")) { real_filename = g_strconcat (uri, ".planner", NULL); } else { real_filename = g_strdup (uri); } file_exist = g_file_test ( real_filename, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR); if (file_exist && !force) { g_set_error (error, MRP_ERROR, MRP_ERROR_SAVE_FILE_EXIST, "%s", real_filename); g_free (real_filename); return FALSE; } doc = parser_build_xml_doc (module, error); if (!doc) { g_free (real_filename); return FALSE; } ret = xmlSaveFormatFile (real_filename, doc, 1); g_free (real_filename); xmlFreeDoc (doc); if (ret == -1) { g_set_error (error, MRP_ERROR, MRP_ERROR_SAVE_WRITE_FAILED, _("Could not write XML file")); return FALSE; } return TRUE; }
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; }
// schematic_write_xml // // Save a Sheet to an XML file. gint schematic_write_xml (Schematic *sm, GError **error) { int ret = -1; xmlDocPtr xml; parseXmlContext ctxt; GError *internal_error = NULL; g_return_val_if_fail (sm != NULL, FALSE); // Create the tree. xml = xmlNewDoc (BAD_CAST "1.0"); if (xml == NULL) { return FALSE; } ctxt.ns = NULL; ctxt.doc = xml; xmlDocSetRootElement (xml, write_xml_schematic (&ctxt, sm, &internal_error)); if (internal_error) { g_propagate_error (error, internal_error); return FALSE; } // Dump the tree. xmlSetDocCompressMode (xml, oregano.compress_files ? 9 : 0); { char *s =schematic_get_filename (sm); if (s != NULL) { ret = xmlSaveFormatFile (s, xml, 1); } else { g_warning ("Schematic has no filename!!\n"); } } if (xml != NULL) { xmlFreeDoc (xml); } else { g_warning ("XML object is NULL\n"); } if (ret < 0) return FALSE; return TRUE; }
//! \cond internal void writeReferenceDataFile(const std::string &path, const ReferenceDataEntry &rootEntry) { // TODO: Error checking XmlDocumentPointer document(xmlNewDoc(cXmlVersion)); xmlNodePtr rootElement = createRootElement(document.get()); createXsltReference(document.get(), rootElement); createChildElements(rootElement, rootEntry); if (xmlSaveFormatFile(path.c_str(), document.get(), 1) == -1) { GMX_THROW(TestException("Reference data saving failed in " + path)); } }
void store() { unsigned int i, n, k; xmlDoc* doc = NULL; xmlNode* matrices = NULL; xmlNode* node = NULL; char buff[4096] = "\0"; char tmp[64]; doc = xmlNewDoc(BAD_CAST "1.0"); matrices = xmlNewNode(NULL, BAD_CAST "matrices"); xmlDocSetRootElement(doc, matrices); for(i = 0; i < N_LAY-1; i++) { for(n = 0; n < N_MAX; n++) { for(k = 0; k < N_MAX; k++) { sprintf(tmp, " %lf ", g_weight_best[i][n][k]); strcat(buff, tmp); } strcat(buff, "\n"); } strcat(buff, "\n"); } xmlNewChild(matrices, NULL, BAD_CAST "weight", BAD_CAST buff); //threshold strcpy(buff, "\0"); for(i = 0; i < N_LAY; i++) { for(k = 0; k < N_MAX-1; k++) { sprintf(tmp, " %lf ", g_thresh_best[i][k]); strcat(buff, tmp); } strcat(buff, "\n"); } xmlNewChild(matrices, NULL, BAD_CAST "thresh", BAD_CAST buff); xmlKeepBlanksDefault(0) ;//libxml2 global variable . xmlIndentTreeOutput = 1 ;// indent .with \n xmlSaveFormatFile(FILENAME, doc, 1); printf("data successfully stored.\n"); xmlFreeDoc(doc); xmlCleanupParser(); xmlMemoryDump(); }
void VspPreferences::saveFile() { xmlNodePtr root = xmlDocGetRootElement(m_XmlDoc); if (root == NULL) return; xmlNodePtr node = xmlGetNode( root, "DefaultComponentFileID", 0 ); // xmlAddIntNode( root, "DefaultComponentFileID", m_DefaultCompFileID ); char str[16]; sprintf(str, "%d", m_DefaultCompFileID ); xmlNodeSetContent( node, (const xmlChar *)str ); xmlSaveFormatFile("VspPreferences.xml", m_XmlDoc, 1); }
void snippets_export_node(xmlNodePtr node, const gchar *filename) { xmlNodePtr newnode=NULL, cur=NULL; xmlDocPtr newdoc; newdoc = xmlNewDoc((const xmlChar *)"1.0"); cur = xmlNewDocNode(newdoc,NULL, (const xmlChar *)"snippets",NULL); xmlDocSetRootElement(newdoc, cur); newnode = xmlDocCopyNode(node, newdoc, TRUE); DEBUG_MSG("snippets_export_node, cur=%p, newdoc=%p, newnode=%p\n",cur,newdoc,newnode); xmlAddChild(cur, newnode); xmlSaveFormatFile(filename, newdoc, 1); xmlFreeDoc(newdoc); }
/* Get all XML configuration data */ int libgadget_sidebar_xml_update (char *sidebar_xml_file, int red, int green, int blue, float transparency) { xmlDocPtr doc; xmlNodePtr cur; doc = xmlParseFile (sidebar_xml_file); if (doc == NULL ) { g_print (" Error - error parsing %s\n", sidebar_xml_file); return; } cur = xmlDocGetRootElement (doc); if (cur == NULL) { g_print (" Error - %s is empty\n", sidebar_xml_file); xmlFreeDoc (doc); return; } if (xmlStrcmp (cur->name, (const xmlChar *) "sidebargadget")) { g_print (" Error - root node \"sidebargadget\" is missing\n"); xmlFreeDoc (doc); return; } cur = cur->xmlChildrenNode; while (cur != NULL) { if ((!xmlStrcmp(cur->name, (const xmlChar *) "sidebar"))) { xmlSetProp (cur, "red", g_strdup_printf ("%d", red)); xmlSetProp (cur, "green", g_strdup_printf ("%d", green)); xmlSetProp (cur, "blue", g_strdup_printf ("%d", blue)); xmlSetProp (cur, "transparency", g_strdup_printf ("%f", transparency)); } cur = cur->next; } if (doc != NULL) { xmlSaveFormatFile (sidebar_xml_file, doc, 0); xmlFreeDoc(doc); } return 0; }
int saveNewEvent(char *keyword, char *id, char *value, int type){ xmlDocPtr doc; xmlNodePtr cur; doc = xmlParseFile(db_uri); if (doc == NULL) { fprintf(stderr, "Failed to parse %s\n", db_uri); return 1; } cur = xmlDocGetRootElement(doc); if (cur == NULL){ fprintf(stderr, "Empty document\n"); xmlFreeDoc(doc); return 1; } if(type == 2) cur = cur->xmlChildrenNode; while(cur != NULL){ if(type == 0){ if((!xmlStrcmp(cur->name, (const xmlChar *)"remendo_db"))){ return parseName(doc, cur, keyword, value); } } if(type == 1){ if((!xmlStrcmp(cur->name, (const xmlChar *)"remendo_db"))){ xmlNodePtr event_node = xmlNewTextChild(cur, NULL, keyword, NULL); xmlNewProp(event_node, "id", value); } }else{ if((!xmlStrcmp(cur->name, (const xmlChar *)"event"))){ xmlChar *current_id = xmlGetProp(cur, "id"); if(!strcmp(current_id, id)){ xmlNewTextChild(cur, NULL, keyword, value); } } } cur = cur->next; } xmlSaveFormatFile(db_uri, doc, 1); xmlFreeDoc(doc); }
bool gpl::xml::saveXmlToFileXPath(const char* fname /*= ""*/, const char* encoding /*= ""*/, int format /*= 1*/) { //xmlKeepBlanksDefault(0); const char* fPtr = ((strlen(fname) == 0) ? m_fileName.c_str() : fname); if (strlen(fPtr) == 0) return false; if (strlen(encoding) == 0) { if (xmlSaveFormatFile(fPtr, m_xml->doc, format) < 0) return false; } else { if (xmlSaveFormatFileEnc(fPtr, m_xml->doc, encoding, format) < 0) return false; } return true; }
//--------------------------------------------------------------------------- int UnknownPolicy::import_schema_from_doc(const std::string& filename, xmlDocPtr doc) { if (!doc) { error = "The document is not valid"; return -1; } std::string path = Core::get_local_data_path() + "policies/"; size_t pos = filename.rfind("/"); std::string file; if (pos != std::string::npos) { if (filename.substr(0, pos + 1) == path) { this->filename = filename; this->title = this->filename; return 0; } file = filename.substr(pos + 1); } path += file; std::string current_path = path; for (size_t i = 0; ; ++i) { ZenLib::Ztring z_path = ZenLib::Ztring().From_UTF8(current_path); if (!ZenLib::File::Exists(z_path)) break; std::stringstream ss; if (path.substr(path.length() - 4) == ".xsl") ss << path.substr(0, path.length() - 4) << i << ".xsl"; else ss << path << i; current_path = ss.str(); } this->filename = current_path; this->title = this->filename; xmlSaveFormatFile(this->filename.c_str(), doc, 2); return 0; }
//--------------------------------------------------------------------------- int UnknownPolicy::import_schema_from_doc(xmlDocPtr doc, const std::string& filename) { if (!doc) { error = "The document is not valid"; return -1; } this->filename = filename; std::string name = filename; size_t pos = name.rfind("/"); this->name = name.substr(pos == std::string::npos ? 0 : pos + 1); size_t ext_pos; if ((ext_pos = this->name.rfind(".")) != std::string::npos) this->name = this->name.substr(0, ext_pos); if (!this->name.length()) this->name = "Policy example"; if (!filename.size()) { system_doc = xmlCopyDoc(doc, 1); return 0; } ZenLib::Ztring z_path = ZenLib::Ztring().From_UTF8(filename); if (ZenLib::File::Exists(z_path)) return 0; int ret = xmlSaveFormatFile(this->filename.c_str(), doc, 2); if (ret < 0) { error = "Cannot copy the policy"; return -1; } return 0; }
static int formatFile (const gchar *input, const gchar *output) { xmlDocPtr doc; /* * build an XML tree from a the file; */ doc = xmlParseFile (input); if (doc == NULL){ g_warning ("File %s empty or not well-formed.", input); return -1; } if (xmlSaveFormatFile (output, doc, TRUE) == -1){ g_warning ("Error saving config data to %s", input); } xmlFreeDoc (doc); return 0; }
void ZXMLDoc::end(const char *file) { /* Here we could close the elements ORDER and EXAMPLE using the * function xmlTextWriterEndElement, but since we do not want to * write any other elements, we simply call xmlTextWriterEndDocument, * which will do all the work. rc = xmlTextWriterEndDocument(writer); if (rc < 0) { printf("testXmlwriterDoc: Error at xmlTextWriterEndDocument\n"); return; } */ xmlFreeTextWriter(writer); //xmlSaveFileEnc(file, doc, MY_ENCODING); xmlSaveFormatFile (file, doc, 1); xmlFreeDoc(doc); }
int main(int argc, char **argv) { char *docname; char *keyword; xmlDocPtr doc; if (argc <= 1){ printf("Usage: %s docname, keyword\n", argv[0]); return(0); } docname = argv[1]; doc = parseDoc (docname, keyword); if (doc != NULL) { xmlSaveFormatFile (docname, doc, 1); xmlFreeDoc(doc); } return (1); }
bool DomTree::write(const std::string& file, bool indent) { xmlDocPtr doc; xmlNodePtr cur; //xmlAttrPtr attr; doc = xmlNewDoc((const xmlChar *)version.c_str()); doc->children = xmlNewDocNode(doc, NULL,(const xmlChar *)name.c_str(), NULL); for(unsigned int i = 0; i < attributes.size() ; i++) { xmlSetProp(doc->children,(const xmlChar *)attributes[i]->getName().c_str(),(const xmlChar *)attributes[i]->getValue().c_str()); } for(unsigned int i = 0; i < elements.size() ; i++) { cur = xmlNewChild(doc->children,NULL,(const xmlChar *)elements[i]->getName().c_str(),(xmlChar *)elements[i]->getValue().c_str()); if(elements[i]->getAttributes().size() > 0) { for(unsigned int a = 0; a < elements[i]->getAttributes().size() ; a++) { xmlSetProp(cur,(const xmlChar *)elements[i]->getAttributes()[a]->getName().c_str(),(const xmlChar *)elements[i]->getAttributes()[a]->getValue().c_str()); } } if ( elements[i]->getChildren().size() > 0 ) { for(unsigned int b = 0; b < elements[i]->getChildren().size() ; b++) { dumpXmlChild(cur,elements[i]->getChildren()[b]); } } } if((xmlSaveFormatFile((const char *)file.c_str(),doc,indent)) < 1) { std::cout << "Error writing to file" << std::endl; xmlFreeDoc(doc); xmlCleanupParser(); return(false); } xmlFreeDoc(doc); xmlCleanupParser(); return(true); }