From dd27e31351be89bc0c28183fc347d6082bca1e36 Mon Sep 17 00:00:00 2001
From: Daniel Pfeifer <daniel@pfeifer-mail.de>
Date: Thu, 16 Jul 2015 21:50:28 +0200
Subject: cmXMLWriter: overload Element() method for empty elements

---
 Source/cmXMLWriter.cxx | 7 +++++++
 Source/cmXMLWriter.h   | 2 ++
 2 files changed, 9 insertions(+)

diff --git a/Source/cmXMLWriter.cxx b/Source/cmXMLWriter.cxx
index f9b3b49..ab9939a 100644
--- a/Source/cmXMLWriter.cxx
+++ b/Source/cmXMLWriter.cxx
@@ -67,6 +67,13 @@ void cmXMLWriter::EndElement()
   this->ElementOpen = false;
 }
 
+void cmXMLWriter::Element(const char* name)
+{
+  this->CloseStartElement();
+  this->ConditionalLineBreak(!this->IsContent, this->Elements.size());
+  this->Output << '<' << name << "/>";
+}
+
 void cmXMLWriter::BreakAttributes()
 {
   this->BreakAttrib = true;
diff --git a/Source/cmXMLWriter.h b/Source/cmXMLWriter.h
index c38c0de..c839a62 100644
--- a/Source/cmXMLWriter.h
+++ b/Source/cmXMLWriter.h
@@ -41,6 +41,8 @@ public:
     this->Output << name << "=\"" << SafeAttribute(value) << '"';
     }
 
+  void Element(const char* name);
+
   template <typename T>
   void Element(std::string const& name, T const& value)
     {
-- 
cgit v0.12


From d740762181976834df32bc9baaf273e5278313b0 Mon Sep 17 00:00:00 2001
From: Daniel Pfeifer <daniel@pfeifer-mail.de>
Date: Thu, 16 Jul 2015 23:06:44 +0200
Subject: cmXMLWriter: add Doctype() method

---
 Source/cmXMLWriter.cxx | 7 +++++++
 Source/cmXMLWriter.h   | 2 ++
 2 files changed, 9 insertions(+)

diff --git a/Source/cmXMLWriter.cxx b/Source/cmXMLWriter.cxx
index ab9939a..6a9172a 100644
--- a/Source/cmXMLWriter.cxx
+++ b/Source/cmXMLWriter.cxx
@@ -92,6 +92,13 @@ void cmXMLWriter::CData(std::string const& data)
   this->Output << "<![CDATA[" << data << "]]>";
 }
 
+void cmXMLWriter::Doctype(const char* doctype)
+{
+  this->CloseStartElement();
+  this->ConditionalLineBreak(!this->IsContent, this->Elements.size());
+  this->Output << "<!DOCTYPE " << doctype << ">";
+}
+
 void cmXMLWriter::ProcessingInstruction(const char* target, const char* data)
 {
   this->CloseStartElement();
diff --git a/Source/cmXMLWriter.h b/Source/cmXMLWriter.h
index c839a62..3083059 100644
--- a/Source/cmXMLWriter.h
+++ b/Source/cmXMLWriter.h
@@ -62,6 +62,8 @@ public:
 
   void CData(std::string const& data);
 
+  void Doctype(const char* doctype);
+
   void ProcessingInstruction(const char* target, const char* data);
 
   void FragmentFile(const char* fname);
-- 
cgit v0.12


From 27e097645350fc07dadc79a8944b47a97e5ecdc3 Mon Sep 17 00:00:00 2001
From: Daniel Pfeifer <daniel@pfeifer-mail.de>
Date: Thu, 16 Jul 2015 21:52:35 +0200
Subject: cmExtraCodeBlocksGenerator: port to cmXMLWriter

---
 Source/cmExtraCodeBlocksGenerator.cxx | 234 +++++++++++++++++++++-------------
 Source/cmExtraCodeBlocksGenerator.h   |   4 +-
 2 files changed, 147 insertions(+), 91 deletions(-)

diff --git a/Source/cmExtraCodeBlocksGenerator.cxx b/Source/cmExtraCodeBlocksGenerator.cxx
index 476d3ac..52512a8 100644
--- a/Source/cmExtraCodeBlocksGenerator.cxx
+++ b/Source/cmExtraCodeBlocksGenerator.cxx
@@ -18,7 +18,7 @@
 #include "cmSourceFile.h"
 #include "cmGeneratedFileStream.h"
 #include "cmSystemTools.h"
-#include "cmXMLSafe.h"
+#include "cmXMLWriter.h"
 
 #include <cmsys/SystemTools.hxx>
 
@@ -101,11 +101,11 @@ struct Tree
   void InsertPath(const std::vector<std::string>& splitted,
                   std::vector<std::string>::size_type start,
                   const std::string& fileName);
-  void BuildVirtualFolder(std::string& virtualFolders) const;
+  void BuildVirtualFolder(cmXMLWriter& xml) const;
   void BuildVirtualFolderImpl(std::string& virtualFolders,
                               const std::string& prefix) const;
-  void BuildUnit(std::string& unitString, const std::string& fsPath) const;
-  void BuildUnitImpl(std::string& unitString,
+  void BuildUnit(cmXMLWriter& xml, const std::string& fsPath) const;
+  void BuildUnitImpl(cmXMLWriter& xml,
                      const std::string& virtualFolderPath,
                      const std::string& fsPath) const;
 };
@@ -159,16 +159,18 @@ void Tree::InsertPath(const std::vector<std::string>& splitted,
 }
 
 
-void Tree::BuildVirtualFolder(std::string& virtualFolders) const
+void Tree::BuildVirtualFolder(cmXMLWriter& xml) const
 {
-  virtualFolders += "<Option virtualFolders=\"CMake Files\\;";
+  xml.StartElement("Option");
+  std::string virtualFolders = "CMake Files\\;";
   for (std::vector<Tree>::const_iterator it = folders.begin();
      it != folders.end();
      ++it)
     {
     it->BuildVirtualFolderImpl(virtualFolders, "");
     }
-  virtualFolders += "\" />";
+  xml.Attribute("virtualFolders", virtualFolders);
+  xml.EndElement();
 }
 
 
@@ -185,26 +187,31 @@ void Tree::BuildVirtualFolderImpl(std::string& virtualFolders,
 }
 
 
-void Tree::BuildUnit(std::string& unitString, const std::string& fsPath) const
+void Tree::BuildUnit(cmXMLWriter& xml, const std::string& fsPath) const
 {
   for (std::vector<std::string>::const_iterator it = files.begin();
        it != files.end();
        ++it)
     {
-    unitString += "      <Unit filename=\"" + fsPath + *it + "\">\n";
-    unitString += "          <Option virtualFolder=\"CMake Files\\\" />\n";
-    unitString += "      </Unit>\n";
+    xml.StartElement("Unit");
+    xml.Attribute("filename", fsPath + *it);
+
+    xml.StartElement("Option");
+    xml.Attribute("virtualFolder", "CMake Files\\");
+    xml.EndElement();
+
+    xml.EndElement();
     }
   for (std::vector<Tree>::const_iterator it = folders.begin();
      it != folders.end();
      ++it)
     {
-    it->BuildUnitImpl(unitString, "", fsPath);
+    it->BuildUnitImpl(xml, "", fsPath);
     }
 }
 
 
-void Tree::BuildUnitImpl(std::string& unitString,
+void Tree::BuildUnitImpl(cmXMLWriter& xml,
                          const std::string& virtualFolderPath,
                          const std::string& fsPath) const
 {
@@ -212,16 +219,21 @@ void Tree::BuildUnitImpl(std::string& unitString,
        it != files.end();
        ++it)
     {
-    unitString += "      <Unit filename=\"" +fsPath+path+ "/" + *it + "\">\n";
-    unitString += "          <Option virtualFolder=\"CMake Files\\"
-               + virtualFolderPath + path + "\\\" />\n";
-    unitString += "      </Unit>\n";
+    xml.StartElement("Unit");
+    xml.Attribute("filename", fsPath + path + "/" + *it);
+
+    xml.StartElement("Option");
+    xml.Attribute("virtualFolder",
+        "CMake Files\\" + virtualFolderPath + path + "\\");
+    xml.EndElement();
+
+    xml.EndElement();
     }
   for (std::vector<Tree>::const_iterator it = folders.begin();
      it != folders.end();
      ++it)
     {
-    it->BuildUnitImpl(unitString,
+    it->BuildUnitImpl(xml,
                       virtualFolderPath + path + "\\", fsPath + path + "/");
     }
 }
@@ -289,30 +301,41 @@ void cmExtraCodeBlocksGenerator
       }
     }
 
-  // Now build a virtual tree string
-  std::string virtualFolders;
-  tree.BuildVirtualFolder(virtualFolders);
-  // And one for <Unit>
-  std::string unitFiles;
-  tree.BuildUnit(unitFiles, std::string(lgs[0]->GetSourceDirectory()) + "/");
-
   // figure out the compiler
   std::string compiler = this->GetCBCompilerId(mf);
   std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
   const std::string makeArgs = mf->GetSafeDefinition(
                                             "CMAKE_CODEBLOCKS_MAKE_ARGUMENTS");
 
-  fout<<"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\n"
-        "<CodeBlocks_project_file>\n"
-        "   <FileVersion major=\"1\" minor=\"6\" />\n"
-        "   <Project>\n"
-        "      <Option title=\"" << lgs[0]->GetProjectName()<<"\" />\n"
-        "      <Option makefile_is_custom=\"1\" />\n"
-        "      <Option compiler=\"" << compiler << "\" />\n"
-        "      "<<virtualFolders<<"\n"
-        "      <Build>\n";
-
-  this->AppendTarget(fout, "all", 0, make.c_str(), lgs[0], compiler.c_str(),
+  cmXMLWriter xml(fout);
+  xml.StartDocument();
+  xml.StartElement("CodeBlocks_project_file");
+
+  xml.StartElement("FileVersion");
+  xml.Attribute("major", 1);
+  xml.Attribute("minor", 6);
+  xml.EndElement();
+
+  xml.StartElement("Project");
+
+  xml.StartElement("Option");
+  xml.Attribute("title", lgs[0]->GetProjectName());
+  xml.EndElement();
+
+  xml.StartElement("Option");
+  xml.Attribute("makefile_is_custom", 1);
+  xml.EndElement();
+
+  xml.StartElement("Option");
+  xml.Attribute("compiler", compiler);
+  xml.EndElement();
+
+  // Now build a virtual tree
+  tree.BuildVirtualFolder(xml);
+
+  xml.StartElement("Build");
+
+  this->AppendTarget(xml, "all", 0, make.c_str(), lgs[0], compiler.c_str(),
                      makeArgs);
 
   // add all executable and library targets and some of the GLOBAL
@@ -334,7 +357,7 @@ void cmExtraCodeBlocksGenerator
           if (strcmp((*lg)->GetCurrentBinaryDirectory(),
                      (*lg)->GetBinaryDirectory())==0)
             {
-            this->AppendTarget(fout, targetName, 0,
+            this->AppendTarget(xml, targetName, 0,
                                make.c_str(), *lg, compiler.c_str(),
                                makeArgs);
             }
@@ -352,7 +375,7 @@ void cmExtraCodeBlocksGenerator
             break;
             }
 
-          this->AppendTarget(fout, targetName, 0,
+          this->AppendTarget(xml, targetName, 0,
                                  make.c_str(), *lg, compiler.c_str(),makeArgs);
           break;
         case cmState::EXECUTABLE:
@@ -362,11 +385,11 @@ void cmExtraCodeBlocksGenerator
         case cmState::OBJECT_LIBRARY:
           {
           cmGeneratorTarget* gt = *ti;
-          this->AppendTarget(fout, targetName, gt,
+          this->AppendTarget(xml, targetName, gt,
                              make.c_str(), *lg, compiler.c_str(), makeArgs);
           std::string fastTarget = targetName;
           fastTarget += "/fast";
-          this->AppendTarget(fout, fastTarget, gt,
+          this->AppendTarget(xml, fastTarget, gt,
                              make.c_str(), *lg, compiler.c_str(), makeArgs);
           }
           break;
@@ -376,8 +399,7 @@ void cmExtraCodeBlocksGenerator
       }
     }
 
-  fout<<"      </Build>\n";
-
+  xml.EndElement(); // Build
 
   // Collect all used source files in the project.
   // Keep a list of C/C++ source files which might have an acompanying header
@@ -505,24 +527,27 @@ void cmExtraCodeBlocksGenerator
     std::string const& unitFilename = sit->first;
     CbpUnit const& unit = sit->second;
 
-    fout<<"      <Unit filename=\""<< cmXMLSafe(unitFilename) <<"\">\n";
+    xml.StartElement("Unit");
+    xml.Attribute("filename", unitFilename);
 
     for(std::vector<const cmGeneratorTarget*>::const_iterator ti =
         unit.Targets.begin();
         ti != unit.Targets.end(); ++ti)
       {
-      std::string const& targetName = (*ti)->GetName();
-      fout<<"         <Option target=\""<< cmXMLSafe(targetName) <<"\"/>\n";
+      xml.StartElement("Option");
+      xml.Attribute("target", (*ti)->GetName());
+      xml.EndElement();
       }
 
-    fout<<"      </Unit>\n";
+    xml.EndElement();
     }
 
   // Add CMakeLists.txt
-  fout<<unitFiles;
+  tree.BuildUnit(xml, std::string(mf->GetHomeDirectory()) + "/");
 
-  fout<<"   </Project>\n"
-        "</CodeBlocks_project_file>\n";
+  xml.EndElement(); // Project
+  xml.EndElement(); // CodeBlocks_project_file
+  xml.EndDocument();
 }
 
 
@@ -553,7 +578,7 @@ std::string cmExtraCodeBlocksGenerator::CreateDummyTargetFile(
 
 
 // Generate the xml code for one target.
-void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout,
+void cmExtraCodeBlocksGenerator::AppendTarget(cmXMLWriter& xml,
                                               const std::string& targetName,
                                               cmGeneratorTarget* target,
                                               const char* make,
@@ -565,7 +590,9 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout,
   std::string makefileName = lg->GetCurrentBinaryDirectory();
   makefileName += "/Makefile";
 
-  fout<<"      <Target title=\"" << targetName << "\">\n";
+  xml.StartElement("Target");
+  xml.Attribute("title", targetName);
+
   if (target!=0)
     {
     int cbTargetType = this->GetCBTargetType(target);
@@ -603,13 +630,29 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout,
       location = target->GetLocation(buildType);
       }
 
-    fout<<"         <Option output=\"" << location
-                            << "\" prefix_auto=\"0\" extension_auto=\"0\" />\n"
-          "         <Option working_dir=\"" << workingDir << "\" />\n"
-          "         <Option object_output=\"./\" />\n"
-          "         <Option type=\"" << cbTargetType << "\" />\n"
-          "         <Option compiler=\"" << compiler << "\" />\n"
-          "         <Compiler>\n";
+    xml.StartElement("Option");
+    xml.Attribute("output", location);
+    xml.Attribute("prefix_auto", 0);
+    xml.Attribute("extension_auto", 0);
+    xml.EndElement();
+
+    xml.StartElement("Option");
+    xml.Attribute("working_dir", workingDir);
+    xml.EndElement();
+
+    xml.StartElement("Option");
+    xml.Attribute("object_output", "./");
+    xml.EndElement();
+
+    xml.StartElement("Option");
+    xml.Attribute("type", cbTargetType);
+    xml.EndElement();
+
+    xml.StartElement("Option");
+    xml.Attribute("compiler", compiler);
+    xml.EndElement();
+
+    xml.StartElement("Compiler");
 
     // the compilerdefines for this target
     std::vector<std::string> cdefs;
@@ -619,8 +662,9 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout,
     for(std::vector<std::string>::const_iterator di = cdefs.begin();
         di != cdefs.end(); ++di)
       {
-      cmXMLSafe safedef(di->c_str());
-      fout <<"            <Add option=\"-D" << safedef.str() << "\" />\n";
+      xml.StartElement("Add");
+      xml.Attribute("option", "-D" + *di);
+      xml.EndElement();
       }
 
     // the include directories for this target
@@ -653,36 +697,48 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout,
         dirIt != uniqIncludeDirs.end();
         ++dirIt)
       {
-      fout <<"            <Add directory=\"" << *dirIt << "\" />\n";
+      xml.StartElement("Add");
+      xml.Attribute("directory", *dirIt);
+      xml.EndElement();
       }
 
-    fout<<"         </Compiler>\n";
+    xml.EndElement(); // Compiler
     }
   else // e.g. all and the GLOBAL and UTILITY targets
     {
-    fout<<"         <Option working_dir=\""
-        << lg->GetCurrentBinaryDirectory() << "\" />\n"
-        <<"         <Option type=\"" << 4 << "\" />\n";
-    }
-
-  fout<<"         <MakeCommands>\n"
-        "            <Build command=\""
-      << this->BuildMakeCommand(make, makefileName.c_str(), targetName,
-                                makeFlags)
-      << "\" />\n"
-        "            <CompileFile command=\""
-      << this->BuildMakeCommand(make, makefileName.c_str(),"&quot;$file&quot;",
-                                makeFlags)
-      << "\" />\n"
-        "            <Clean command=\""
-      << this->BuildMakeCommand(make, makefileName.c_str(), "clean", makeFlags)
-      << "\" />\n"
-        "            <DistClean command=\""
-      << this->BuildMakeCommand(make, makefileName.c_str(), "clean", makeFlags)
-      << "\" />\n"
-        "         </MakeCommands>\n"
-        "      </Target>\n";
+    xml.StartElement("Option");
+    xml.Attribute("working_dir", lg->GetCurrentBinaryDirectory());
+    xml.EndElement();
+
+    xml.StartElement("Option");
+    xml.Attribute("type", 4);
+    xml.EndElement();
+    }
+
+  xml.StartElement("MakeCommands");
+
+  xml.StartElement("Build");
+  xml.Attribute("command",
+    this->BuildMakeCommand(make, makefileName.c_str(), targetName, makeFlags));
+  xml.EndElement();
+
+  xml.StartElement("CompileFile");
+  xml.Attribute("command",
+    this->BuildMakeCommand(make, makefileName.c_str(),"\"$file\"", makeFlags));
+  xml.EndElement();
 
