ENH: when using the Eclipse project generator, run gcc so that it tells us

its system include directories. These are catched in CMakeSystemSpecificInformation.cmake
(only with the Eclipse generator) and then written by the Eclipse generator
in the Eclipse project file. This way Eclipse can find the standard headers
(#7585)
Not sure CMakeSystemSpecificInformation.cmake is the best place to do this.

Alex

Modules/CMakeSystemSpecificInformation.cmake

@@ -35,6 +35,44 @@ IF(NOT _INCLUDED_SYSTEM_INFO_FILE)
 ENDIF(NOT _INCLUDED_SYSTEM_INFO_FILE)
 
 
+# The Eclipse generator needs to know the standard include path
+# so that Eclipse ca find the headers at runtime and parsing etc. works better
+# This is done here by actually running gcc with the options so it prints its
+# system include directories, which are parsed then and stored in the cache.
+IF("${CMAKE_EXTRA_GENERATOR}" MATCHES "Eclipse")
+
+  MACRO(_DETERMINE_GCC_SYSTEM_INCLUDE_DIRS _lang _result)
+    SET(${_result})
+    SET(_gccOutput)
+    FILE(WRITE "${CMAKE_BINARY_DIR}/CMakeFiles/dummy" "\n" )
+    EXECUTE_PROCESS(COMMAND ${CMAKE_C_COMPILER} -v -E -x ${_lang} dummy
+                   WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/CMakeFiles
+                   ERROR_VARIABLE _gccOutput
+                   OUTPUT_QUIET )
+    FILE(REMOVE "${CMAKE_BINARY_DIR}/CMakeFiles/dummy")
+
+    IF( "${_gccOutput}" MATCHES "> search starts here[^\n]+\n *(.+) *\n *End of (search) list" )
+      SET(${_result} ${CMAKE_MATCH_1})
+      STRING(REPLACE "\n" " " ${_result} "${${_result}}")
+      SEPARATE_ARGUMENTS(${_result})
+    ENDIF( "${_gccOutput}" MATCHES "> search starts here[^\n]+\n *(.+) *\n *End of (search) list" )
+  ENDMACRO(_DETERMINE_GCC_SYSTEM_INCLUDE_DIRS _lang)
+
+  # Now check for C
+  IF ("${CMAKE_C_COMPILER_ID}" MATCHES GNU  AND NOT  CMAKE_ECLIPSE_C_SYSTEM_INCLUDE_DIRS)
+    _DETERMINE_GCC_SYSTEM_INCLUDE_DIRS(c _dirs)
+    SET(CMAKE_ECLIPSE_C_SYSTEM_INCLUDE_DIRS "${_dirs}" CACHE INTERNAL "C compiler system include directories")
+  ENDIF ("${CMAKE_C_COMPILER_ID}" MATCHES GNU  AND NOT  CMAKE_ECLIPSE_C_SYSTEM_INCLUDE_DIRS)
+
+  # And now the same for C++
+  IF ("${CMAKE_CXX_COMPILER_ID}" MATCHES GNU  AND NOT  CMAKE_ECLIPSE_CXX_SYSTEM_INCLUDE_DIRS)
+    _DETERMINE_GCC_SYSTEM_INCLUDE_DIRS(c++ _dirs)
+    SET(CMAKE_ECLIPSE_CXX_SYSTEM_INCLUDE_DIRS "${_dirs}" CACHE INTERNAL "CXX compiler system include directories")
+  ENDIF ("${CMAKE_CXX_COMPILER_ID}" MATCHES GNU  AND NOT  CMAKE_ECLIPSE_CXX_SYSTEM_INCLUDE_DIRS)
+
+ENDIF("${CMAKE_EXTRA_GENERATOR}" MATCHES "Eclipse")
+
+
 # for most systems a module is the same as a shared library
 # so unless the variable CMAKE_MODULE_EXISTS is set just
 # copy the values from the LIBRARY variables

Source/cmExtraEclipseCDT4Generator.cxx

@@ -394,6 +394,30 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
   fout << "</projectDescription>\n";
 }
 
+//----------------------------------------------------------------------------
+void cmExtraEclipseCDT4Generator::AppendIncludeDirectories(
+                            cmGeneratedFileStream& fout,
+                            const std::vector<std::string>& includeDirs,
+                            std::set<std::string>& emittedDirs)
+{
+  for(std::vector<std::string>::const_iterator inc = includeDirs.begin();
+      inc != includeDirs.end();
+      ++inc)
+    {
+    if (!inc->empty())
+      {
+      std::string dir = cmSystemTools::CollapseFullPath(inc->c_str());
+      if(emittedDirs.find(dir) == emittedDirs.end())
+        {
+        emittedDirs.insert(dir);
+        fout << "<pathentry include=\"" 
+             << cmExtraEclipseCDT4Generator::GetEclipsePath(dir)
+             << "\" kind=\"inc\" path=\"\" system=\"true\"/>\n";
+        }
+      }
+    }
+}
+
 //----------------------------------------------------------------------------
 void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
 {
@@ -590,19 +614,31 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
     {
     const std::vector<std::string>& includeDirs
       = (*it)->GetMakefile()->GetIncludeDirectories();
-    for(std::vector<std::string>::const_iterator inc = includeDirs.begin();
+    this->AppendIncludeDirectories(fout, includeDirs, emmited);
-        inc != includeDirs.end();
-        ++inc)
-      {
-      std::string dir = cmSystemTools::CollapseFullPath(inc->c_str());
-      if(emmited.find(dir) == emmited.end())
-        {
-        emmited.insert(dir);
-        fout << "<pathentry include=\"" << this->GetEclipsePath(dir)
-             << "\" kind=\"inc\" path=\"\" system=\"true\"/>\n";
-        }
-      }
     }
+  // now also the system include directories, in case we found them in 
+  // CMakeSystemSpecificInformation.cmake. This makes Eclipse find the 
+  // standard headers.
+  mf->GetDefinition("CMAKE_ECLIPSE_C_SYSTEM_INCLUDE_DIRS");
+  std::string compiler = mf->GetSafeDefinition("CMAKE_C_COMPILER");
+  if (!compiler.empty())
+    {
+    std::string systemIncludeDirs = mf->GetSafeDefinition(
+                                      "CMAKE_ECLIPSE_C_SYSTEM_INCLUDE_DIRS");
+    std::vector<std::string> dirs;
+    cmSystemTools::ExpandListArgument(systemIncludeDirs.c_str(), dirs);
+    this->AppendIncludeDirectories(fout, dirs, emmited);
+    }
+  compiler = mf->GetSafeDefinition("CMAKE_CXX_COMPILER");
+  if (!compiler.empty())
+    {
+    std::string systemIncludeDirs = mf->GetSafeDefinition(
+                                      "CMAKE_ECLIPSE_CXX_SYSTEM_INCLUDE_DIRS");
+    std::vector<std::string> dirs;
+    cmSystemTools::ExpandListArgument(systemIncludeDirs.c_str(), dirs);
+    this->AppendIncludeDirectories(fout, dirs, emmited);
+    }
+
   fout << "</storageModule>\n";
 
   // add build targets

Source/cmExtraEclipseCDT4Generator.h

@@ -111,6 +111,10 @@ private:
                                const std::string&     defname,
                                const std::string&     altdefname);
 
+  static void AppendIncludeDirectories(cmGeneratedFileStream& fout,
+                                   const std::vector<std::string>& includeDirs,
+                                   std::set<std::string>& emittedDirs);
+
   std::vector<std::string> SrcLinkedResources;
   std::vector<std::string> OutLinkedResources;
   std::string HomeDirectory;