Merge topic 'autogen-protect-cmsys-calls'

b11e2c80b1 Autogen: Print moc/uic/rcc output to stdout
1d2c9d8c6d Autogen: Use std::istreambuf_iterator for file so string reading
ccc38fa509 Autogen: Protected calls to cmFilePathChecksum
719b24c872 Autogen: Protected calls to cmQtAutoGen::SubDirPrefix
9a73615815 Autogen: Protected calls to cmSystemTools::GetFilenameWithoutLastExtension
65203ce407 Autogen: Protected calls to cmSystemTools::Split/JoinPath
14a86c9ea7 Autogen: Protected calls to cmSystemTools::CollapseCombinedPath

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !1918

Source/cmQtAutoGenerator.cxx

@@ -146,19 +146,93 @@ void cmQtAutoGenerator::Logger::ErrorCommand(
   }
 }
 
-std::string cmQtAutoGenerator::FileSystem::RealPath(
+std::string cmQtAutoGenerator::FileSystem::GetRealPath(
   std::string const& filename)
 {
   std::lock_guard<std::mutex> lock(Mutex_);
   return cmSystemTools::GetRealPath(filename);
 }
 
+std::string cmQtAutoGenerator::FileSystem::CollapseCombinedPath(
+  std::string const& dir, std::string const& file)
+{
+  std::lock_guard<std::mutex> lock(Mutex_);
+  return cmSystemTools::CollapseCombinedPath(dir, file);
+}
+
+void cmQtAutoGenerator::FileSystem::SplitPath(
+  const std::string& p, std::vector<std::string>& components,
+  bool expand_home_dir)
+{
+  std::lock_guard<std::mutex> lock(Mutex_);
+  cmSystemTools::SplitPath(p, components, expand_home_dir);
+}
+
+std::string cmQtAutoGenerator::FileSystem::JoinPath(
+  const std::vector<std::string>& components)
+{
+  std::lock_guard<std::mutex> lock(Mutex_);
+  return cmSystemTools::JoinPath(components);
+}
+
+std::string cmQtAutoGenerator::FileSystem::JoinPath(
+  std::vector<std::string>::const_iterator first,
+  std::vector<std::string>::const_iterator last)
+{
+  std::lock_guard<std::mutex> lock(Mutex_);
+  return cmSystemTools::JoinPath(first, last);
+}
+
+std::string cmQtAutoGenerator::FileSystem::GetFilenameWithoutLastExtension(
+  const std::string& filename)
+{
+  std::lock_guard<std::mutex> lock(Mutex_);
+  return cmSystemTools::GetFilenameWithoutLastExtension(filename);
+}
+
+std::string cmQtAutoGenerator::FileSystem::SubDirPrefix(
+  std::string const& filename)
+{
+  std::lock_guard<std::mutex> lock(Mutex_);
+  return cmQtAutoGen::SubDirPrefix(filename);
+}
+
+void cmQtAutoGenerator::FileSystem::setupFilePathChecksum(
+  std::string const& currentSrcDir, std::string const& currentBinDir,
+  std::string const& projectSrcDir, std::string const& projectBinDir)
+{
+  std::lock_guard<std::mutex> lock(Mutex_);
+  FilePathChecksum_.setupParentDirs(currentSrcDir, currentBinDir,
+                                    projectSrcDir, projectBinDir);
+}
+
+std::string cmQtAutoGenerator::FileSystem::GetFilePathChecksum(
+  std::string const& filename)
+{
+  std::lock_guard<std::mutex> lock(Mutex_);
+  return FilePathChecksum_.getPart(filename);
+}
+
 bool cmQtAutoGenerator::FileSystem::FileExists(std::string const& filename)
 {
   std::lock_guard<std::mutex> lock(Mutex_);
   return cmSystemTools::FileExists(filename);
 }
 
+bool cmQtAutoGenerator::FileSystem::FileExists(std::string const& filename,
+                                               bool isFile)
+{
+  std::lock_guard<std::mutex> lock(Mutex_);
+  return cmSystemTools::FileExists(filename, isFile);
+}
+
+unsigned long cmQtAutoGenerator::FileSystem::FileLength(
+  std::string const& filename)
+{
+  std::lock_guard<std::mutex> lock(Mutex_);
+  return cmSystemTools::FileLength(filename);
+}
+
 bool cmQtAutoGenerator::FileSystem::FileIsOlderThan(
   std::string const& buildFile, std::string const& sourceFile,
   std::string* error)
@@ -188,35 +262,30 @@ bool cmQtAutoGenerator::FileSystem::FileRead(std::string& content,
                                              std::string* error)
 {
   bool success = false;
-  {
-    std::lock_guard<std::mutex> lock(Mutex_);
-    if (cmSystemTools::FileExists(filename, true)) {
-      std::size_t const length = cmSystemTools::FileLength(filename);
+  if (FileExists(filename, true)) {
+    unsigned long const length = FileLength(filename);
+    {
+      std::lock_guard<std::mutex> lock(Mutex_);
       cmsys::ifstream ifs(filename.c_str(), (std::ios::in | std::ios::binary));
       if (ifs) {
-        if (length > 0) {
-          content.resize(length);
-          ifs.read(&content.front(), content.size());
-          if (ifs) {
-            success = true;
-          } else {
-            content.clear();
-            if (error != nullptr) {
-              error->append("Reading from the file failed.");
-            }
-          }
-        } else {
-          // Readable but empty file
-          content.clear();
+        content.reserve(length);
+        content.assign(std::istreambuf_iterator<char>{ ifs },
+                       std::istreambuf_iterator<char>{});
+        if (ifs) {
           success = true;
+        } else {
+          content.clear();
+          if (error != nullptr) {
+            error->append("Reading from the file failed.");
+          }
         }
       } else if (error != nullptr) {
         error->append("Opening the file for reading failed.");
       }
-    } else if (error != nullptr) {
-      error->append(
-        "The file does not exist, is not readable or is a directory.");
     }
+  } else if (error != nullptr) {
+    error->append(
+      "The file does not exist, is not readable or is a directory.");
   }
   return success;
 }

Source/cmQtAutoGenerator.h

@@ -5,6 +5,7 @@
 
 #include "cmConfigure.h" // IWYU pragma: keep
 
+#include "cmFilePathChecksum.h"
 #include "cmQtAutoGen.h"
 #include "cmUVHandlePtr.h"
 #include "cmUVSignalHackRAII.h" // IWYU pragma: keep
@@ -68,9 +69,42 @@ public:
     {
     }
 
+    /// @brief Logger
     Logger* Log() const { return Log_; }
-    std::string RealPath(std::string const& filename);
+
+    // -- Paths
+    /// @brief Wrapper for cmSystemTools::GetRealPath
+    std::string GetRealPath(std::string const& filename);
+    /// @brief Wrapper for cmSystemTools::CollapseCombinedPath
+    std::string CollapseCombinedPath(std::string const& dir,
+                                     std::string const& file);
+    /// @brief Wrapper for cmSystemTools::SplitPath
+    void SplitPath(const std::string& p, std::vector<std::string>& components,
+                   bool expand_home_dir = true);
+    /// @brief Wrapper for cmSystemTools::JoinPath
+    std::string JoinPath(const std::vector<std::string>& components);
+    /// @brief Wrapper for cmSystemTools::JoinPath
+    std::string JoinPath(std::vector<std::string>::const_iterator first,
+                         std::vector<std::string>::const_iterator last);
+    /// @brief Wrapper for cmSystemTools::GetFilenameWithoutLastExtension
+    std::string GetFilenameWithoutLastExtension(const std::string& filename);
+    /// @brief Wrapper for cmQtAutoGen::SubDirPrefix
+    std::string SubDirPrefix(std::string const& filename);
+    /// @brief Wrapper for cmFilePathChecksum::setupParentDirs
+    void setupFilePathChecksum(std::string const& currentSrcDir,
+                               std::string const& currentBinDir,
+                               std::string const& projectSrcDir,
+                               std::string const& projectBinDir);
+    /// @brief Wrapper for cmFilePathChecksum::getPart
+    std::string GetFilePathChecksum(std::string const& filename);
+
+    // -- File access
+    /// @brief Wrapper for cmSystemTools::FileExists
     bool FileExists(std::string const& filename);
+    /// @brief Wrapper for cmSystemTools::FileExists
+    bool FileExists(std::string const& filename, bool isFile);
+    /// @brief Wrapper for cmSystemTools::FileLength
+    unsigned long FileLength(std::string const& filename);
     bool FileIsOlderThan(std::string const& buildFile,
                          std::string const& sourceFile,
                          std::string* error = nullptr);
@@ -92,6 +126,7 @@ public:
     bool FileRemove(std::string const& filename);
     bool Touch(std::string const& filename);
 
+    // -- Directory access
     bool MakeDirectory(std::string const& dirname);
     /// @brief Error logging version
     bool MakeDirectory(GeneratorT genType, std::string const& dirname);
@@ -102,6 +137,7 @@ public:
 
   private:
     std::mutex Mutex_;
+    cmFilePathChecksum FilePathChecksum_;
     Logger* Log_;
   };
 

Source/cmQtAutoGeneratorMocUic.cxx

@@ -26,7 +26,7 @@
 std::string cmQtAutoGeneratorMocUic::BaseSettingsT::AbsoluteBuildPath(
   std::string const& relativePath) const
 {
-  return cmSystemTools::CollapseCombinedPath(AutogenBuildDir, relativePath);
+  return FileSys->CollapseCombinedPath(AutogenBuildDir, relativePath);
 }
 
 /**
@@ -106,7 +106,7 @@ std::string cmQtAutoGeneratorMocUic::MocSettingsT::FindIncludedFile(
     std::string testPath = sourcePath;
     testPath += includeString;
     if (FileSys->FileExists(testPath)) {
-      return FileSys->RealPath(testPath);
+      return FileSys->GetRealPath(testPath);
     }
   }
   // Search in include directories
@@ -115,7 +115,7 @@ std::string cmQtAutoGeneratorMocUic::MocSettingsT::FindIncludedFile(
     fullPath.push_back('/');
     fullPath += includeString;
     if (FileSys->FileExists(fullPath)) {
-      return FileSys->RealPath(fullPath);
+      return FileSys->GetRealPath(fullPath);
     }
   }
   // Return empty string
@@ -166,9 +166,9 @@ void cmQtAutoGeneratorMocUic::JobParseT::Process(WorkerT& wrk)
     MetaT meta;
     if (wrk.FileSys().FileRead(meta.Content, FileName, &error)) {
       if (!meta.Content.empty()) {
-        meta.FileDir = SubDirPrefix(FileName);
+        meta.FileDir = wrk.FileSys().SubDirPrefix(FileName);
         meta.FileBase =
-          cmSystemTools::GetFilenameWithoutLastExtension(FileName);
+          wrk.FileSys().GetFilenameWithoutLastExtension(FileName);
 
         bool success = true;
         if (AutoMoc) {
@@ -222,9 +222,9 @@ bool cmQtAutoGeneratorMocUic::JobParseT::ParseMocSource(WorkerT& wrk,
       cmsys::RegularExpressionMatch match;
       while (wrk.Moc().RegExpInclude.find(contentChars, match)) {
         std::string incString = match.match(2);
-        std::string incDir(SubDirPrefix(incString));
+        std::string incDir(wrk.FileSys().SubDirPrefix(incString));
         std::string incBase =
-          cmSystemTools::GetFilenameWithoutLastExtension(incString);
+          wrk.FileSys().GetFilenameWithoutLastExtension(incString);
         if (cmHasLiteralPrefix(incBase, "moc_")) {
           // moc_<BASE>.cxx
           // Remove the moc_ part from the base name
@@ -487,7 +487,7 @@ std::string cmQtAutoGeneratorMocUic::JobParseT::MocFindIncludedHeader(
   }
   // Sanitize
   if (!header.empty()) {
-    header = wrk.FileSys().RealPath(header);
+    header = wrk.FileSys().GetRealPath(header);
   }
   return header;
 }
@@ -533,12 +533,12 @@ std::string cmQtAutoGeneratorMocUic::JobParseT::UicFindIncludedFile(
 {
   std::string res;
   std::string searchFile =
-    cmSystemTools::GetFilenameWithoutLastExtension(includeString).substr(3);
+    wrk.FileSys().GetFilenameWithoutLastExtension(includeString).substr(3);
   searchFile += ".ui";
   // Collect search paths list
   std::deque<std::string> testFiles;
   {
-    std::string const searchPath = SubDirPrefix(includeString);
+    std::string const searchPath = wrk.FileSys().SubDirPrefix(includeString);
 
     std::string searchFileFull;
     if (!searchPath.empty()) {
@@ -569,7 +569,7 @@ std::string cmQtAutoGeneratorMocUic::JobParseT::UicFindIncludedFile(
   // Search for the .ui file!
   for (std::string const& testFile : testFiles) {
     if (wrk.FileSys().FileExists(testFile)) {
-      res = wrk.FileSys().RealPath(testFile);
+      res = wrk.FileSys().GetRealPath(testFile);
       break;
     }
   }
@@ -676,9 +676,9 @@ void cmQtAutoGeneratorMocUic::JobMocT::Process(WorkerT& wrk)
     BuildFile += '/';
     BuildFile += IncludeString;
   } else {
-    std::string rel = wrk.Base().FilePathChecksum.getPart(SourceFile);
+    std::string rel = wrk.FileSys().GetFilePathChecksum(SourceFile);
     rel += "/moc_";
-    rel += cmSystemTools::GetFilenameWithoutLastExtension(SourceFile);
+    rel += wrk.FileSys().GetFilenameWithoutLastExtension(SourceFile);
     rel += ".cpp";
     // Register relative file path
     wrk.Gen().ParallelMocAutoRegister(rel);
@@ -798,7 +798,7 @@ bool cmQtAutoGeneratorMocUic::JobMocT::UpdateRequired(WorkerT& wrk)
     }
     // Check dependency timestamps
     std::string error;
-    std::string sourceDir = SubDirPrefix(SourceFile);
+    std::string sourceDir = wrk.FileSys().SubDirPrefix(SourceFile);
     for (std::string const& depFileRel : Depends) {
       std::string depFileAbs =
         wrk.Moc().FindIncludedFile(sourceDir, depFileRel);
@@ -853,8 +853,12 @@ void cmQtAutoGeneratorMocUic::JobMocT::GenerateMoc(WorkerT& wrk)
     ProcessResultT result;
     if (wrk.RunProcess(GeneratorT::MOC, result, cmd)) {
       // Moc command success
+      // Print moc output
+      if (!result.StdOut.empty()) {
+        wrk.LogInfo(GeneratorT::MOC, result.StdOut);
+      }
+      // Notify the generator that a not included file changed (on demand)
       if (IncludeString.empty()) {
-        // Notify the generator that a not included file changed
         wrk.Gen().ParallelMocAutoUpdated();
       }
     } else {
@@ -963,9 +967,13 @@ void cmQtAutoGeneratorMocUic::JobUicT::GenerateUic(WorkerT& wrk)
 
     ProcessResultT result;
     if (wrk.RunProcess(GeneratorT::UIC, result, cmd)) {
-      // Success
+      // Uic command success
+      // Print uic output
+      if (!result.StdOut.empty()) {
+        wrk.LogInfo(GeneratorT::UIC, result.StdOut);
+      }
     } else {
-      // Command failed
+      // Uic command failed
       {
         std::string emsg = "The uic process failed to compile\n  ";
         emsg += Quoted(SourceFile);
@@ -1416,8 +1424,8 @@ bool cmQtAutoGeneratorMocUic::Init(cmMakefile* makefile)
         // Search for the default header file and a private header
         {
           std::array<std::string, 2> bases;
-          bases[0] = SubDirPrefix(src);
-          bases[0] += cmSystemTools::GetFilenameWithoutLastExtension(src);
+          bases[0] = FileSys().SubDirPrefix(src);
+          bases[0] += FileSys().GetFilenameWithoutLastExtension(src);
           bases[1] = bases[0];
           bases[1] += "_p";
           for (std::string const& headerBase : bases) {
@@ -1444,7 +1452,7 @@ bool cmQtAutoGeneratorMocUic::Init(cmMakefile* makefile)
   // ------------------------
 
   // Init file path checksum generator
-  Base_.FilePathChecksum.setupParentDirs(
+  FileSys().setupFilePathChecksum(
     Base().CurrentSourceDir, Base().CurrentBinaryDir, Base().ProjectSourceDir,
     Base().ProjectBinaryDir);
 
@@ -1503,8 +1511,8 @@ bool cmQtAutoGeneratorMocUic::Init(cmMakefile* makefile)
         if (cmHasLiteralSuffix(path, ".framework/Headers")) {
           // Go up twice to get to the framework root
           std::vector<std::string> pathComponents;
-          cmSystemTools::SplitPath(path, pathComponents);
-          std::string frameworkPath = cmSystemTools::JoinPath(
+          FileSys().SplitPath(path, pathComponents);
+          std::string frameworkPath = FileSys().JoinPath(
             pathComponents.begin(), pathComponents.end() - 2);
           frameworkPaths.insert(frameworkPath);
         }

Source/cmQtAutoGeneratorMocUic.h

@@ -5,7 +5,6 @@
 
 #include "cmConfigure.h" // IWYU pragma: keep
 
-#include "cmFilePathChecksum.h"
 #include "cmQtAutoGen.h"
 #include "cmQtAutoGenerator.h"
 #include "cmUVHandlePtr.h"
@@ -95,7 +94,6 @@ public:
     std::string AutogenBuildDir;
     std::string AutogenIncludeDir;
     // - Files
-    cmFilePathChecksum FilePathChecksum;
     std::vector<std::string> HeaderExtensions;
     // - File system
     FileSystem* FileSys;

Source/cmQtAutoGeneratorRcc.cxx

@@ -533,10 +533,14 @@ bool cmQtAutoGeneratorRcc::GenerateRcc()
     if (Process_->IsFinished()) {
       // Process is finished
       if (!ProcessResult_.error()) {
-        // Process success
+        // Rcc process success
+        // Print rcc output
+        if (!ProcessResult_.StdOut.empty()) {
+          Log().Info(GeneratorT::RCC, ProcessResult_.StdOut);
+        }
         BuildFileChanged_ = true;
       } else {
-        // Process failed
+        // Rcc process failed
         {
           std::string emsg = "The rcc process failed to compile\n  ";
           emsg += Quoted(QrcFile_);