+  xml.StartElement("Clean");
+  xml.Attribute("command",
+    this->BuildMakeCommand(make, makefileName.c_str(), "clean", makeFlags));
+  xml.EndElement();
+
+  xml.StartElement("DistClean");
+  xml.Attribute("command",
+    this->BuildMakeCommand(make, makefileName.c_str(), "clean", makeFlags));
+  xml.EndElement();
+
+  xml.EndElement(); //MakeCommands
+  xml.EndElement(); //Target
 }
 
 
@@ -825,7 +881,7 @@ std::string cmExtraCodeBlocksGenerator::BuildMakeCommand(
     // http://public.kitware.com/Bug/view.php?id=13952
     std::string makefileName = cmSystemTools::ConvertToOutputPath(makefile);
     command += " /NOLOGO /f ";
-    command += cmXMLSafe(makefileName).str();
+    command += makefileName;
     command += " VERBOSE=1 ";
     command += target;
     }
@@ -834,9 +890,9 @@ std::string cmExtraCodeBlocksGenerator::BuildMakeCommand(
     // no escaping of spaces in this case, see
     // http://public.kitware.com/Bug/view.php?id=10014
     std::string makefileName = makefile;
-    command += " -f &quot;";
+    command += " -f \"";
     command += makefileName;
-    command += "&quot; ";
+    command += "\" ";
     command += " VERBOSE=1 ";
     command += target;
     }
@@ -848,9 +904,9 @@ std::string cmExtraCodeBlocksGenerator::BuildMakeCommand(
   else
     {
     std::string makefileName = cmSystemTools::ConvertToOutputPath(makefile);
-    command += " -f &quot;";
+    command += " -f \"";
     command += makefileName;
-    command += "&quot; ";
+    command += "\" ";
     command += " VERBOSE=1 ";
     command += target;
     }
diff --git a/Source/cmExtraCodeBlocksGenerator.h b/Source/cmExtraCodeBlocksGenerator.h
index 4abfa7e..e2f09de 100644
--- a/Source/cmExtraCodeBlocksGenerator.h
+++ b/Source/cmExtraCodeBlocksGenerator.h
@@ -18,7 +18,7 @@
 class cmLocalGenerator;
 class cmMakefile;
 class cmGeneratorTarget;
-class cmGeneratedFileStream;
+class cmXMLWriter;
 
 /** \class cmExtraCodeBlocksGenerator
  * \brief Write CodeBlocks project files for Makefile based projects
@@ -56,7 +56,7 @@ private:
   std::string BuildMakeCommand(const std::string& make, const char* makefile,
                                const std::string& target,
                                const std::string& makeFlags);
-  void AppendTarget(cmGeneratedFileStream& fout,
+  void AppendTarget(cmXMLWriter& xml,
                     const std::string& targetName,
                     cmGeneratorTarget* target,
                     const char* make,
-- 
cgit v0.12


From dcdc270eeb48ad5eb017aca5c3e16188a0b7d808 Mon Sep 17 00:00:00 2001
From: Daniel Pfeifer <daniel@pfeifer-mail.de>
Date: Thu, 16 Jul 2015 21:53:17 +0200
Subject: cmExtraCodeLiteGenerator: port to cmXMLWriter

---
 Source/cmExtraCodeLiteGenerator.cxx | 242 ++++++++++++++++++++++--------------
 1 file changed, 149 insertions(+), 93 deletions(-)

diff --git a/Source/cmExtraCodeLiteGenerator.cxx b/Source/cmExtraCodeLiteGenerator.cxx
index 67aa157..9fc7b1e 100644
--- a/Source/cmExtraCodeLiteGenerator.cxx
+++ b/Source/cmExtraCodeLiteGenerator.cxx
@@ -24,7 +24,7 @@
 #include <cmsys/SystemInformation.hxx>
 #include <cmsys/Directory.hxx>
 #include "cmStandardIncludes.h"
-#include "cmXMLSafe.h"
+#include "cmXMLWriter.h"
 
 //----------------------------------------------------------------------------
 void cmExtraCodeLiteGenerator::GetDocumentation(cmDocumentationEntry& entry,
@@ -54,16 +54,14 @@ void cmExtraCodeLiteGenerator::Generate()
   std::string workspaceOutputDir;
   std::string workspaceFileName;
   std::string workspaceSourcePath;
-  std::string lprjdebug;
 
-  cmGeneratedFileStream fout;
+  const std::map<std::string, std::vector<cmLocalGenerator*> >& projectMap =
+      this->GlobalGenerator->GetProjectMap();
 
   // loop projects and locate the root project.
   // and extract the information for creating the worspace
   for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
-       it = this->GlobalGenerator->GetProjectMap().begin();
-       it!= this->GlobalGenerator->GetProjectMap().end();
-       ++it)
+       it = projectMap.begin(); it!= projectMap.end(); ++it)
     {
     const cmMakefile* mf =it->second[0]->GetMakefile();
     this->ConfigName = GetConfigurationName( mf );
@@ -77,18 +75,20 @@ void cmExtraCodeLiteGenerator::Generate()
       workspaceFileName    = workspaceOutputDir+"/";
       workspaceFileName   += workspaceProjectName + ".workspace";
       this->WorkspacePath = it->second[0]->GetCurrentBinaryDirectory();;
-
-      fout.Open(workspaceFileName.c_str(), false, false);
-      fout << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
-           "<CodeLite_Workspace Name=\"" << workspaceProjectName << "\" >\n";
+      break;
       }
     }
 
+  cmGeneratedFileStream fout(workspaceFileName.c_str());
+  cmXMLWriter xml(fout);
+
+  xml.StartDocument("utf-8");
+  xml.StartElement("CodeLite_Workspace");
+  xml.Attribute("Name", workspaceProjectName);
+
   // for each sub project in the workspace create a codelite project
   for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
-       it = this->GlobalGenerator->GetProjectMap().begin();
-       it!= this->GlobalGenerator->GetProjectMap().end();
-       ++it)
+       it = projectMap.begin(); it!= projectMap.end(); ++it)
     {
     // retrive project information
     std::string outputDir   = it->second[0]->GetCurrentBinaryDirectory();
@@ -101,19 +101,33 @@ void cmExtraCodeLiteGenerator::Generate()
 
     // create a project file
     this->CreateProjectFile(it->second);
-    fout << "  <Project Name=\"" << projectName << "\" Path=\""
-    << filename << "\" Active=\"No\"/>\n";
-    lprjdebug += "<Project Name=\"" + projectName
-              + "\" ConfigName=\"" + this->ConfigName + "\"/>\n";
+    xml.StartElement("Project");
+    xml.Attribute("Name", projectName);
+    xml.Attribute("Path", filename);
+    xml.Attribute("Active", "No");
+    xml.EndElement();
+    }
+
+  xml.StartElement("BuildMatrix");
+  xml.StartElement("WorkspaceConfiguration");
+  xml.Attribute("Name", this->ConfigName);
+  xml.Attribute("Selected", "yes");
+
+  for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
+       it = projectMap.begin(); it!= projectMap.end(); ++it)
+    {
+    // retrive project information
+    std::string projectName = it->second[0]->GetProjectName();
+
+    xml.StartElement("Project");
+    xml.Attribute("Name", projectName);
+    xml.Attribute("ConfigName", this->ConfigName);
+    xml.EndElement();
     }
 
-  fout << "  <BuildMatrix>\n"
-       "    <WorkspaceConfiguration Name=\""
-       << this->ConfigName << "\" Selected=\"yes\">\n"
-       "      " << lprjdebug << ""
-       "    </WorkspaceConfiguration>\n"
-       "  </BuildMatrix>\n"
-       "</CodeLite_Workspace>\n";
+  xml.EndElement(); // WorkspaceConfiguration
+  xml.EndElement(); // BuildMatrix
+  xml.EndElement(); // CodeLite_Workspace
 }
 
 /* create the project file */
@@ -138,11 +152,13 @@ void cmExtraCodeLiteGenerator
     {
     return;
     }
+  cmXMLWriter xml(fout);
 
   ////////////////////////////////////
-  fout << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
-       "<CodeLite_Project Name=\"" << lgs[0]->GetProjectName()
-       << "\" InternalType=\"\">\n";
+  xml.StartDocument("utf-8");
+  xml.StartElement("CodeLite_Project");
+  xml.Attribute("Name", lgs[0]->GetProjectName());
+  xml.Attribute("InternalType", "");
 
   // Collect all used source files in the project
   // Sort them into two containers, one for C/C++ implementation files
@@ -285,7 +301,8 @@ void cmExtraCodeLiteGenerator
   // Create 2 virtual folders: src and include
   // and place all the implementation files into the src
   // folder, the rest goes to the include folder
-  fout<< "  <VirtualDirectory Name=\"src\">\n";
+  xml.StartElement("VirtualDirectory");
+  xml.Attribute("Name", "src");
 
   // insert all source files in the codelite project
   // first the C/C++ implementation files, then all others
@@ -294,22 +311,25 @@ void cmExtraCodeLiteGenerator
        sit!=cFiles.end();
        ++sit)
     {
-    std::string relativePath =
-      cmSystemTools::RelativePath(projectPath.c_str(), sit->first.c_str());
-    fout<< "    <File Name=\"" << relativePath << "\"/>\n";
+    xml.StartElement("File");
+    xml.Attribute("Name",
+      cmSystemTools::RelativePath(projectPath.c_str(), sit->first.c_str()));
+    xml.EndElement();
     }
-  fout<< "  </VirtualDirectory>\n";
-  fout<< "  <VirtualDirectory Name=\"include\">\n";
+  xml.EndElement(); // VirtualDirectory
+  xml.StartElement("VirtualDirectory");
+  xml.Attribute("Name", "include");
   for (std::set<std::string>::const_iterator
        sit=otherFiles.begin();
        sit!=otherFiles.end();
        ++sit)
     {
-    std::string relativePath =
-      cmSystemTools::RelativePath(projectPath.c_str(), sit->c_str());
-    fout << "    <File Name=\"" << relativePath << "\"/>\n";
+    xml.StartElement("File");
+    xml.Attribute("Name",
+      cmSystemTools::RelativePath(projectPath.c_str(), sit->c_str()));
+    xml.EndElement();
     }
-  fout << "  </VirtualDirectory>\n";
+  xml.EndElement(); // VirtualDirectory
 
   // Get the number of CPUs. We use this information for the make -jN
   // command
@@ -319,63 +339,99 @@ void cmExtraCodeLiteGenerator
   this->CpuCount = info.GetNumberOfLogicalCPU() *
                    info.GetNumberOfPhysicalCPU();
 
-  std::string cleanCommand      = GetCleanCommand(mf);
-  std::string buildCommand      = GetBuildCommand(mf);
-  std::string rebuildCommand    = GetRebuildCommand(mf);
-  std::string singleFileCommand = GetSingleFileBuildCommand(mf);
-
   std::string codeliteCompilerName = this->GetCodeLiteCompilerName(mf);
 
