Merge topic 'use-cmXMLWriter'

51465da1 CPack/IFW: port to cmXMLWriter
754485af cmExtraEclipseCDT4Generator: port to cmXMLWriter
c45671b0 cmGlobalKdevelopGenerator: port to cmXMLWriter
dcdc270e cmExtraCodeLiteGenerator: port to cmXMLWriter
27e09764 cmExtraCodeBlocksGenerator: port to cmXMLWriter
d7407621 cmXMLWriter: add Doctype() method
dd27e313 cmXMLWriter: overload Element() method for empty elements

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

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
 

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

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

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

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

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,

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;

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;
@@ -85,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();

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)
     {
@@ -60,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);