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