-  fout << "\n"
-     "  <Settings Type=\"" << projectType << "\">\n"
-     "    <Configuration Name=\"" << this->ConfigName << "\" CompilerType=\""
-     << codeliteCompilerName << "\" DebuggerType=\"GNU gdb debugger\" "
-     "Type=\""
-     << projectType << "\" BuildCmpWithGlobalSettings=\"append\" "
-     "BuildLnkWithGlobalSettings=\"append\" "
-     "BuildResWithGlobalSettings=\"append\">\n"
-     "      <Compiler Options=\"-g\" "
-     "Required=\"yes\" PreCompiledHeader=\"\">\n"
-     "        <IncludePath Value=\".\"/>\n"
-     "      </Compiler>\n"
-     "      <Linker Options=\"\" Required=\"yes\"/>\n"
-     "      <ResourceCompiler Options=\"\" Required=\"no\"/>\n"
-     "      <General OutputFile=\"$(IntermediateDirectory)/$(ProjectName)\" "
-     "IntermediateDirectory=\"./\" Command=\"./$(ProjectName)\" "
-     "CommandArguments=\"\" WorkingDirectory=\"$(IntermediateDirectory)\" "
-     "PauseExecWhenProcTerminates=\"yes\"/>\n"
-     "      <Debugger IsRemote=\"no\" RemoteHostName=\"\" "
-     "RemoteHostPort=\"\" DebuggerPath=\"\">\n"
-     "        <PostConnectCommands/>\n"
-     "        <StartupCommands/>\n"
-     "      </Debugger>\n"
-     "      <PreBuild/>\n"
-     "      <PostBuild/>\n"
-     "      <CustomBuild Enabled=\"yes\">\n"
-     "        <RebuildCommand>" << rebuildCommand << "</RebuildCommand>\n"
-     "        <CleanCommand>" << cleanCommand << "</CleanCommand>\n"
-     "        <BuildCommand>" << buildCommand << "</BuildCommand>\n"
-     "        <SingleFileCommand>" << singleFileCommand
-     << "</SingleFileCommand>\n"
-     "        <PreprocessFileCommand/>\n"
-     "        <WorkingDirectory>$(WorkspacePath)</WorkingDirectory>\n"
-     "      </CustomBuild>\n"
-     "      <AdditionalRules>\n"
-     "        <CustomPostBuild/>\n"
-     "        <CustomPreBuild/>\n"
-     "      </AdditionalRules>\n"
-     "    </Configuration>\n"
-     "    <GlobalSettings>\n"
-     "      <Compiler Options=\"\">\n"
-     "        <IncludePath Value=\".\"/>\n"
-     "      </Compiler>\n"
-     "      <Linker Options=\"\">\n"
-     "        <LibraryPath Value=\".\"/>\n"
-     "      </Linker>\n"
-     "      <ResourceCompiler Options=\"\"/>\n"
-     "    </GlobalSettings>\n"
-     "  </Settings>\n"
-     "</CodeLite_Project>\n";
+  xml.StartElement("Settings");
+  xml.Attribute("Type", projectType);
+
+  xml.StartElement("Configuration");
+  xml.Attribute("Name", this->ConfigName);
+  xml.Attribute("CompilerType", this->GetCodeLiteCompilerName(mf));
+  xml.Attribute("DebuggerType", "GNU gdb debugger");
+  xml.Attribute("Type", projectType);
+  xml.Attribute("BuildCmpWithGlobalSettings", "append");
+  xml.Attribute("BuildLnkWithGlobalSettings", "append");
+  xml.Attribute("BuildResWithGlobalSettings", "append");
+
+  xml.StartElement("Compiler");
+  xml.Attribute("Options", "-g");
+  xml.Attribute("Required", "yes");
+  xml.Attribute("PreCompiledHeader", "");
+  xml.StartElement("IncludePath");
+  xml.Attribute("Value", ".");
+  xml.EndElement(); // IncludePath
+  xml.EndElement(); // Compiler
+
+  xml.StartElement("Linker");
+  xml.Attribute("Options", "");
+  xml.Attribute("Required", "yes");
+  xml.EndElement(); // Linker
+
+  xml.StartElement("ResourceCompiler");
+  xml.Attribute("Options", "");
+  xml.Attribute("Required", "no");
+  xml.EndElement(); // ResourceCompiler
+
+  xml.StartElement("General");
+  xml.Attribute("OutputFile", "$(IntermediateDirectory)/$(ProjectName)");
+  xml.Attribute("IntermediateDirectory", "./");
+  xml.Attribute("Command", "./$(ProjectName)");
+  xml.Attribute("CommandArguments", "");
+  xml.Attribute("WorkingDirectory", "$(IntermediateDirectory)");
+  xml.Attribute("PauseExecWhenProcTerminates", "yes");
+  xml.EndElement(); // General
+
+  xml.StartElement("Debugger");
+  xml.Attribute("IsRemote", "no");
+  xml.Attribute("RemoteHostName", "");
+  xml.Attribute("RemoteHostPort", "");
+  xml.Attribute("DebuggerPath", "");
+  xml.Element("PostConnectCommands");
+  xml.Element("StartupCommands");
+  xml.EndElement(); // Debugger
+
+  xml.Element("PreBuild");
+  xml.Element("PostBuild");
+
+  xml.StartElement("CustomBuild");
+  xml.Attribute("Enabled", "yes");
+  xml.Element("RebuildCommand", GetRebuildCommand(mf));
+  xml.Element("CleanCommand", GetCleanCommand(mf));
+  xml.Element("BuildCommand", GetBuildCommand(mf));
+  xml.Element("SingleFileCommand", GetSingleFileBuildCommand(mf));
+  xml.Element("PreprocessFileCommand");
+  xml.Element("WorkingDirectory", "$(WorkspacePath)");
+  xml.EndElement(); // CustomBuild
+
+  xml.StartElement("AdditionalRules");
+  xml.Element("CustomPostBuild");
+  xml.Element("CustomPreBuild");
+  xml.EndElement(); // AdditionalRules
+
+  xml.EndElement(); // Configuration
+  xml.StartElement("GlobalSettings");
+
+  xml.StartElement("Compiler");
+  xml.Attribute("Options", "");
+  xml.StartElement("IncludePath");
+  xml.Attribute("Value", ".");
+  xml.EndElement(); // IncludePath
+  xml.EndElement(); // Compiler
+
+  xml.StartElement("Linker");
+  xml.Attribute("Options", "");
+  xml.StartElement("LibraryPath");
+  xml.Attribute("Value", ".");
+  xml.EndElement(); // LibraryPath
+  xml.EndElement(); // Linker
+
+  xml.StartElement("ResourceCompiler");
+  xml.Attribute("Options", "");
+  xml.EndElement(); // ResourceCompiler
+
+  xml.EndElement(); // GlobalSettings
+  xml.EndElement(); // Settings
+  xml.EndElement(); // CodeLite_Project
 }
 
 std::string
@@ -454,7 +510,7 @@ cmExtraCodeLiteGenerator::GetCleanCommand(const cmMakefile* mf) const
 std::string
 cmExtraCodeLiteGenerator::GetRebuildCommand(const cmMakefile* mf) const
 {
-  return GetCleanCommand(mf) + cmXMLSafe(" && ").str() + GetBuildCommand(mf);
+  return GetCleanCommand(mf) + " && " + GetBuildCommand(mf);
 }
 
 std::string
-- 
cgit v0.12


From c45671b0f1bbad18a190c42f4762df48f96b96f3 Mon Sep 17 00:00:00 2001
From: Daniel Pfeifer <daniel@pfeifer-mail.de>
Date: Thu, 16 Jul 2015 23:07:15 +0200
Subject: cmGlobalKdevelopGenerator: port to cmXMLWriter

---
 Source/cmGlobalKdevelopGenerator.cxx | 351 ++++++++++++++++++++---------------
 1 file changed, 205 insertions(+), 146 deletions(-)

diff --git a/Source/cmGlobalKdevelopGenerator.cxx b/Source/cmGlobalKdevelopGenerator.cxx
index 018ab24..b4f7670 100644
--- a/Source/cmGlobalKdevelopGenerator.cxx
+++ b/Source/cmGlobalKdevelopGenerator.cxx
@@ -18,6 +18,7 @@
 #include "cmSourceFile.h"
 #include "cmGeneratedFileStream.h"
 #include "cmSystemTools.h"
+#include "cmXMLWriter.h"
 
 #include <cmsys/SystemTools.hxx>
 #include <cmsys/Directory.hxx>
@@ -397,6 +398,7 @@ void cmGlobalKdevelopGenerator
     {
     return;
     }
+  cmXMLWriter xml(fout);
 
   // check for a version control system
   bool hasSvn = cmSystemTools::FileExists((projectDir + "/.svn").c_str());
@@ -411,182 +413,230 @@ void cmGlobalKdevelopGenerator
     primaryLanguage="Fortran77";
     }
 
-  fout<<"<?xml version = '1.0'?>\n"
-        "<kdevelop>\n"
-        "  <general>\n"
-        "  <author></author>\n"
-        "  <email></email>\n"
-        "  <version>$VERSION$</version>\n"
-        "  <projectmanagement>KDevCustomProject</projectmanagement>\n"
-        "  <primarylanguage>" << primaryLanguage << "</primarylanguage>\n"
-        "  <ignoreparts/>\n"
-        "  <projectdirectory>" << projectDir <<
-        "</projectdirectory>\n";   //this one is important
-  fout<<"  <absoluteprojectpath>true</absoluteprojectpath>\n"; //and this one
+  xml.StartDocument();
+  xml.StartElement("kdevelop");
+  xml.StartElement("general");
+
+  xml.Element("author", "");
+  xml.Element("email", "");
+  xml.Element("version", "$VERSION$");
+  xml.Element("projectmanagement", "KDevCustomProject");
+  xml.Element("primarylanguage", primaryLanguage);
+  xml.Element("ignoreparts");
+  xml.Element("projectdirectory", projectDir); // this one is important
+  xml.Element("absoluteprojectpath", "true");  // and this one
 
   // setup additional languages
-  fout<<"  <secondaryLanguages>\n";
+  xml.StartElement("secondaryLanguages");
   if (enableFortran && enableCxx)
     {
-    fout<<"     <language>Fortran</language>\n";
+    xml.Element("language", "Fortran");
     }
   if (enableCxx)
     {
-    fout<<"     <language>C</language>\n";
+    xml.Element("language", "C");
     }
-  fout<<"  </secondaryLanguages>\n";
+  xml.EndElement();
 
   if (hasSvn)
     {
-    fout << "  <versioncontrol>kdevsubversion</versioncontrol>\n";
+    xml.Element("versioncontrol", "kdevsubversion");
     }
   else if (hasCvs)
     {
-    fout << "  <versioncontrol>kdevcvsservice</versioncontrol>\n";
+    xml.Element("versioncontrol", "kdevcvsservice");
     }
 
-  fout<<"  </general>\n"
-        "  <kdevcustomproject>\n"
-        "    <filelistdirectory>" << outputDir <<
-        "</filelistdirectory>\n"
-        "    <run>\n"
-        "      <mainprogram>" << executable << "</mainprogram>\n"
-        "      <directoryradio>custom</directoryradio>\n"
-        "      <customdirectory>"<<outputDir<<"</customdirectory>\n"
-        "      <programargs></programargs>\n"
-        "      <terminal>false</terminal>\n"
-        "      <autocompile>true</autocompile>\n"
-        "      <envvars/>\n"
-        "    </run>\n"
-        "    <build>\n"
-        "      <buildtool>make</buildtool>\n"; //this one is important
-  fout<<"      <builddir>"<<outputDir<<"</builddir>\n";  //and this one
-  fout<<"    </build>\n"
-        "    <make>\n"
-        "      <abortonerror>false</abortonerror>\n"
-        "      <numberofjobs>1</numberofjobs>\n"
-        "      <dontact>false</dontact>\n"
-        "      <makebin>" << this->GlobalGenerator->GetLocalGenerators()[0]->
-            GetMakefile()->GetRequiredDefinition("CMAKE_MAKE_PROGRAM")
-            << " </makebin>\n"
-        "      <selectedenvironment>default</selectedenvironment>\n"
-        "      <environments>\n"
-        "        <default>\n"
-        "          <envvar value=\"1\" name=\"VERBOSE\" />\n"
-        "          <envvar value=\"1\" name=\"CMAKE_NO_VERBOSE\" />\n"
-        "        </default>\n"
-        "      </environments>\n"
-        "    </make>\n";
-
-  fout<<"    <blacklist>\n";
+  xml.EndElement(); // general
+  xml.StartElement("kdevcustomproject");
+
+  xml.Element("filelistdirectory", outputDir);
+
+  xml.StartElement("run");
+  xml.Element("mainprogram", executable);
+  xml.Element("directoryradio", "custom");
+  xml.Element("customdirectory", outputDir);
+  xml.Element("programargs", "");
+  xml.Element("terminal", "false");
+  xml.Element("autocompile", "true");
+  xml.Element("envvars");
+  xml.EndElement();
+
+  xml.StartElement("build");
+  xml.Element("buildtool", "make");   // this one is important
+  xml.Element("builddir", outputDir); // and this one
+  xml.EndElement();
+
+  xml.StartElement("make");
+  xml.Element("abortonerror", "false");
+  xml.Element("numberofjobs", 1);
+  xml.Element("dontact", "false");
+  xml.Element("makebin", this->GlobalGenerator->GetLocalGenerators()[0]->
+      GetMakefile()->GetRequiredDefinition("CMAKE_MAKE_PROGRAM"));
+  xml.Element("selectedenvironment", "default");
+
+  xml.StartElement("environments");
+  xml.StartElement("default");
+
+  xml.StartElement("envvar");
+  xml.Attribute("value", 1);
+  xml.Attribute("name", "VERBOSE");
+  xml.EndElement();
+
+  xml.StartElement("envvar");
+  xml.Attribute("value", 1);
+  xml.Attribute("name", "CMAKE_NO_VERBOSE");
+  xml.EndElement();
+
+  xml.EndElement(); // default
+  xml.EndElement(); // environments
+  xml.EndElement(); // make
+
+  xml.StartElement("blacklist");
   for(std::vector<std::string>::const_iterator dirIt=this->Blacklist.begin();
       dirIt != this->Blacklist.end();
       ++dirIt)
     {
-    fout<<"      <path>" << *dirIt << "</path>\n";
+    xml.Element("path", *dirIt);
     }
