automoc:run moc on the header if the source file contains include "foo.moc"

This fixes #12533.
Before automoc did not check the header if the source file contained a
statement, now it does.
Additionally, moc is now only run on explicitely listed headers which
contain a Q_OBJECT macro.

Alex

Source/cmQtAutomoc.cxx

@@ -377,9 +377,8 @@ bool cmQtAutomoc::RunAutomocQt4()
 
   // key = moc source filepath, value = moc output filepath
   std::map<std::string, std::string> includedMocs;
-  // key = moc source filepath, value = moc output filename
+  // collect all headers which may need to be mocced
-  std::map<std::string, std::string> notIncludedMocs;
+  std::set<std::string> headerFiles;
-
 
   std::vector<std::string> sourceFiles;
   cmSystemTools::ExpandListArgument(this->Sources, sourceFiles);
@@ -393,34 +392,22 @@ bool cmQtAutomoc::RunAutomocQt4()
       {
       std::cout << "AUTOMOC: Checking " << absFilename << std::endl;
       }
-    this->ParseCppFile(absFilename, includedMocs, notIncludedMocs);
+    this->ParseCppFile(absFilename, includedMocs, headerFiles);
     }
 
-  std::vector<std::string> headerFiles;
+  std::vector<std::string> headerFilesVec;
-  cmSystemTools::ExpandListArgument(this->Headers, headerFiles);
+  cmSystemTools::ExpandListArgument(this->Headers, headerFilesVec);
-  for (std::vector<std::string>::const_iterator it = headerFiles.begin();
+  for (std::vector<std::string>::const_iterator it = headerFilesVec.begin();
-       it != headerFiles.end();
+       it != headerFilesVec.end();
        ++it)
     {
-    const std::string &absFilename = *it;
+    headerFiles.insert(*it);
-    if (this->Verbose)
-      {
-      std::cout << "AUTOMOC: Checking " << absFilename << std::endl;
-      }
-    if (includedMocs.find(absFilename) == includedMocs.end()
-              && notIncludedMocs.find(absFilename) == notIncludedMocs.end())
-      {
-      // if this header is not getting processed yet and is explicitly
-      // mentioned for the automoc the moc is run unconditionally on the
-      // header and the resulting file is included in the _automoc.cpp file
-      // (unless there's a .cpp file later on that includes the moc from
-      // this header)
-      const std::string currentMoc = "moc_" + cmsys::SystemTools::
-                         GetFilenameWithoutLastExtension(absFilename) + ".cpp";
-      notIncludedMocs[absFilename] = currentMoc;
-      }
     }
 
+  // key = moc source filepath, value = moc output filename
+  std::map<std::string, std::string> notIncludedMocs;
+  this->ParseHeaders(headerFiles, includedMocs, notIncludedMocs);
+
   // run moc on all the moc's that are #included in source files
   for(std::map<std::string, std::string>::const_iterator
                                                      it = includedMocs.begin();
@@ -487,7 +474,7 @@ bool cmQtAutomoc::RunAutomocQt4()
 
 void cmQtAutomoc::ParseCppFile(const std::string& absFilename,
                            std::map<std::string, std::string>& includedMocs,
-                           std::map<std::string, std::string>& notIncludedMocs)
+                           std::set<std::string>& absHeaders)
 {
   cmsys::RegularExpression mocIncludeRegExp(
               "[\n][ \t]*#[ \t]*include[ \t]+"
@@ -520,52 +507,7 @@ void cmQtAutomoc::ParseCppFile(const std::string& absFilename,
                    cmsys::SystemTools::GetRealPath(absFilename.c_str())) + '/';
 
   std::string::size_type matchOffset = 0;
-  if (!mocIncludeRegExp.find(contentsString.c_str()))
+  if (mocIncludeRegExp.find(contentsString.c_str()))
-    {
-    // no moc #include, look whether we need to create a moc from
-    // the .h nevertheless
-    const std::string basename =
-              cmsys::SystemTools::GetFilenameWithoutLastExtension(absFilename);
-    for(std::list<std::string>::const_iterator ext = headerExtensions.begin();
-        ext != headerExtensions.end();
-        ++ext)
-      {
-      const std::string headername = absPath + basename + (*ext);
-      if (cmsys::SystemTools::FileExists(headername.c_str())
-              && includedMocs.find(headername) == includedMocs.end()
-              && notIncludedMocs.find(headername) == notIncludedMocs.end())
-        {
-        const std::string currentMoc = "moc_" + basename + ".cpp";
-        const std::string contents = this->ReadAll(headername);
-        if (qObjectRegExp.find(contents))
-          {
-          //std::cout << "header contains Q_OBJECT macro";
-          notIncludedMocs[headername] = currentMoc;
-          }
-        break;
-        }
-      }
-    for(std::list<std::string>::const_iterator ext = headerExtensions.begin();
-        ext != headerExtensions.end();
-        ++ext)
-      {
-      const std::string privateHeaderName = absPath+basename+"_p"+(*ext);
-      if (cmsys::SystemTools::FileExists(privateHeaderName.c_str())
-          && includedMocs.find(privateHeaderName) == includedMocs.end()
-          && notIncludedMocs.find(privateHeaderName) == notIncludedMocs.end())
-        {
-        const std::string currentMoc = "moc_" + basename + "_p.cpp";
-        const std::string contents = this->ReadAll(privateHeaderName);
-        if (qObjectRegExp.find(contents))
-          {
-          //std::cout << "header contains Q_OBJECT macro";
-          notIncludedMocs[privateHeaderName] = currentMoc;
-          }
-        break;
-        }
-      }
-    }
-  else
     {
     // for every moc include in the file
     do
@@ -604,7 +546,6 @@ void cmQtAutomoc::ParseCppFile(const std::string& absFilename,
             {
             headerFound = true;
             includedMocs[sourceFilePath] = currentMoc;
-            notIncludedMocs.erase(sourceFilePath);
             break;
             }
           }
@@ -628,7 +569,6 @@ void cmQtAutomoc::ParseCppFile(const std::string& absFilename,
                 {
                 headerFound = true;
                 includedMocs[sourceFilePath] = currentMoc;
-                notIncludedMocs.erase(sourceFilePath);
                 break;
                 }
               }
@@ -658,11 +598,71 @@ void cmQtAutomoc::ParseCppFile(const std::string& absFilename,
       else
         {
         includedMocs[absFilename] = currentMoc;
-        notIncludedMocs.erase(absFilename);
         }
       matchOffset += mocIncludeRegExp.end();
       } while(mocIncludeRegExp.find(contentsString.c_str() + matchOffset));
     }
+
+  // search for header files and private header files we may need to moc:
+  const std::string basename =
+              cmsys::SystemTools::GetFilenameWithoutLastExtension(absFilename);
+  for(std::list<std::string>::const_iterator ext = headerExtensions.begin();
+      ext != headerExtensions.end();
+      ++ext)
+    {
+    const std::string headerName = absPath + basename + (*ext);
+    if (cmsys::SystemTools::FileExists(headerName.c_str()))
+      {
+      absHeaders.insert(headerName);
+      break;
+      }
+    }
+  for(std::list<std::string>::const_iterator ext = headerExtensions.begin();
+      ext != headerExtensions.end();
+      ++ext)
+    {
+    const std::string privateHeaderName = absPath+basename+"_p"+(*ext);
+    if (cmsys::SystemTools::FileExists(privateHeaderName.c_str()))
+      {
+      absHeaders.insert(privateHeaderName);
+      break;
+      }
+    }
+
+}
+
+
+void cmQtAutomoc::ParseHeaders(const std::set<std::string>& absHeaders,
+                        const std::map<std::string, std::string>& includedMocs,
+                        std::map<std::string, std::string>& notIncludedMocs)
+{
+  cmsys::RegularExpression qObjectRegExp("[\n][ \t]*Q_OBJECT[^a-zA-Z0-9_]");
+  for(std::set<std::string>::const_iterator hIt=absHeaders.begin();
+      hIt!=absHeaders.end();
+      ++hIt)
+    {
+    const std::string& headerName = *hIt;
+
+    if (includedMocs.find(headerName) == includedMocs.end())
+      {
+      if (this->Verbose)
+        {
+        std::cout << "AUTOMOC: Checking " << headerName << std::endl;
+        }
+
+      const std::string basename = cmsys::SystemTools::
+                                   GetFilenameWithoutLastExtension(headerName);
+
+      const std::string currentMoc = "moc_" + basename + ".cpp";
+      const std::string contents = this->ReadAll(headerName);
+      if (qObjectRegExp.find(contents))
+        {
+        //std::cout << "header contains Q_OBJECT macro";
+        notIncludedMocs[headerName] = currentMoc;
+        }
+      }
+    }
+
 }
 
 

Source/cmQtAutomoc.h

@@ -27,6 +27,9 @@ private:
                    const std::string& mocFileName);
   void ParseCppFile(const std::string& absFilename,
                     std::map<std::string, std::string>& includedMocs,
+                    std::set<std::string>& absHeaders);
+  void ParseHeaders(const std::set<std::string>& absHeaders,
+                    const std::map<std::string, std::string>& includedMocs,
                     std::map<std::string, std::string>& notIncludedMocs);
 
   void Init();

Tests/QtAutomoc/CMakeLists.txt

@@ -13,7 +13,7 @@ add_definitions(-DFOO)
 # create an executable and a library target, both requiring automoc:
 add_library(codeeditorLib STATIC codeeditor.cpp)
 
-add_executable(foo main.cpp calwidget.cpp )
+add_executable(foo main.cpp calwidget.cpp foo.cpp)
 
 set_target_properties(foo codeeditorLib PROPERTIES AUTOMOC TRUE)
 

Tests/QtAutomoc/foo.cpp

@@ -0,0 +1,26 @@
+#include "foo.h"
+
+#include <stdio.h>
+
+class FooFoo : public QObject
+{
+  Q_OBJECT
+  public:
+    FooFoo():QObject() {}
+  public slots:
+    int getValue() const { return 12; }
+};
+
+Foo::Foo()
+:QObject()
+{
+}
+
+
+void Foo::doFoo()
+{
+  FooFoo ff;
+  printf("Hello automoc: %d\n", ff.getValue());
+}
+
+#include "foo.moc"

Tests/QtAutomoc/foo.h

@@ -0,0 +1,15 @@
+#ifndef FOO_H
+#define FOO_H
+
+#include <QObject>
+
+class Foo : public QObject
+{
+  Q_OBJECT
+  public:
+    Foo();
+  public slots:
+    void doFoo();
+};
+
+#endif

Tests/QtAutomoc/main.cpp

@@ -42,6 +42,7 @@
 
 #include "codeeditor.h"
 #include "calwidget.h"
+#include "foo.h"
 
 int main(int argv, char **args)
 {
@@ -54,5 +55,8 @@ int main(int argv, char **args)
   Window w;
   w.show();
 
+  Foo foo;
+  foo.doFoo();
+
   return app.exec();
 }