-  fout<<"    </blacklist>\n";
-
-  fout<<"  </kdevcustomproject>\n"
-        "  <kdevfilecreate>\n"
-        "    <filetypes/>\n"
-        "    <useglobaltypes>\n"
-        "      <type ext=\"ui\" />\n"
-        "      <type ext=\"cpp\" />\n"
-        "      <type ext=\"h\" />\n"
-        "    </useglobaltypes>\n"
-        "  </kdevfilecreate>\n"
-        "  <kdevdoctreeview>\n"
-        "    <projectdoc>\n"
-        "      <userdocDir>html/</userdocDir>\n"
-        "      <apidocDir>html/</apidocDir>\n"
-        "    </projectdoc>\n"
-        "    <ignoreqt_xml/>\n"
-        "    <ignoredoxygen/>\n"
-        "    <ignorekdocs/>\n"
-        "    <ignoretocs/>\n"
-        "    <ignoredevhelp/>\n"
-        "  </kdevdoctreeview>\n";
+  xml.EndElement();
+
+  xml.EndElement(); // kdevcustomproject
+
+  xml.StartElement("kdevfilecreate");
+  xml.Element("filetypes");
+  xml.StartElement("useglobaltypes");
+
+  xml.StartElement("type");
+  xml.Attribute("ext", "ui");
+  xml.EndElement();
+
+  xml.StartElement("type");
+  xml.Attribute("ext", "cpp");
+  xml.EndElement();
+
+  xml.StartElement("type");
+  xml.Attribute("ext", "h");
+  xml.EndElement();
+
+  xml.EndElement(); // useglobaltypes
+  xml.EndElement(); // kdevfilecreate
+
+  xml.StartElement("kdevdoctreeview");
+  xml.StartElement("projectdoc");
+  xml.Element("userdocDir", "html/");
+  xml.Element("apidocDir", "html/");
+  xml.EndElement(); // projectdoc
+  xml.Element("ignoreqt_xml");
+  xml.Element("ignoredoxygen");
+  xml.Element("ignorekdocs");
+  xml.Element("ignoretocs");
+  xml.Element("ignoredevhelp");
+  xml.EndElement(); // kdevdoctreeview;
 
   if (enableCxx)
     {
-    fout<<"  <cppsupportpart>\n"
-          "    <filetemplates>\n"
-          "      <interfacesuffix>.h</interfacesuffix>\n"
-          "      <implementationsuffix>.cpp</implementationsuffix>\n"
-          "    </filetemplates>\n"
-          "  </cppsupportpart>\n"
-          "  <kdevcppsupport>\n"
-          "    <codecompletion>\n"
-          "      <includeGlobalFunctions>true</includeGlobalFunctions>\n"
-          "      <includeTypes>true</includeTypes>\n"
-          "      <includeEnums>true</includeEnums>\n"
-          "      <includeTypedefs>false</includeTypedefs>\n"
-          "      <automaticCodeCompletion>true</automaticCodeCompletion>\n"
-          "      <automaticArgumentsHint>true</automaticArgumentsHint>\n"
-          "      <automaticHeaderCompletion>true</automaticHeaderCompletion>\n"
-          "      <codeCompletionDelay>250</codeCompletionDelay>\n"
-          "      <argumentsHintDelay>400</argumentsHintDelay>\n"
-          "      <headerCompletionDelay>250</headerCompletionDelay>\n"
-          "    </codecompletion>\n"
-          "    <references/>\n"
-          "  </kdevcppsupport>\n";
+    xml.StartElement("cppsupportpart");
+    xml.StartElement("filetemplates");
+    xml.Element("interfacesuffix", ".h");
+    xml.Element("implementationsuffix", ".cpp");
+    xml.EndElement(); // filetemplates
+    xml.EndElement(); // cppsupportpart
+
+    xml.StartElement("kdevcppsupport");
+    xml.StartElement("codecompletion");
+    xml.Element("includeGlobalFunctions", "true");
+    xml.Element("includeTypes", "true");
+    xml.Element("includeEnums", "true");
+    xml.Element("includeTypedefs", "false");
+    xml.Element("automaticCodeCompletion", "true");
+    xml.Element("automaticArgumentsHint", "true");
+    xml.Element("automaticHeaderCompletion", "true");
+    xml.Element("codeCompletionDelay", 250);
+    xml.Element("argumentsHintDelay", 400);
+    xml.Element("headerCompletionDelay", 250);
+    xml.EndElement(); // codecompletion
+    xml.Element("references");
+    xml.EndElement(); // kdevcppsupport;
     }
 
   if (enableFortran)
     {
-    fout<<"  <kdevfortransupport>\n"
-          "    <ftnchek>\n"
-          "      <division>false</division>\n"
-          "      <extern>false</extern>\n"
-          "      <declare>false</declare>\n"
-          "      <pure>false</pure>\n"
-          "      <argumentsall>false</argumentsall>\n"
-          "      <commonall>false</commonall>\n"
-          "      <truncationall>false</truncationall>\n"
-          "      <usageall>false</usageall>\n"
-          "      <f77all>false</f77all>\n"
-          "      <portabilityall>false</portabilityall>\n"
-          "      <argumentsonly/>\n"
-          "      <commononly/>\n"
-          "      <truncationonly/>\n"
-          "      <usageonly/>\n"
-          "      <f77only/>\n"
-          "      <portabilityonly/>\n"
-          "    </ftnchek>\n"
-          "  </kdevfortransupport>\n";
+    xml.StartElement("kdevfortransupport");
+    xml.StartElement("ftnchek");
+    xml.Element("division", "false");
+    xml.Element("extern", "false");
+    xml.Element("declare", "false");
+    xml.Element("pure", "false");
+    xml.Element("argumentsall", "false");
+    xml.Element("commonall", "false");
+    xml.Element("truncationall", "false");
+    xml.Element("usageall", "false");
+    xml.Element("f77all", "false");
+    xml.Element("portabilityall", "false");
+    xml.Element("argumentsonly");
+    xml.Element("commononly");
+    xml.Element("truncationonly");
+    xml.Element("usageonly");
+    xml.Element("f77only");
+    xml.Element("portabilityonly");
+    xml.EndElement(); // ftnchek
+    xml.EndElement(); // kdevfortransupport;
     }
 
   // set up file groups. maybe this can be used with the CMake SOURCE_GROUP()
   // command
-  fout<<"  <kdevfileview>\n"
-        "    <groups>\n"
-        "      <group pattern=\"" << cmakeFilePattern <<
-        "\" name=\"CMake\" />\n";
+  xml.StartElement("kdevfileview");
+  xml.StartElement("groups");
+
+  xml.StartElement("group");
+  xml.Attribute("pattern", cmakeFilePattern);
+  xml.Attribute("name", "CMake");
+  xml.EndElement();
 
   if (enableCxx)
     {
-    fout<<"      <group pattern=\"*.h;*.hxx;*.hpp\" name=\"Header\" />\n"
-          "      <group pattern=\"*.c\" name=\"C Sources\" />\n"
-          "      <group pattern=\"*.cpp;*.C;*.cxx;*.cc\" name=\"C++ Sources\""
-          "/>\n";
+    xml.StartElement("group");
+    xml.Attribute("pattern", "*.h;*.hxx;*.hpp");
+    xml.Attribute("name", "Header");
+    xml.EndElement();
+
+    xml.StartElement("group");
+    xml.Attribute("pattern", "*.c");
+    xml.Attribute("name", "C Sources");
+    xml.EndElement();
+
+    xml.StartElement("group");
+    xml.Attribute("pattern", "*.cpp;*.C;*.cxx;*.cc");
+    xml.Attribute("name", "C++ Sources");
+    xml.EndElement();
     }
 
   if (enableFortran)
     {
-    fout<<"      <group pattern=\"*.f;*.F;*.f77;*.F77;*.f90;*.F90;*.for;*.f95;"
-          "*.F95\" name=\"Fortran Sources\" />\n";
+    xml.StartElement("group");
+    xml.Attribute("pattern",
+        "*.f;*.F;*.f77;*.F77;*.f90;*.F90;*.for;*.f95;*.F95");
+    xml.Attribute("name", "Fortran Sources");
+    xml.EndElement();
     }
 
-  fout<<"      <group pattern=\"*.ui\" name=\"Qt Designer files\" />\n"
-        "      <hidenonprojectfiles>true</hidenonprojectfiles>\n"
-        "    </groups>\n"
-        "    <tree>\n"
-        "      <hidepatterns>*.o,*.lo,CVS,*~,cmake*</hidepatterns>\n"
-        "      <hidenonprojectfiles>true</hidenonprojectfiles>\n"
-        "    </tree>\n"
-        "  </kdevfileview>\n"
-        "</kdevelop>\n";
+  xml.StartElement("group");
+  xml.Attribute("pattern", "*.ui");
+  xml.Attribute("name", "Qt Designer files");
+  xml.EndElement();
+
+  xml.Element("hidenonprojectfiles", "true");
+  xml.EndElement(); // groups
+
+  xml.StartElement("tree");
+  xml.Element("hidepatterns", "*.o,*.lo,CVS,*~,cmake*");
+  xml.Element("hidenonprojectfiles", "true");
+  xml.EndElement(); // tree
+
+  xml.EndElement(); // kdevfileview
+  xml.EndElement(); // kdevelop;
+  xml.EndDocument();
 
   if (sessionFilename.empty())
     {
@@ -600,15 +650,24 @@ void cmGlobalKdevelopGenerator
     {
     return;
     }
-  devses<<"<?xml version = '1.0' encoding = \'UTF-8\'?>\n"
-          "<!DOCTYPE KDevPrjSession>\n"
-          "<KDevPrjSession>\n"
-          " <DocsAndViews NumberOfDocuments=\"1\" >\n"
-          "  <Doc0 NumberOfViews=\"1\" URL=\"file://" << fileToOpen <<
-          "\" >\n"
-          "   <View0 line=\"0\" Type=\"Source\" />\n"
-          "  </Doc0>\n"
-          " </DocsAndViews>\n"
-          "</KDevPrjSession>\n";
+  cmXMLWriter sesxml(devses);
+  sesxml.StartDocument("UTF-8");
+  sesxml.Doctype("KDevPrjSession");
+  sesxml.StartElement("KDevPrjSession");
+
+  sesxml.StartElement("DocsAndViews");
+  sesxml.Attribute("NumberOfDocuments", 1);
+
+  sesxml.StartElement("Doc0");
+  sesxml.Attribute("NumberOfViews", 1);
+  sesxml.Attribute("URL", "file://" + fileToOpen);
+
+  sesxml.StartElement("View0");
+  sesxml.Attribute("line", 0);
+  sesxml.Attribute("Type", "Source");
+  sesxml.EndElement(); // View0
+
+  sesxml.EndElement(); // Doc0
+  sesxml.EndElement(); // DocsAndViews
+  sesxml.EndElement(); // KDevPrjSession;
 }
-
-- 
cgit v0.12


From 754485afff2b0dcf6ba16af8b65d08d1fcf75702 Mon Sep 17 00:00:00 2001
From: Daniel Pfeifer <daniel@pfeifer-mail.de>
Date: Sun, 2 Aug 2015 22:06:38 +0200
Subject: cmExtraEclipseCDT4Generator: port to cmXMLWriter

---
 Source/cmExtraEclipseCDT4Generator.cxx | 687 +++++++++++++++------------------
 Source/cmExtraEclipseCDT4Generator.h   |  21 +-
 2 files changed, 328 insertions(+), 380 deletions(-)

diff --git a/Source/cmExtraEclipseCDT4Generator.cxx b/Source/cmExtraEclipseCDT4Generator.cxx
index 133a85a..f0227b0 100644
--- a/Source/cmExtraEclipseCDT4Generator.cxx
+++ b/Source/cmExtraEclipseCDT4Generator.cxx
@@ -19,11 +19,29 @@
 #include "cmState.h"
 #include "cmTarget.h"
 #include "cmSourceFile.h"
+#include "cmXMLWriter.h"
 
 #include "cmSystemTools.h"
 #include <stdlib.h>
 #include <assert.h>
 
+static void AppendAttribute(cmXMLWriter& xml, const char* keyval)
+{
+  xml.StartElement("attribute");
+  xml.Attribute("key", keyval);
+  xml.Attribute("value", keyval);
+  xml.EndElement();
+}
+
+template<typename T>
+void AppendDictionary(cmXMLWriter& xml, const char* key, T const& value)
+{
+  xml.StartElement("dictionary");
+  xml.Element("key", key);
+  xml.Element("value", value);
+  xml.EndElement();
+}
+
 //----------------------------------------------------------------------------
 cmExtraEclipseCDT4Generator
 ::cmExtraEclipseCDT4Generator() : cmExternalMakefileProjectGenerator()
@@ -172,34 +190,30 @@ void cmExtraEclipseCDT4Generator::CreateSourceProjectFile()
     return;
     }
 
-  fout <<
-    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
-    "<projectDescription>\n"
-    "\t<name>" << this->EscapeForXML(name) << "</name>\n"
-    "\t<comment></comment>\n"
-    "\t<projects>\n"
-    "\t</projects>\n"
-    "\t<buildSpec>\n"
-    "\t</buildSpec>\n"
-    "\t<natures>\n"
-    "\t</natures>\n"
-    "\t<linkedResources>\n";
+  cmXMLWriter xml(fout);
+  xml.StartDocument("UTF-8");
+  xml.StartElement("projectDescription");
+  xml.Element("name", name);
+  xml.Element("comment", "");
+  xml.Element("projects", "");
+  xml.Element("buildSpec", "");
+  xml.Element("natures", "");
+  xml.StartElement("linkedResources");
 
   if (this->SupportsVirtualFolders)
     {
-    this->CreateLinksToSubprojects(fout, this->HomeDirectory);
+    this->CreateLinksToSubprojects(xml, this->HomeDirectory);
     this->SrcLinkedResources.clear();
     }
 
-  fout <<
-    "\t</linkedResources>\n"
-    "</projectDescription>\n"
-    ;
+  xml.EndElement(); // linkedResources
+  xml.EndElement(); // projectDescription
+  xml.EndDocument();
 }
 
 
 //----------------------------------------------------------------------------
-void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout,
+void cmExtraEclipseCDT4Generator::AddEnvVar(std::ostream& out,
                                             const char* envVar,
                                             cmLocalGenerator* lg)
 {
@@ -257,7 +271,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout,
 
   if (!valueToUse.empty())
     {
-    fout << envVar << "=" << valueToUse << "|";
+    out << envVar << "=" << valueToUse << "|";
     }
 }
 
@@ -282,197 +296,125 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
     compilerId = mf->GetSafeDefinition("CMAKE_CXX_COMPILER_ID");
     }
 
-  fout <<
-    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
-    "<projectDescription>\n"
-    "\t<name>" <<
-    this->GenerateProjectName(lg->GetProjectName(),
-                              mf->GetSafeDefinition("CMAKE_BUILD_TYPE"),
-                              this->GetPathBasename(this->HomeOutputDirectory))
-    << "</name>\n"
-    "\t<comment></comment>\n"
-    "\t<projects>\n"
-    "\t</projects>\n"
-    "\t<buildSpec>\n"
-    "\t\t<buildCommand>\n"
-    "\t\t\t<name>org.eclipse.cdt.make.core.makeBuilder</name>\n"
-    "\t\t\t<triggers>clean,full,incremental,</triggers>\n"
-    "\t\t\t<arguments>\n"
-    ;
+  cmXMLWriter xml(fout);
+
+  xml.StartDocument("UTF-8");
+  xml.StartElement("projectDescription");
+
+  xml.Element("name", this->GenerateProjectName(lg->GetProjectName(),
+      mf->GetSafeDefinition("CMAKE_BUILD_TYPE"),
+      this->GetPathBasename(this->HomeOutputDirectory)));
+
+  xml.Element("comment", "");
+  xml.Element("projects", "");
+
+  xml.StartElement("buildSpec");
+  xml.StartElement("buildCommand");
+  xml.Element("name", "org.eclipse.cdt.make.core.makeBuilder");
+  xml.Element("triggers", "clean,full,incremental,");
+  xml.StartElement("arguments");
 
   // use clean target
-  fout <<
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.cleanBuildTarget</key>\n"
-    "\t\t\t\t\t<value>clean</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.enableCleanBuild</key>\n"
-    "\t\t\t\t\t<value>true</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.append_environment</key>\n"
-    "\t\t\t\t\t<value>true</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.stopOnError</key>\n"
-    "\t\t\t\t\t<value>true</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    ;
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.cleanBuildTarget", "clean");
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.enableCleanBuild", "true");
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.append_environment","true");
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.stopOnError", "true");
 
   // set the make command
-  std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
-  const std::string makeArgs = mf->GetSafeDefinition(
-                                               "CMAKE_ECLIPSE_MAKE_ARGUMENTS");
-
-  fout <<
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.enabledIncrementalBuild</key>\n"
-    "\t\t\t\t\t<value>true</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.build.command</key>\n"
-    "\t\t\t\t\t<value>" << this->GetEclipsePath(make) << "</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.contents</key>\n"
-    "\t\t\t\t\t<value>org.eclipse.cdt.make.core.activeConfigSettings</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.build.target.inc</key>\n"
-    "\t\t\t\t\t<value>all</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.build.arguments</key>\n"
-    "\t\t\t\t\t<value>" << makeArgs << "</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.buildLocation</key>\n"
-    "\t\t\t\t\t<value>"
-     << this->GetEclipsePath(this->HomeOutputDirectory) << "</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.useDefaultBuildCmd</key>\n"
-    "\t\t\t\t\t<value>false</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    ;
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.enabledIncrementalBuild",
+      "true");
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.build.command",
+      this->GetEclipsePath(mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM")));
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.contents",
+      "org.eclipse.cdt.make.core.activeConfigSettings");
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.build.target.inc", "all");
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.build.arguments",
+      mf->GetSafeDefinition("CMAKE_ECLIPSE_MAKE_ARGUMENTS"));
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.buildLocation",
+      this->GetEclipsePath(this->HomeOutputDirectory));
+  AppendDictionary(xml,
+      "org.eclipse.cdt.make.core.useDefaultBuildCmd", "false");
 
   // set project specific environment
-  fout <<
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.environment</key>\n"
-    "\t\t\t\t\t<value>VERBOSE=1|CMAKE_NO_VERBOSE=1|"  //verbose Makefile output
-    ;
+  std::stringstream environment;
+  environment << "VERBOSE=1|CMAKE_NO_VERBOSE=1|"; //verbose Makefile output
   // set vsvars32.bat environment available at CMake time,
   //   but not necessarily when eclipse is open
   if (compilerId == "MSVC")
     {
-    AddEnvVar(fout, "PATH", lg);
-    AddEnvVar(fout, "INCLUDE", lg);
-    AddEnvVar(fout, "LIB", lg);
-    AddEnvVar(fout, "LIBPATH", lg);
+    AddEnvVar(environment, "PATH", lg);
+    AddEnvVar(environment, "INCLUDE", lg);
+    AddEnvVar(environment, "LIB", lg);
+    AddEnvVar(environment, "LIBPATH", lg);
     }
   else if (compilerId == "Intel")
     {
     // if the env.var is set, use this one and put it in the cache
     // if the env.var is not set, but the value is in the cache,
     // use it from the cache:
-    AddEnvVar(fout, "INTEL_LICENSE_FILE", lg);
+    AddEnvVar(environment, "INTEL_LICENSE_FILE", lg);
     }
-  fout <<
-    "</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    ;
-
-  fout <<
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.enableFullBuild</key>\n"
-    "\t\t\t\t\t<value>true</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.build.target.auto</key>\n"
-    "\t\t\t\t\t<value>all</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.enableAutoBuild</key>\n"
-    "\t\t\t\t\t<value>false</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.build.target.clean</key>\n"
-    "\t\t\t\t\t<value>clean</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.fullBuildTarget</key>\n"
-    "\t\t\t\t\t<value>all</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.buildArguments</key>\n"
-    "\t\t\t\t\t<value></value>\n"
-    "\t\t\t\t</dictionary>\n"
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.build.location</key>\n"
-    "\t\t\t\t\t<value>"
-    << this->GetEclipsePath(this->HomeOutputDirectory) << "</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.make.core.autoBuildTarget</key>\n"
-    "\t\t\t\t\t<value>all</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    ;
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.environment",
+                   environment.str());
+
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.enableFullBuild", "true");
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.build.target.auto", "all");
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.enableAutoBuild", "false");
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.build.target.clean",
+      "clean");
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.fullBuildTarget", "all");
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.buildArguments", "");
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.build.location",
+      this->GetEclipsePath(this->HomeOutputDirectory));
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.autoBuildTarget", "all");
 
   // set error parsers
-  fout <<
-    "\t\t\t\t<dictionary>\n"
-    "\t\t\t\t\t<key>org.eclipse.cdt.core.errorOutputParser</key>\n"
-    "\t\t\t\t\t<value>"
-    ;
+  std::stringstream errorOutputParser;
+
   if (compilerId == "MSVC")
     {
-    fout << "org.eclipse.cdt.core.VCErrorParser;";
+    errorOutputParser << "org.eclipse.cdt.core.VCErrorParser;";
     }
   else if (compilerId == "Intel")
     {
-    fout << "org.eclipse.cdt.core.ICCErrorParser;";
+    errorOutputParser << "org.eclipse.cdt.core.ICCErrorParser;";
     }
 
   if (this->SupportsGmakeErrorParser)
     {
-    fout << "org.eclipse.cdt.core.GmakeErrorParser;";
+    errorOutputParser << "org.eclipse.cdt.core.GmakeErrorParser;";
     }
   else
     {
-    fout << "org.eclipse.cdt.core.MakeErrorParser;";
+    errorOutputParser << "org.eclipse.cdt.core.MakeErrorParser;";
     }
 
-  fout <<
+  errorOutputParser <<
     "org.eclipse.cdt.core.GCCErrorParser;"
     "org.eclipse.cdt.core.GASErrorParser;"
     "org.eclipse.cdt.core.GLDErrorParser;"
-    "</value>\n"
-    "\t\t\t\t</dictionary>\n"
-    ;
-
-  fout <<
-    "\t\t\t</arguments>\n"
-    "\t\t</buildCommand>\n"
-    "\t\t<buildCommand>\n"
-    "\t\t\t<name>org.eclipse.cdt.make.core.ScannerConfigBuilder</name>\n"
-    "\t\t\t<arguments>\n"
-    "\t\t\t</arguments>\n"
-    "\t\t</buildCommand>\n"
-    "\t</buildSpec>\n"
     ;
+  AppendDictionary(xml, "org.eclipse.cdt.core.errorOutputParser",
+      errorOutputParser.str());
+
+  xml.EndElement(); // arguments
+  xml.EndElement(); // buildCommand
+  xml.StartElement("buildCommand");
+  xml.Element("name", "org.eclipse.cdt.make.core.ScannerConfigBuilder");
+  xml.StartElement("arguments");
+  xml.EndElement(); // arguments
+  xml.EndElement(); // buildCommand
+  xml.EndElement(); // buildSpec
 
   // set natures for c/c++ projects
-  fout <<
-    "\t<natures>\n"
-    "\t\t<nature>org.eclipse.cdt.make.core.makeNature</nature>\n"
-    "\t\t<nature>org.eclipse.cdt.make.core.ScannerConfigNature</nature>\n";
+  xml.StartElement("natures");
+  xml.Element("nature", "org.eclipse.cdt.make.core.makeNature");
+  xml.Element("nature", "org.eclipse.cdt.make.core.ScannerConfigNature");;
 
   for (std::set<std::string>::const_iterator nit=this->Natures.begin();
        nit != this->Natures.end(); ++nit)
     {
-    fout << "\t\t<nature>" << *nit << "</nature>\n";
+    xml.Element("nature", *nit);
     }
 
   if (const char *extraNaturesProp = mf->GetState()
@@ -483,13 +425,13 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
     for (std::vector<std::string>::const_iterator nit = extraNatures.begin();
          nit != extraNatures.end(); ++nit)
       {
-      fout << "\t\t<nature>" << *nit << "</nature>\n";
+      xml.Element("nature", *nit);
       }
     }
 
-  fout << "\t</natures>\n";
+  xml.EndElement(); // natures
 
-  fout << "\t<linkedResources>\n";
+  xml.StartElement("linkedResources");
   // create linked resources
   if (this->IsOutOfSourceBuild)
     {
@@ -506,7 +448,7 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
     if (!cmSystemTools::IsSubDirectory(this->HomeOutputDirectory,
                                          linkSourceDirectory))
       {
-      this->AppendLinkedResource(fout, sourceLinkedResourceName,
+      this->AppendLinkedResource(xml, sourceLinkedResourceName,
                                  this->GetEclipsePath(linkSourceDirectory),
                                  LinkToFolder);
       this->SrcLinkedResources.push_back(sourceLinkedResourceName);
@@ -516,23 +458,21 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
 
   if (this->SupportsVirtualFolders)
     {
-    this->CreateLinksToSubprojects(fout, this->HomeOutputDirectory);
+    this->CreateLinksToSubprojects(xml, this->HomeOutputDirectory);
 
-    this->CreateLinksForTargets(fout);
+    this->CreateLinksForTargets(xml);
     }
 
-  fout << "\t</linkedResources>\n";
-
-  fout << "</projectDescription>\n";
+  xml.EndElement(); // linkedResources
+  xml.EndElement(); // projectDescription
 }
 
 
 //----------------------------------------------------------------------------
-void cmExtraEclipseCDT4Generator::CreateLinksForTargets(
-                                                   cmGeneratedFileStream& fout)
+void cmExtraEclipseCDT4Generator::CreateLinksForTargets(cmXMLWriter& xml)
 {
   std::string linkName = "[Targets]";
-  this->AppendLinkedResource(fout, linkName, "virtual:/virtual",VirtualFolder);
+  this->AppendLinkedResource(xml, linkName, "virtual:/virtual", VirtualFolder);
 
   for (std::vector<cmLocalGenerator*>::const_iterator
        lgIt = this->GlobalGenerator->GetLocalGenerators().begin();
@@ -560,7 +500,7 @@ void cmExtraEclipseCDT4Generator::CreateLinksForTargets(
                                                           "[exe] " : "[lib] ");
           linkName2 += prefix;
           linkName2 += (*ti)->GetName();
-          this->AppendLinkedResource(fout, linkName2, "virtual:/virtual",
+          this->AppendLinkedResource(xml, linkName2, "virtual:/virtual",
                                      VirtualFolder);
           if (!this->GenerateLinkedResources)
             {
@@ -590,7 +530,7 @@ void cmExtraEclipseCDT4Generator::CreateLinksForTargets(
             std::string linkName3 = linkName2;
             linkName3 += "/";
             linkName3 += sgIt->GetFullName();
-            this->AppendLinkedResource(fout, linkName3, "virtual:/virtual",
+            this->AppendLinkedResource(xml, linkName3, "virtual:/virtual",
                                        VirtualFolder);
 
             std::vector<const cmSourceFile*> sFiles = sgIt->GetSourceFiles();
@@ -605,7 +545,7 @@ void cmExtraEclipseCDT4Generator::CreateLinksForTargets(
                 std::string linkName4 = linkName3;
                 linkName4 += "/";
                 linkName4 += cmSystemTools::GetFilenameName(fullPath);
-                this->AppendLinkedResource(fout, linkName4,
+                this->AppendLinkedResource(xml, linkName4,
                                            this->GetEclipsePath(fullPath),
                                            LinkToFile);
                 }
@@ -624,7 +564,7 @@ void cmExtraEclipseCDT4Generator::CreateLinksForTargets(
 
 //----------------------------------------------------------------------------
 void cmExtraEclipseCDT4Generator::CreateLinksToSubprojects(
-                       cmGeneratedFileStream& fout, const std::string& baseDir)
+                       cmXMLWriter& xml, const std::string& baseDir)
 {
   if (!this->GenerateLinkedResources)
     {
@@ -633,7 +573,7 @@ void cmExtraEclipseCDT4Generator::CreateLinksToSubprojects(
 
   // for each sub project create a linked resource to the source dir
   // - only if it is an out-of-source build
-  this->AppendLinkedResource(fout, "[Subprojects]",
+  this->AppendLinkedResource(xml, "[Subprojects]",
                              "virtual:/virtual", VirtualFolder);
 
   for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
@@ -651,7 +591,7 @@ void cmExtraEclipseCDT4Generator::CreateLinksToSubprojects(
       {
       std::string linkName = "[Subprojects]/";
       linkName += it->first;
-      this->AppendLinkedResource(fout, linkName,
+      this->AppendLinkedResource(xml, linkName,
                                  this->GetEclipsePath(linkSourceDirectory),
                                  LinkToFolder
                                 );
@@ -664,7 +604,7 @@ void cmExtraEclipseCDT4Generator::CreateLinksToSubprojects(
 
 //----------------------------------------------------------------------------
 void cmExtraEclipseCDT4Generator::AppendIncludeDirectories(
-                            cmGeneratedFileStream& fout,
+                            cmXMLWriter& xml,
                             const std::vector<std::string>& includeDirs,
                             std::set<std::string>& emittedDirs)
 {
@@ -688,10 +628,13 @@ void cmExtraEclipseCDT4Generator::AppendIncludeDirectories(
       if(emittedDirs.find(dir) == emittedDirs.end())
         {
         emittedDirs.insert(dir);
-        fout << "<pathentry include=\""
-             << cmExtraEclipseCDT4Generator::EscapeForXML(
-                              cmExtraEclipseCDT4Generator::GetEclipsePath(dir))
-             << "\" kind=\"inc\" path=\"\" system=\"true\"/>\n";
+        xml.StartElement("pathentry");
+        xml.Attribute("include",
+            cmExtraEclipseCDT4Generator::GetEclipsePath(dir));
+        xml.Attribute("kind", "inc");
+        xml.Attribute("path", "");
+        xml.Attribute("system", "true");
+        xml.EndElement();
         }
       }
     }
@@ -713,95 +656,100 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
     return;
     }
 
+  cmXMLWriter xml(fout);
+
   // add header
-  fout <<
-    "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n"
-    "<?fileVersion 4.0.0?>\n\n"
-    "<cproject>\n"
-    "<storageModule moduleId=\"org.eclipse.cdt.core.settings\">\n"
-    ;
+  xml.StartDocument("UTF-8");
+  xml.ProcessingInstruction("fileVersion", "4.0.0");
+  xml.StartElement("cproject");
+  xml.StartElement("storageModule");
+  xml.Attribute("moduleId", "org.eclipse.cdt.core.settings");
 
-  fout << "<cconfiguration id=\"org.eclipse.cdt.core.default.config.1\">\n";
+  xml.StartElement("cconfiguration");
+  xml.Attribute("id", "org.eclipse.cdt.core.default.config.1");
 
   // Configuration settings...
-  fout <<
-    "<storageModule"
-    " buildSystemId=\"org.eclipse.cdt.core.defaultConfigDataProvider\""
-    " id=\"org.eclipse.cdt.core.default.config.1\""
-    " moduleId=\"org.eclipse.cdt.core.settings\" name=\"Configuration\">\n"
-    "<externalSettings/>\n"
-    "<extensions>\n"
-    ;
+  xml.StartElement("storageModule");
+  xml.Attribute("buildSystemId",
+      "org.eclipse.cdt.core.defaultConfigDataProvider");
+  xml.Attribute("id", "org.eclipse.cdt.core.default.config.1");
+  xml.Attribute("moduleId", "org.eclipse.cdt.core.settings");
+  xml.Attribute("name", "Configuration");
+  xml.Element("externalSettings");
+  xml.StartElement("extensions");
+
   // TODO: refactor this out...
   std::string executableFormat = mf->GetSafeDefinition(
                                                     "CMAKE_EXECUTABLE_FORMAT");
   if (executableFormat == "ELF")
     {
-    fout << "<extension id=\"org.eclipse.cdt.core.ELF\""
-            " point=\"org.eclipse.cdt.core.BinaryParser\"/>\n"
-            ;
-    fout << "<extension id=\"org.eclipse.cdt.core.GNU_ELF\""
-            " point=\"org.eclipse.cdt.core.BinaryParser\">\n"
-            "<attribute key=\"addr2line\" value=\"addr2line\"/>\n"
-            "<attribute key=\"c++filt\" value=\"c++filt\"/>\n"
-            "</extension>\n"
-            ;
+    xml.StartElement("extension");
+    xml.Attribute("id", "org.eclipse.cdt.core.ELF");
+    xml.Attribute("point", "org.eclipse.cdt.core.BinaryParser");
+    xml.EndElement(); // extension
+
+    xml.StartElement("extension");
+    xml.Attribute("id", "org.eclipse.cdt.core.GNU_ELF");
+    xml.Attribute("point", "org.eclipse.cdt.core.BinaryParser");
+    AppendAttribute(xml, "addr2line");
+    AppendAttribute(xml, "c++filt");
+    xml.EndElement(); // extension
     }
   else
     {
     std::string systemName = mf->GetSafeDefinition("CMAKE_SYSTEM_NAME");
     if (systemName == "CYGWIN")
       {
-      fout << "<extension id=\"org.eclipse.cdt.core.Cygwin_PE\""
-              " point=\"org.eclipse.cdt.core.BinaryParser\">\n"
-              "<attribute key=\"addr2line\" value=\"addr2line\"/>\n"
-              "<attribute key=\"c++filt\" value=\"c++filt\"/>\n"
-              "<attribute key=\"cygpath\" value=\"cygpath\"/>\n"
-              "<attribute key=\"nm\" value=\"nm\"/>\n"
-              "</extension>\n"
-              ;
+      xml.StartElement("extension");
+      xml.Attribute("id", "org.eclipse.cdt.core.Cygwin_PE");
+      xml.Attribute("point", "org.eclipse.cdt.core.BinaryParser");
+      AppendAttribute(xml, "addr2line");
+      AppendAttribute(xml, "c++filt");
+      AppendAttribute(xml, "cygpath");
+      AppendAttribute(xml, "nm");
+      xml.EndElement(); // extension
       }
     else if (systemName == "Windows")
       {
-      fout << "<extension id=\"org.eclipse.cdt.core.PE\""
-              " point=\"org.eclipse.cdt.core.BinaryParser\"/>\n"
-              ;
+      xml.StartElement("extension");
+      xml.Attribute("id", "org.eclipse.cdt.core.PE");
+      xml.Attribute("point", "org.eclipse.cdt.core.BinaryParser");
+      xml.EndElement(); // extension
       }
     else if (systemName == "Darwin")
       {
-      fout << "<extension id=\"" <<
-           (this->SupportsMachO64Parser ? "org.eclipse.cdt.core.MachO64"
-                                        : "org.eclipse.cdt.core.MachO") << "\""
-              " point=\"org.eclipse.cdt.core.BinaryParser\">\n"
-              "<attribute key=\"c++filt\" value=\"c++filt\"/>\n"
-              "</extension>\n"
-              ;
+      xml.StartElement("extension");
+      xml.Attribute("id",  this->SupportsMachO64Parser ?
+              "org.eclipse.cdt.core.MachO64" : "org.eclipse.cdt.core.MachO");
+      xml.Attribute("point", "org.eclipse.cdt.core.BinaryParser");
+      AppendAttribute(xml, "c++filt");
+      xml.EndElement(); // extension
       }
     else
       {
       // *** Should never get here ***
-      fout << "<error_toolchain_type/>\n";
+      xml.Element("error_toolchain_type");
       }
     }
 
-  fout << "</extensions>\n"
-          "</storageModule>\n"
-          ;
+  xml.EndElement(); // extensions
+  xml.EndElement(); // storageModule
 
   // ???
-  fout <<
-    "<storageModule moduleId=\"org.eclipse.cdt.core.language.mapping\">\n"
-    "<project-mappings/>\n"
-    "</storageModule>\n"
-    ;
+  xml.StartElement("storageModule");
+  xml.Attribute("moduleId", "org.eclipse.cdt.core.language.mapping");
+  xml.Element("project-mappings");
+  xml.EndElement(); // storageModule
 
   // ???
-  fout<<"<storageModule moduleId=\"org.eclipse.cdt.core.externalSettings\"/>\n"
-          ;
+  xml.StartElement("storageModule");
+  xml.Attribute("moduleId", "org.eclipse.cdt.core.externalSettings");
+  xml.EndElement(); // storageModule
 
   // set the path entries (includes, libs, source dirs, etc.)
-  fout << "<storageModule moduleId=\"org.eclipse.cdt.core.pathentry\">\n"
-          ;
+  xml.StartElement("storageModule");
+  xml.Attribute("moduleId", "org.eclipse.cdt.core.pathentry");
+
   // for each sub project with a linked resource to the source dir:
   // - make it type 'src'
   // - and exclude it from type 'out'
@@ -824,21 +772,27 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
        it != this->SrcLinkedResources.end();
        ++it)
     {
-    fout << "<pathentry kind=\"src\" path=\"" << this->EscapeForXML(*it)
-         << "\"/>\n";
+    xml.StartElement("pathentry");
+    xml.Attribute("kind", "src");
+    xml.Attribute("path", *it);
+    xml.EndElement();
 
     // exlude source directory from output search path
     // - only if not named the same as an output directory
     if (!cmSystemTools::FileIsDirectory(
            std::string(this->HomeOutputDirectory + "/" + *it)))
       {
-      excludeFromOut += this->EscapeForXML(*it) + "/|";
+      excludeFromOut += *it + "/|";
       }
     }
 
   excludeFromOut += "**/CMakeFiles/";
-  fout << "<pathentry excluding=\"" << excludeFromOut
-       << "\" kind=\"out\" path=\"\"/>\n";
+
+  xml.StartElement("pathentry");
+  xml.Attribute("excluding", excludeFromOut);
+  xml.Attribute("kind", "out");
+  xml.Attribute("path", "");
+  xml.EndElement();
 
   // add pre-processor definitions to allow eclipse to gray out sections
   emmited.clear();
@@ -884,9 +838,12 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
         if(emmited.find(def) == emmited.end())
           {
           emmited.insert(def);
-          fout << "<pathentry kind=\"mac\" name=\"" << def
-               << "\" path=\"\" value=\"" << this->EscapeForXML(val)
-               << "\"/>\n";
+          xml.StartElement("pathentry");
+          xml.Attribute("kind", "mac");
+          xml.Attribute("name", def);
+          xml.Attribute("path", "");
+          xml.Attribute("value", val);
+          xml.EndElement();
           }
         }
       }
@@ -919,9 +876,12 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
         if(emmited.find(def) == emmited.end())
           {
           emmited.insert(def);
-          fout << "<pathentry kind=\"mac\" name=\"" << def
-               << "\" path=\"\" value=\"" << this->EscapeForXML(val)
-               << "\"/>\n";
+          xml.StartElement("pathentry");
+          xml.Attribute("kind", "mac");
+          xml.Attribute("name", def);
+          xml.Attribute("path", "");
+          xml.Attribute("value", val);
+          xml.EndElement();
           }
         }
       }
@@ -954,9 +914,12 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
         if(emmited.find(def) == emmited.end())
           {
           emmited.insert(def);
-          fout << "<pathentry kind=\"mac\" name=\"" << def
-               << "\" path=\"\" value=\"" << this->EscapeForXML(val)
-               << "\"/>\n";
+          xml.StartElement("pathentry");
+          xml.Attribute("kind", "mac");
+          xml.Attribute("name", def);
+          xml.Attribute("path", "");
+          xml.Attribute("value", val);
+          xml.EndElement();
           }
         }
       }
@@ -976,7 +939,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
       std::vector<std::string> includeDirs;
       std::string config = mf->GetSafeDefinition("CMAKE_BUILD_TYPE");
       (*it)->GetIncludeDirectories(includeDirs, *l, "C", config);
-      this->AppendIncludeDirectories(fout, includeDirs, emmited);
+      this->AppendIncludeDirectories(xml, includeDirs, emmited);
       }
     }
   // now also the system include directories, in case we found them in
@@ -989,7 +952,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
                                 "CMAKE_EXTRA_GENERATOR_C_SYSTEM_INCLUDE_DIRS");
     std::vector<std::string> dirs;
     cmSystemTools::ExpandListArgument(systemIncludeDirs, dirs);
-    this->AppendIncludeDirectories(fout, dirs, emmited);
+    this->AppendIncludeDirectories(xml, dirs, emmited);
     }
   compiler = mf->GetSafeDefinition("CMAKE_CXX_COMPILER");
   if (this->CXXEnabled && !compiler.empty())
@@ -998,16 +961,15 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
                               "CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_INCLUDE_DIRS");
     std::vector<std::string> dirs;
     cmSystemTools::ExpandListArgument(systemIncludeDirs, dirs);
-    this->AppendIncludeDirectories(fout, dirs, emmited);
+    this->AppendIncludeDirectories(xml, dirs, emmited);
     }
 
-  fout << "</storageModule>\n";
+  xml.EndElement(); // storageModule
 
   // add build targets
-  fout <<
-    "<storageModule moduleId=\"org.eclipse.cdt.make.core.buildtargets\">\n"
-    "<buildTargets>\n"
-    ;
+  xml.StartElement("storageModule");
+  xml.Attribute("moduleId", "org.eclipse.cdt.make.core.buildtargets");
+  xml.StartElement("buildTargets");
   emmited.clear();
   const std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
   const std::string makeArgs = mf->GetSafeDefinition(
@@ -1055,7 +1017,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
           // not from the subdirs
           if (subdir.empty())
            {
-           this->AppendTarget(fout, targetName, make, makeArgs, subdir, ": ");
+           this->AppendTarget(xml, targetName, make, makeArgs, subdir, ": ");
            }
          }
          break;
@@ -1070,7 +1032,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
            break;
            }
 
-         this->AppendTarget(fout, targetName, make, makeArgs, subdir, ": ");
+         this->AppendTarget(xml, targetName, make, makeArgs, subdir, ": ");
          break;
        case cmState::EXECUTABLE:
        case cmState::STATIC_LIBRARY:
@@ -1080,10 +1042,10 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
          {
          const char* prefix = ((*ti)->GetType()==cmState::EXECUTABLE ?
                                                           "[exe] " : "[lib] ");
-         this->AppendTarget(fout, targetName, make, makeArgs, subdir, prefix);
+         this->AppendTarget(xml, targetName, make, makeArgs, subdir, prefix);
          std::string fastTarget = targetName;
          fastTarget += "/fast";
-         this->AppendTarget(fout, fastTarget, make, makeArgs, subdir, prefix);
+         this->AppendTarget(xml, fastTarget, make, makeArgs, subdir, prefix);
 
          // Add Build and Clean targets in the virtual folder of targets:
          if (this->SupportsVirtualFolders)
@@ -1095,7 +1057,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
           buildArgs += (*it)->GetBinaryDirectory();
           buildArgs += "\" ";
           buildArgs += makeArgs;
-          this->AppendTarget(fout, "Build", make, buildArgs, virtDir, "",
+          this->AppendTarget(xml, "Build", make, buildArgs, virtDir, "",
                              targetName.c_str());
 
           std::string cleanArgs = "-E chdir \"";
@@ -1106,7 +1068,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
           cmGeneratorTarget* gt = *ti;
           cleanArgs += (*it)->GetTargetDirectory(gt);
           cleanArgs += "/cmake_clean.cmake\"";
-          this->AppendTarget(fout, "Clean", cmSystemTools::GetCMakeCommand(),
+          this->AppendTarget(xml, "Clean", cmSystemTools::GetCMakeCommand(),
                              cleanArgs, virtDir, "", "");
           }
          }
@@ -1119,11 +1081,11 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
     // insert the all and clean targets in every subdir
     if (!allTarget.empty())
       {
-      this->AppendTarget(fout, allTarget, make, makeArgs, subdir, ": ");
+      this->AppendTarget(xml, allTarget, make, makeArgs, subdir, ": ");
       }
     if (!cleanTarget.empty())
       {
-      this->AppendTarget(fout, cleanTarget, make, makeArgs, subdir, ": ");
+      this->AppendTarget(xml, cleanTarget, make, makeArgs, subdir, ": ");
       }
 
     //insert rules for compiling, preprocessing and assembling individual files
@@ -1142,25 +1104,29 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
         {
         prefix = "[pre] ";
         }
-      this->AppendTarget(fout, *fit, make, makeArgs, subdir, prefix);
+      this->AppendTarget(xml, *fit, make, makeArgs, subdir, prefix);
       }
     }
 
-  fout << "</buildTargets>\n"
-          "</storageModule>\n"
-          ;
-
-  this->AppendStorageScanners(fout, *mf);
-
-  fout << "</cconfiguration>\n"
-          "</storageModule>\n"
-          "<storageModule moduleId=\"cdtBuildSystem\" version=\"4.0.0\">\n"
-          "<project id=\"" << this->EscapeForXML(lg->GetProjectName())
-       << ".null.1\" name=\"" << this->EscapeForXML(lg->GetProjectName())
-       << "\"/>\n"
-          "</storageModule>\n"
-          "</cproject>\n"
-          ;
+  xml.EndElement(); // buildTargets
+  xml.EndElement(); // storageModule
+
+  this->AppendStorageScanners(xml, *mf);
+
+  xml.EndElement(); // cconfiguration
+  xml.EndElement(); // storageModule
+
+  xml.StartElement("storageModule");
+  xml.Attribute("moduleId", "cdtBuildSystem");
+  xml.Attribute("version", "4.0.0");
+
+  xml.StartElement("project");
+  xml.Attribute("id", std::string(lg->GetProjectName()) + ".null.1");
+  xml.Attribute("name", lg->GetProjectName());
+  xml.EndElement(); // project
+
+  xml.EndElement(); // storageModule
+  xml.EndElement(); // cproject
 }
 
 //----------------------------------------------------------------------------
@@ -1208,28 +1174,14 @@ cmExtraEclipseCDT4Generator::GenerateProjectName(const std::string& name,
                                                  const std::string& type,
                                                  const std::string& path)
 {
-  return cmExtraEclipseCDT4Generator::EscapeForXML(name)
-                                +(type.empty() ? "" : "-") + type + "@" + path;
-}
-
-std::string cmExtraEclipseCDT4Generator::EscapeForXML(const std::string& value)
-{
-  std::string str = value;
-  cmSystemTools::ReplaceString(str, "&", "&amp;");
-  cmSystemTools::ReplaceString(str, "<", "&lt;");
-  cmSystemTools::ReplaceString(str, ">", "&gt;");
-  cmSystemTools::ReplaceString(str, "\"", "&quot;");
-  // NOTE: This one is not necessary, since as of Eclipse CDT4 it will
-  //       automatically change this to the original value (').
-  //cmSystemTools::ReplaceString(str, "'", "&apos;");
-  return str;
+  return name + (type.empty() ? "" : "-") + type + "@" + path;
 }
 
 //----------------------------------------------------------------------------
 // Helper functions
 //----------------------------------------------------------------------------
 void cmExtraEclipseCDT4Generator
-::AppendStorageScanners(cmGeneratedFileStream& fout,
+::AppendStorageScanners(cmXMLWriter& xml,
                         const cmMakefile& makefile)
 {
   // we need the "make" and the C (or C++) compiler which are used, Alex
@@ -1255,24 +1207,28 @@ void cmExtraEclipseCDT4Generator
     compilerArgs = arg1 + compilerArgs;
     }
 
-  fout <<
-    "<storageModule moduleId=\"scannerConfiguration\">\n"
-    "<autodiscovery enabled=\"true\" problemReportingEnabled=\"true\""
-    " selectedProfileId="
-    "\"org.eclipse.cdt.make.core.GCCStandardMakePerProjectProfile\"/>\n"
-    ;
-  cmExtraEclipseCDT4Generator::AppendScannerProfile(fout,
+  xml.StartElement("storageModule");
+  xml.Attribute("moduleId", "scannerConfiguration");
+
+  xml.StartElement("autodiscovery");
+  xml.Attribute("enabled", "true");
+  xml.Attribute("problemReportingEnabled", "true");
+  xml.Attribute("selectedProfileId",
+      "org.eclipse.cdt.make.core.GCCStandardMakePerProjectProfile");
+  xml.EndElement(); // autodiscovery
+
+  cmExtraEclipseCDT4Generator::AppendScannerProfile(xml,
     "org.eclipse.cdt.make.core.GCCStandardMakePerProjectProfile",
     true, "", true, "specsFile",
     compilerArgs,
     compiler, true, true);
-  cmExtraEclipseCDT4Generator::AppendScannerProfile(fout,
+  cmExtraEclipseCDT4Generator::AppendScannerProfile(xml,
     "org.eclipse.cdt.make.core.GCCStandardMakePerFileProfile",
     true, "", true, "makefileGenerator",
     "-f ${project_name}_scd.mk",
     make, true, true);
 
-  fout << "</storageModule>\n";
+  xml.EndElement(); // storageModule
 }
 
 // The prefix is prepended before the actual name of the target. The purpose
@@ -1283,7 +1239,7 @@ void cmExtraEclipseCDT4Generator
 // finally the assembly files "[to asm] ". Note the "to" in "to asm",
 // without it, "asm" would be the first targets in the list, with the "to"
 // they are the last targets, which makes more sense.
-void cmExtraEclipseCDT4Generator::AppendTarget(cmGeneratedFileStream& fout,
+void cmExtraEclipseCDT4Generator::AppendTarget(cmXMLWriter& xml,
                                                const std::string&     target,
                                                const std::string&     make,
                                                const std::string&     makeArgs,
@@ -1292,31 +1248,21 @@ void cmExtraEclipseCDT4Generator::AppendTarget(cmGeneratedFileStream& fout,
                                                const char* makeTarget
                                               )
 {
-  std::string targetXml = cmExtraEclipseCDT4Generator::EscapeForXML(target);
-  std::string makeTargetXml = targetXml;
-  if (makeTarget != NULL)
-    {
-    makeTargetXml = cmExtraEclipseCDT4Generator::EscapeForXML(makeTarget);
-    }
-  cmExtraEclipseCDT4Generator::EscapeForXML(target);
-  std::string pathXml = cmExtraEclipseCDT4Generator::EscapeForXML(path);
-  fout <<
-    "<target name=\"" << prefix << targetXml << "\""
-    " path=\"" << pathXml << "\""
-    " targetID=\"org.eclipse.cdt.make.MakeTargetBuilder\">\n"
-    "<buildCommand>"
-    << cmExtraEclipseCDT4Generator::GetEclipsePath(make)
-    << "</buildCommand>\n"
-    "<buildArguments>"  << makeArgs << "</buildArguments>\n"
-    "<buildTarget>" << makeTargetXml << "</buildTarget>\n"
-    "<stopOnError>true</stopOnError>\n"
-    "<useDefaultCommand>false</useDefaultCommand>\n"
-    "</target>\n"
-    ;
+  xml.StartElement("target");
+  xml.Attribute("name", prefix + target);
+  xml.Attribute("path", path);
+  xml.Attribute("targetID", "org.eclipse.cdt.make.MakeTargetBuilder");
+  xml.Element("buildCommand",
+      cmExtraEclipseCDT4Generator::GetEclipsePath(make));
+  xml.Element("buildArguments", makeArgs);
+  xml.Element("buildTarget", makeTarget ? makeTarget : target.c_str());
+  xml.Element("stopOnError", "true");
+  xml.Element("useDefaultCommand", "false");
+  xml.EndElement();
 }
 
 void cmExtraEclipseCDT4Generator
-::AppendScannerProfile(cmGeneratedFileStream& fout,
+::AppendScannerProfile(cmXMLWriter& xml,
                        const std::string&     profileID,
                        bool                   openActionEnabled,
                        const std::string&     openActionFilePath,
@@ -1327,49 +1273,54 @@ void cmExtraEclipseCDT4Generator
                        bool                   runActionUseDefault,
                        bool                   sipParserEnabled)
 {
-  fout <<
-    "<profile id=\"" << profileID << "\">\n"
-    "<buildOutputProvider>\n"
-    "<openAction enabled=\"" << (openActionEnabled ? "true" : "false")
-    << "\" filePath=\"" << openActionFilePath << "\"/>\n"
-    "<parser enabled=\"" << (pParserEnabled ? "true" : "false") << "\"/>\n"
-    "</buildOutputProvider>\n"
-    "<scannerInfoProvider id=\"" << scannerInfoProviderID << "\">\n"
-    "<runAction arguments=\"" << runActionArguments << "\""
-    " command=\"" << runActionCommand
-    << "\" useDefault=\"" << (runActionUseDefault ? "true":"false") << "\"/>\n"
-    "<parser enabled=\"" << (sipParserEnabled ? "true" : "false") << "\"/>\n"
-    "</scannerInfoProvider>\n"
-    "</profile>\n"
-    ;
+  xml.StartElement("profile");
+  xml.Attribute("id", profileID);
+
+  xml.StartElement("buildOutputProvider");
+  xml.StartElement("openAction");
+  xml.Attribute("enabled", openActionEnabled ? "true" : "false");
+  xml.Attribute("filePath", openActionFilePath);
+  xml.EndElement(); // openAction
+  xml.StartElement("parser");
+  xml.Attribute("enabled", pParserEnabled ? "true" : "false");
+  xml.EndElement(); // parser
+  xml.EndElement(); // buildOutputProvider
+
+  xml.StartElement("scannerInfoProvider");
+  xml.Attribute("id", scannerInfoProviderID);
+  xml.StartElement("runAction");
+  xml.Attribute("arguments", runActionArguments);
+  xml.Attribute("command", runActionCommand);
+  xml.Attribute("useDefault", runActionUseDefault ? "true" : "false");
+  xml.EndElement(); // runAction
+  xml.StartElement("parser");
+  xml.Attribute("enabled", sipParserEnabled ? "true" : "false");
+  xml.EndElement(); // parser
+  xml.EndElement(); // scannerInfoProvider
+
+  xml.EndElement(); // profile
 }
 
 void cmExtraEclipseCDT4Generator
-::AppendLinkedResource (cmGeneratedFileStream& fout,
+::AppendLinkedResource (cmXMLWriter& xml,
                         const std::string&     name,
                         const std::string&     path,
                         LinkType linkType)
 {
   const char* locationTag = "location";
-  const char* typeTag = "2";
+  int typeTag = 2;
   if (linkType == VirtualFolder) // ... and not a linked folder
     {
     locationTag = "locationURI";
     }
   if (linkType == LinkToFile)
     {
-    typeTag = "1";
+    typeTag = 1;
     }
 
-  fout <<
-    "\t\t<link>\n"
-    "\t\t\t<name>"
-    << cmExtraEclipseCDT4Generator::EscapeForXML(name)
-    << "</name>\n"
-    "\t\t\t<type>" << typeTag << "</type>\n"
-    "\t\t\t<" << locationTag << ">"
-    << cmExtraEclipseCDT4Generator::EscapeForXML(path)
-    << "</" << locationTag << ">\n"
-    "\t\t</link>\n"
-    ;
+  xml.StartElement("link");
+  xml.Element("name", name);
+  xml.Element("type", typeTag);
+  xml.Element(locationTag, path);
+  xml.EndElement();
 }
diff --git a/Source/cmExtraEclipseCDT4Generator.h b/Source/cmExtraEclipseCDT4Generator.h
index 1da2077..4032a6c 100644
--- a/Source/cmExtraEclipseCDT4Generator.h
+++ b/Source/cmExtraEclipseCDT4Generator.h
@@ -17,7 +17,7 @@
 #include "cmExternalMakefileProjectGenerator.h"
 
 class cmMakefile;
-class cmGeneratedFileStream;
+class cmXMLWriter;
 
 /** \class cmExtraEclipseCDT4Generator
  * \brief Write Eclipse project files for Makefile based projects
@@ -67,19 +67,17 @@ private:
                                          const std::string& type,
                                          const std::string& path);
 
-  static std::string EscapeForXML(const std::string& value);
-
   // Helper functions
-  static void AppendStorageScanners(cmGeneratedFileStream& fout,
+  static void AppendStorageScanners(cmXMLWriter& xml,
                                     const cmMakefile& makefile);
-  static void AppendTarget         (cmGeneratedFileStream& fout,
+  static void AppendTarget         (cmXMLWriter& xml,
                                     const std::string&     target,
                                     const std::string&     make,
                                     const std::string&     makeArguments,
                                     const std::string&     path,
                                     const char* prefix = "",
                                     const char* makeTarget = NULL);
-  static void AppendScannerProfile (cmGeneratedFileStream& fout,
+  static void AppendScannerProfile (cmXMLWriter& xml,
                                     const std::string&   profileID,
                                     bool                 openActionEnabled,
                                     const std::string&   openActionFilePath,
@@ -90,21 +88,20 @@ private:
                                     bool                 runActionUseDefault,
                                     bool                 sipParserEnabled);
 
-  static void AppendLinkedResource (cmGeneratedFileStream& fout,
+  static void AppendLinkedResource (cmXMLWriter& xml,
                                     const std::string&     name,
                                     const std::string&     path,
                                     LinkType linkType);
 
-  static void AppendIncludeDirectories(cmGeneratedFileStream& fout,
+  static void AppendIncludeDirectories(cmXMLWriter& xml,
                                    const std::vector<std::string>& includeDirs,
                                    std::set<std::string>& emittedDirs);
 
-  static void AddEnvVar(cmGeneratedFileStream& fout, const char* envVar,
+  static void AddEnvVar(std::ostream& out, const char* envVar,
                         cmLocalGenerator* lg);
 
-  void CreateLinksToSubprojects(cmGeneratedFileStream& fout,
-                                const std::string& baseDir);
-  void CreateLinksForTargets(cmGeneratedFileStream& fout);
+  void CreateLinksToSubprojects(cmXMLWriter& xml, const std::string& baseDir);
+  void CreateLinksForTargets(cmXMLWriter& xml);
 
   std::vector<std::string> SrcLinkedResources;
   std::set<std::string> Natures;
-- 
cgit v0.12


From 51465da1ec9e519c69240ebb810df3fce4c1292e Mon Sep 17 00:00:00 2001
From: Daniel Pfeifer <daniel@pfeifer-mail.de>
Date: Thu, 16 Jul 2015 21:53:57 +0200
Subject: CPack/IFW: port to cmXMLWriter

---
 Source/CPack/IFW/cmCPackIFWGenerator.cxx | 15 +++---
 Source/CPack/IFW/cmCPackIFWGenerator.h   |  5 +-
 Source/CPack/IFW/cmCPackIFWInstaller.cxx | 89 +++++++++++++-------------------
 Source/CPack/IFW/cmCPackIFWInstaller.h   |  4 +-
 Source/CPack/IFW/cmCPackIFWPackage.cxx   | 67 +++++++++++-------------
 Source/CPack/IFW/cmCPackIFWPackage.h     |  4 +-
 6 files changed, 81 insertions(+), 103 deletions(-)

diff --git a/Source/CPack/IFW/cmCPackIFWGenerator.cxx b/Source/CPack/IFW/cmCPackIFWGenerator.cxx
index 4eb23c1..50ac971 100644
--- a/Source/CPack/IFW/cmCPackIFWGenerator.cxx
+++ b/Source/CPack/IFW/cmCPackIFWGenerator.cxx
@@ -27,7 +27,7 @@
 #include <cmSystemTools.h>
 #include <cmMakefile.h>
 #include <cmGeneratedFileStream.h>
-#include <cmXMLSafe.h>
+#include <cmXMLWriter.h>
 #include <cmVersionConfig.h>
 #include <cmTimestamp.h>
 
@@ -611,18 +611,19 @@ cmCPackIFWPackage* cmCPackIFWGenerator::GetComponentPackage(
 }
 
 //----------------------------------------------------------------------------
-void cmCPackIFWGenerator::WriteGeneratedByToStrim(cmGeneratedFileStream &xout)
+void cmCPackIFWGenerator::WriteGeneratedByToStrim(cmXMLWriter &xout)
 {
-  xout << "<!-- Generated by CPack " << CMake_VERSION << " IFW generator "
+  std::stringstream comment;
+  comment << "Generated by CPack " << CMake_VERSION << " IFW generator "
        << "for QtIFW ";
   if(IsVersionLess("2.0"))
     {
-    xout << "less 2.0";
+    comment << "less 2.0";
     }
   else
     {
-    xout << FrameworkVersion;
+    comment << FrameworkVersion;
     }
-  xout << " tools at " << cmTimestamp().CurrentTime("", true) << " -->"
-       << std::endl;
+  comment << " tools at " << cmTimestamp().CurrentTime("", true);
+  xout.Comment(comment.str().c_str());
 }
diff --git a/Source/CPack/IFW/cmCPackIFWGenerator.h b/Source/CPack/IFW/cmCPackIFWGenerator.h
index 3246861..5770451 100644
--- a/Source/CPack/IFW/cmCPackIFWGenerator.h
+++ b/Source/CPack/IFW/cmCPackIFWGenerator.h
@@ -13,12 +13,13 @@
 #ifndef cmCPackIFWGenerator_h
 #define cmCPackIFWGenerator_h
 
-#include <cmGeneratedFileStream.h>
 #include <CPack/cmCPackGenerator.h>
 
 #include "cmCPackIFWPackage.h"
 #include "cmCPackIFWInstaller.h"
 
+class cmXMLWriter;
+
 /** \class cmCPackIFWGenerator
  * \brief A generator for Qt Installer Framework tools
  *
@@ -121,7 +122,7 @@ protected: // Methods
   cmCPackIFWPackage* GetGroupPackage(cmCPackComponentGroup *group) const;
   cmCPackIFWPackage* GetComponentPackage(cmCPackComponent *component) const;
 
-  void WriteGeneratedByToStrim(cmGeneratedFileStream& xout);
+  void WriteGeneratedByToStrim(cmXMLWriter& xout);
 
 protected: // Data
 
diff --git a/Source/CPack/IFW/cmCPackIFWInstaller.cxx b/Source/CPack/IFW/cmCPackIFWInstaller.cxx
index 8c77a2c..224d606 100644
--- a/Source/CPack/IFW/cmCPackIFWInstaller.cxx
+++ b/Source/CPack/IFW/cmCPackIFWInstaller.cxx
@@ -17,7 +17,7 @@
 #include <CPack/cmCPackLog.h>
 
 #include <cmGeneratedFileStream.h>
-#include <cmXMLSafe.h>
+#include <cmXMLWriter.h>
 
 #ifdef cmCPackLogger
 # undef cmCPackLogger
@@ -334,30 +334,27 @@ void cmCPackIFWInstaller::GenerateInstallerFile()
     }
 
   // Output stream
-  cmGeneratedFileStream xout((Directory + "/config/config.xml").data());
+  cmGeneratedFileStream fout((Directory + "/config/config.xml").data());
+  cmXMLWriter xout(fout);
 
-  xout << "<?xml version=\"1.0\"?>" << std::endl;
+  xout.StartDocument();
 
   WriteGeneratedByToStrim(xout);
 
-  xout << "<Installer>" << std::endl;
+  xout.StartElement("Installer");
 
-  xout << "    <Name>" << cmXMLSafe(Name).str() << "</Name>" << std::endl;
-
-  xout << "    <Version>" << Version << "</Version>" << std::endl;
-
-  xout << "    <Title>" << cmXMLSafe(Title).str() << "</Title>"
-       << std::endl;
+  xout.Element("Name", Name);
+  xout.Element("Version", Version);
+  xout.Element("Title", Title);
 
   if(!Publisher.empty())
     {
-    xout << "    <Publisher>" << cmXMLSafe(Publisher).str()
-         << "</Publisher>" << std::endl;
+    xout.Element("Publisher", Publisher);
     }
 
   if(!ProductUrl.empty())
     {
-    xout << "    <ProductUrl>" << ProductUrl << "</ProductUrl>" << std::endl;
+    xout.Element("ProductUrl", ProductUrl);
     }
 
   // ApplicationIcon
@@ -369,8 +366,7 @@ void cmCPackIFWInstaller::GenerateInstallerFile()
     name = cmSystemTools::GetFilenameWithoutExtension(name);
     cmsys::SystemTools::CopyFileIfDifferent(
       InstallerApplicationIcon.data(), path.data());
-    xout << "    <InstallerApplicationIcon>" << name
-         << "</InstallerApplicationIcon>" << std::endl;
+    xout.Element("InstallerApplicationIcon", name);
     }
 
   // WindowIcon
@@ -380,8 +376,7 @@ void cmCPackIFWInstaller::GenerateInstallerFile()
     std::string path = Directory + "/config/" + name;
     cmsys::SystemTools::CopyFileIfDifferent(
       InstallerWindowIcon.data(), path.data());
-    xout << "    <InstallerWindowIcon>" << name
-         << "</InstallerWindowIcon>" << std::endl;
+    xout.Element("InstallerWindowIcon", name);
     }
 
   // Logo
@@ -390,104 +385,91 @@ void cmCPackIFWInstaller::GenerateInstallerFile()
     std::string name = cmSystemTools::GetFilenameName(Logo);
     std::string path = Directory + "/config/" + name;
     cmsys::SystemTools::CopyFileIfDifferent(Logo.data(), path.data());
-    xout << "    <Logo>" << name << "</Logo>" << std::endl;
+    xout.Element("Logo", name);
     }
 
   // Start menu
   if(!IsVersionLess("2.0"))
     {
-    xout << "    <StartMenuDir>" << StartMenuDir
-         << "</StartMenuDir>" << std::endl;
+    xout.Element("StartMenuDir", StartMenuDir);
     }
 
   // Target dir
   if(!TargetDir.empty())
     {
-    xout << "    <TargetDir>" << TargetDir << "</TargetDir>" << std::endl;
+    xout.Element("TargetDir", TargetDir);
     }
 
   // Admin target dir
   if(!AdminTargetDir.empty())
     {
-    xout << "    <AdminTargetDir>" << AdminTargetDir
-         << "</AdminTargetDir>" << std::endl;
+    xout.Element("AdminTargetDir", AdminTargetDir);
     }
 
   // Remote repositories
   if (!Repositories.empty())
     {
-    xout << "    <RemoteRepositories>" << std::endl;
+    xout.StartElement("RemoteRepositories");
     for(std::vector<RepositoryStruct>::iterator
         rit = Repositories.begin(); rit != Repositories.end(); ++rit)
       {
-      xout << "        <Repository>" << std::endl;
+      xout.StartElement("Repository");
       // Url
-      xout << "            <Url>" << rit->Url
-           << "</Url>" << std::endl;
+      xout.Element("Url", rit->Url);
       // Enabled
       if(!rit->Enabled.empty())
         {
-        xout << "            <Enabled>" << rit->Enabled
-             << "</Enabled>" << std::endl;
+        xout.Element("Enabled", rit->Enabled);
         }
       // Username
       if(!rit->Username.empty())
         {
-        xout << "            <Username>" << rit->Username
-             << "</Username>" << std::endl;
+        xout.Element("Username", rit->Username);
         }
       // Password
       if(!rit->Password.empty())
         {
-        xout << "            <Password>" << rit->Password
-             << "</Password>" << std::endl;
+        xout.Element("Password", rit->Password);
         }
       // DisplayName
       if(!rit->DisplayName.empty())
         {
-        xout << "            <DisplayName>" << rit->DisplayName
-             << "</DisplayName>" << std::endl;
+        xout.Element("DisplayName", rit->DisplayName);
         }
-      xout << "        </Repository>" << std::endl;
+      xout.EndElement();
       }
-    xout << "    </RemoteRepositories>" << std::endl;
+    xout.EndElement();
     }
 
   // Maintenance tool
   if(!IsVersionLess("2.0") && !MaintenanceToolName.empty())
     {
-    xout << "    <MaintenanceToolName>" << MaintenanceToolName
-         << "</MaintenanceToolName>" << std::endl;
+    xout.Element("MaintenanceToolName", MaintenanceToolName);
     }
 
   // Maintenance tool ini file
   if(!IsVersionLess("2.0") && !MaintenanceToolIniFile.empty())
     {
-    xout << "    <MaintenanceToolIniFile>" << MaintenanceToolIniFile
-         << "</MaintenanceToolIniFile>" << std::endl;
+    xout.Element("MaintenanceToolIniFile", MaintenanceToolIniFile);
     }
 
   // Different allows
   if(IsVersionLess("2.0"))
     {
     // CPack IFW default policy
-    xout << "    <!-- CPack IFW default policy for QtIFW less 2.0 -->"
-         << std::endl;
-    xout << "    <AllowNonAsciiCharacters>true</AllowNonAsciiCharacters>"
-         << std::endl;
-    xout << "    <AllowSpaceInPath>true</AllowSpaceInPath>" << std::endl;
+    xout.Comment("CPack IFW default policy for QtIFW less 2.0");
+    xout.Element("AllowNonAsciiCharacters", "true");
+    xout.Element("AllowSpaceInPath", "true");
     }
   else
     {
       if(!AllowNonAsciiCharacters.empty())
         {
-        xout << "    <AllowNonAsciiCharacters>" << AllowNonAsciiCharacters
-             << "</AllowNonAsciiCharacters>" << std::endl;
+        xout.Element("AllowNonAsciiCharacters", AllowNonAsciiCharacters);
         }
       if(!AllowSpaceInPath.empty())
         {
-        xout << "    <AllowAllowSpaceInPath>" << AllowSpaceInPath
-             << "</AllowSpaceInPath>" << std::endl;
+        xout.Element("AllowSpaceInPath", AllowSpaceInPath);
         }
     }
 
@@ -497,10 +479,11 @@ void cmCPackIFWInstaller::GenerateInstallerFile()
     std::string name = cmSystemTools::GetFilenameName(ControlScript);
     std::string path = Directory + "/config/" + name;
     cmsys::SystemTools::CopyFileIfDifferent(ControlScript.data(), path.data());
-    xout << "    <ControlScript>" << name << "</ControlScript>" << std::endl;
+    xout.Element("ControlScript", name);
     }
 
-  xout << "</Installer>" << std::endl;
+  xout.EndElement();
+  xout.EndDocument();
 }
 
 //----------------------------------------------------------------------------
@@ -535,7 +518,7 @@ void cmCPackIFWInstaller::GeneratePackageFiles()
   }
 }
 
-void cmCPackIFWInstaller::WriteGeneratedByToStrim(cmGeneratedFileStream &xout)
+void cmCPackIFWInstaller::WriteGeneratedByToStrim(cmXMLWriter &xout)
 {
   if(Generator) Generator->WriteGeneratedByToStrim(xout);
 }
diff --git a/Source/CPack/IFW/cmCPackIFWInstaller.h b/Source/CPack/IFW/cmCPackIFWInstaller.h
index 4cba5b2..04050c0 100644
--- a/Source/CPack/IFW/cmCPackIFWInstaller.h
+++ b/Source/CPack/IFW/cmCPackIFWInstaller.h
@@ -13,11 +13,11 @@
 #ifndef cmCPackIFWInstaller_h
 #define cmCPackIFWInstaller_h
 
-#include <cmGeneratedFileStream.h>
 #include <cmStandardIncludes.h>
 
 class cmCPackIFWPackage;
 class cmCPackIFWGenerator;
+class cmXMLWriter;
 
 /** \class cmCPackIFWInstaller
  * \brief A binary installer to be created CPack IFW generator
@@ -115,7 +115,7 @@ public: // Internal implementation
   std::string Directory;
 
 protected:
-  void WriteGeneratedByToStrim(cmGeneratedFileStream& xout);
+  void WriteGeneratedByToStrim(cmXMLWriter& xout);
 };
 
 #endif // cmCPackIFWInstaller_h
diff --git a/Source/CPack/IFW/cmCPackIFWPackage.cxx b/Source/CPack/IFW/cmCPackIFWPackage.cxx
index 5474ad1b..b71c7e3 100644
--- a/Source/CPack/IFW/cmCPackIFWPackage.cxx
+++ b/Source/CPack/IFW/cmCPackIFWPackage.cxx
@@ -18,6 +18,7 @@
 
 #include <cmGeneratedFileStream.h>
 #include <cmTimestamp.h>
+#include <cmXMLWriter.h>
 
 //----------------------------------------------------------------- Logger ---
 #ifdef cmCPackLogger
@@ -447,35 +448,28 @@ void cmCPackIFWPackage::GeneratePackageFile()
     }
 
   // Output stream
-  cmGeneratedFileStream xout((Directory + "/meta/package.xml").data());
+  cmGeneratedFileStream fout((Directory + "/meta/package.xml").data());
+  cmXMLWriter xout(fout);
 
-  xout << "<?xml version=\"1.0\"?>" << std::endl;
+  xout.StartDocument();
 
   WriteGeneratedByToStrim(xout);
 
-  xout << "<Package>" << std::endl;
+  xout.StartElement("Package");
 
-  xout << "    <DisplayName>" << DisplayName
-       << "</DisplayName>" << std::endl;
+  xout.Element("DisplayName", DisplayName);
+  xout.Element("Description", Description);
+  xout.Element("Name", Name);
+  xout.Element("Version", Version);
 
-  xout << "    <Description>" << Description
-       << "</Description>" << std::endl;
-
-  xout << "    <Name>" << Name << "</Name>" << std::endl;
-
-  xout << "    <Version>" <<  Version
-       << "</Version>" << std::endl;
-
-  xout << "    <ReleaseDate>";
-  if(ReleaseDate.empty())
+  if (!ReleaseDate.empty())
     {
-    xout << cmTimestamp().CurrentTime("%Y-%m-%d", true);
+    xout.Element("ReleaseDate", ReleaseDate);
     }
   else
     {
-    xout << ReleaseDate;
+    xout.Element("ReleaseDate", cmTimestamp().CurrentTime("%Y-%m-%d", true));
     }
-  xout << "</ReleaseDate>" << std::endl;
 
   // Script (copy to meta dir)
   if(!Script.empty())
@@ -483,7 +477,7 @@ void cmCPackIFWPackage::GeneratePackageFile()
     std::string name = cmSystemTools::GetFilenameName(Script);
     std::string path = Directory + "/meta/" + name;
     cmsys::SystemTools::CopyFileIfDifferent(Script.data(), path.data());
-    xout << "    <Script>" << name << "</Script>" << std::endl;
+    xout.Element("Script", name);
     }
 
   // Dependencies
@@ -501,16 +495,16 @@ void cmCPackIFWPackage::GeneratePackageFile()
   // Write dependencies
   if  (!compDepSet.empty())
     {
-    xout << "    <Dependencies>";
+    std::stringstream dependencies;
     std::set<DependenceStruct>::iterator it = compDepSet.begin();
-    xout << it->NameWithCompare();
+    dependencies << it->NameWithCompare();
     ++it;
     while(it != compDepSet.end())
       {
-      xout << "," << it->NameWithCompare();
+      dependencies << "," << it->NameWithCompare();
       ++it;
       }
-    xout << "</Dependencies>" << std::endl;
+    xout.Element("Dependencies", dependencies.str());
     }
 
   // Licenses (copy to meta dir)
@@ -524,43 +518,42 @@ void cmCPackIFWPackage::GeneratePackageFile()
     }
   if(!licenses.empty())
     {
-    xout << "    <Licenses>" << std::endl;
+    xout.StartElement("Licenses");
     for(size_t i = 0; i < licenses.size(); i += 2)
       {
-      xout << "        <License "
-           << "name=\"" << licenses[i] << "\" "
-           << "file=\"" << licenses[i + 1] << "\" "
-           << "/>" <<std::endl;
+      xout.StartElement("License");
+      xout.Attribute("name", licenses[i]);
+      xout.Attribute("file", licenses[i + 1]);
+      xout.EndElement();
       }
-    xout << "    </Licenses>" << std::endl;
+    xout.EndElement();
     }
 
   if (!ForcedInstallation.empty())
     {
-    xout << "    <ForcedInstallation>" << ForcedInstallation
-         << "</ForcedInstallation>" << std::endl;
+    xout.Element("ForcedInstallation", ForcedInstallation);
     }
 
   if (!Virtual.empty())
     {
-    xout << "    <Virtual>" << Virtual << "</Virtual>" << std::endl;
+    xout.Element("Virtual", Virtual);
     }
   else if (!Default.empty())
     {
-    xout << "    <Default>" << Default << "</Default>" << std::endl;
+    xout.Element("Default", Default);
     }
 
   // Priority
   if(!SortingPriority.empty())
     {
-    xout << "    <SortingPriority>" << SortingPriority
-         << "</SortingPriority>" << std::endl;
+    xout.Element("SortingPriority", SortingPriority);
     }
 
-  xout << "</Package>" << std::endl;
+  xout.EndElement();
+  xout.EndDocument();
 }
 
-void cmCPackIFWPackage::WriteGeneratedByToStrim(cmGeneratedFileStream &xout)
+void cmCPackIFWPackage::WriteGeneratedByToStrim(cmXMLWriter &xout)
 {
   if(Generator) Generator->WriteGeneratedByToStrim(xout);
 }
diff --git a/Source/CPack/IFW/cmCPackIFWPackage.h b/Source/CPack/IFW/cmCPackIFWPackage.h
index d2f7927..e647c16 100644
--- a/Source/CPack/IFW/cmCPackIFWPackage.h
+++ b/Source/CPack/IFW/cmCPackIFWPackage.h
@@ -14,12 +14,12 @@
 #define cmCPackIFWPackage_h
 
 #include <cmStandardIncludes.h>
-#include <cmGeneratedFileStream.h>
 
 class cmCPackComponent;
 class cmCPackComponentGroup;
 class cmCPackIFWInstaller;
 class cmCPackIFWGenerator;
+class cmXMLWriter;
 
 /** \class cmCPackIFWPackage
  * \brief A single component to be installed by CPack IFW generator
@@ -135,7 +135,7 @@ public: // Internal implementation
   std::string Directory;
 
 protected:
-  void WriteGeneratedByToStrim(cmGeneratedFileStream& xout);
+  void WriteGeneratedByToStrim(cmXMLWriter& xout);
 };
 
 #endif // cmCPackIFWPackage_h
-- 
cgit v0.12