Add support for codelite IDE project fles

Help/generator/CodeLite.rst

@@ -0,0 +1,24 @@
+CodeLite
+----------
+
+Generates CodeLite project files.
+
+Project files for CodeLite will be created in the top directory and
+in every subdirectory which features a CMakeLists.txt file containing
+a PROJECT() call. The appropriate make program can build the
+project through the default make target.  A "make install" target is
+also provided.
+
+This "extra" generator may be specified as:
+
+``CodeLite - MinGW Makefiles``
+ Generate with :generator:`MinGW Makefiles`.
+
+``CodeLite - NMake Makefiles``
+ Generate with :generator:`NMake Makefiles`.
+
+``CodeLite - Ninja``
+ Generate with :generator:`Ninja`.
+
+``CodeLite - Unix Makefiles``
+ Generate with :generator:`Unix Makefiles`.

Help/manual/cmake-generators.7.rst

@@ -79,6 +79,7 @@ The following extra generators are known to CMake.
    :maxdepth: 1
 
    /generator/CodeBlocks
+   /generator/CodeLite
    /generator/Eclipse CDT4
    /generator/KDevelop3
    /generator/Kate

Source/CMakeLists.txt

@@ -186,6 +186,8 @@ set(SRCS
   cmExportSetMap.cxx
   cmExtraCodeBlocksGenerator.cxx
   cmExtraCodeBlocksGenerator.h
+  cmExtraCodeLiteGenerator.cxx
+  cmExtraCodeLiteGenerator.h
   cmExtraEclipseCDT4Generator.cxx
   cmExtraEclipseCDT4Generator.h
   cmExtraKateGenerator.cxx

Source/cmExtraCodeLiteGenerator.cxx

@@ -0,0 +1,487 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2004-2009 Kitware, Inc.
+  Copyright 2004 Alexander Neundorf (neundorf@kde.org)
+  Copyright 2013 Eran Ifrah (eran.ifrah@gmail.com)
+
+  Distributed under the OSI-approved BSD License (the "License");
+  see accompanying file Copyright.txt for details.
+
+  This software is distributed WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the License for more information.
+============================================================================*/
+#include "cmExtraCodeLiteGenerator.h"
+#include "cmGlobalUnixMakefileGenerator3.h"
+#include "cmLocalUnixMakefileGenerator3.h"
+#include "cmMakefile.h"
+#include "cmake.h"
+#include "cmSourceFile.h"
+#include "cmGeneratedFileStream.h"
+#include "cmSystemTools.h"
+
+#include <cmsys/SystemTools.hxx>
+#include <cmsys/SystemInformation.hxx>
+#include <cmsys/Directory.hxx>
+#include "cmXMLSafe.h"
+#include <sstream>
+
+//----------------------------------------------------------------------------
+void cmExtraCodeLiteGenerator::GetDocumentation(cmDocumentationEntry& entry,
+                                                const char*) const
+{
+  entry.Name = this->GetName();
+  entry.Brief = "Generates CodeLite project files.";
+}
+
+cmExtraCodeLiteGenerator::cmExtraCodeLiteGenerator()
+  : cmExternalMakefileProjectGenerator()
+  , ConfigName("NoConfig")
+  , CpuCount(2)
+{
+#if defined(_WIN32)
+  this->SupportedGlobalGenerators.push_back("MinGW Makefiles");
+  this->SupportedGlobalGenerators.push_back("NMake Makefiles");
+#endif
+  this->SupportedGlobalGenerators.push_back("Ninja");
+  this->SupportedGlobalGenerators.push_back("Unix Makefiles");
+}
+
+void cmExtraCodeLiteGenerator::Generate()
+{
+  // Hold root tree information for creating the workspace
+  std::string workspaceProjectName;
+  std::string workspaceOutputDir;
+  std::string workspaceFileName;
+  std::string workspaceSourcePath;
+  std::string lprjdebug;
+
+  cmGeneratedFileStream fout;
+
+  // loop projects and locate the root project.
+  // and extract the information for creating the worspace
+  for (std::map<cmStdString, std::vector<cmLocalGenerator*> >::const_iterator
+       it = this->GlobalGenerator->GetProjectMap().begin();
+       it!= this->GlobalGenerator->GetProjectMap().end();
+       ++it)
+    {
+    const cmMakefile* mf =it->second[0]->GetMakefile();
+    this->ConfigName = GetConfigurationName( mf );
+
+    if (strcmp(mf->GetStartOutputDirectory(),
+               mf->GetHomeOutputDirectory()) == 0)
+      {
+      workspaceOutputDir   = mf->GetStartOutputDirectory();
+      workspaceProjectName = mf->GetProjectName();
+      workspaceSourcePath  = mf->GetHomeDirectory();
+      workspaceFileName    = workspaceOutputDir+"/";
+      workspaceFileName   += workspaceProjectName + ".workspace";
+      this->WorkspacePath = mf->GetStartOutputDirectory();;
+
+      fout.Open(workspaceFileName.c_str(), false, false);
+      fout << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
+           "<CodeLite_Workspace Name=\"" << workspaceProjectName << "\" >\n";
+      }
+    }
+
+  // for each sub project in the workspace create a codelite project
+  for (std::map<cmStdString, std::vector<cmLocalGenerator*> >::const_iterator
+       it = this->GlobalGenerator->GetProjectMap().begin();
+       it!= this->GlobalGenerator->GetProjectMap().end();
+       ++it)
+    {
+    // retrive project information
+    const cmMakefile* mf    = it->second[0]->GetMakefile();
+    std::string outputDir   = mf->GetStartOutputDirectory();
+    std::string projectName = mf->GetProjectName();
+    std::string filename    = outputDir + "/" + projectName + ".project";
+
+    // Make the project file relative to the workspace
+    filename = cmSystemTools::RelativePath(this->WorkspacePath.c_str(),
+                                          filename.c_str());
+
+    // 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";
+    }
+
+  fout << "  <BuildMatrix>\n"
+       "    <WorkspaceConfiguration Name=\""
+       << this->ConfigName << "\" Selected=\"yes\">\n"
+       "      " << lprjdebug << ""
+       "    </WorkspaceConfiguration>\n"
+       "  </BuildMatrix>\n"
+       "</CodeLite_Workspace>\n";
+}
+
+/* create the project file */
+void cmExtraCodeLiteGenerator::CreateProjectFile(
+  const std::vector<cmLocalGenerator*>& lgs)
+{
+  const cmMakefile* mf    = lgs[0]->GetMakefile();
+  std::string outputDir   = mf->GetStartOutputDirectory();
+  std::string projectName = mf->GetProjectName();
+  std::string filename    = outputDir + "/";
+
+  filename += projectName + ".project";
+  this->CreateNewProjectFile(lgs, filename);
+}
+
+void cmExtraCodeLiteGenerator
+::CreateNewProjectFile(const std::vector<cmLocalGenerator*>& lgs,
+                       const std::string& filename)
+{
+  const cmMakefile* mf=lgs[0]->GetMakefile();
+  cmGeneratedFileStream fout(filename.c_str());
+  if(!fout)
+    {
+    return;
+    }
+
+  // figure out the compiler
+  //std::string compiler = this->GetCBCompilerId(mf);
+  std::string workspaceSourcePath = mf->GetHomeDirectory();
+  std::string workspaceOutputDir =  mf->GetHomeOutputDirectory();
+  std::vector<std::string> outputFiles = mf->GetOutputFiles();
+  std::string projectName = mf->GetProjectName();
+  std::string incDirs;
+  std::vector<cmValueWithOrigin> incDirsVec =
+    mf->GetIncludeDirectoriesEntries();
+  std::vector<cmValueWithOrigin>::const_iterator iterInc = incDirsVec.begin();
+
+  //std::cout << "GetIncludeDirectories:" << std::endl;
+  for(; iterInc != incDirsVec.end(); ++iterInc )
+    {
+    //std::cout << (*ItStrVec) << std::endl;
+    incDirs += iterInc->Value + " ";
+    }
+
+  ////////////////////////////////////
+  fout << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
+       "<CodeLite_Project Name=\"" << mf->GetProjectName()
+       << "\" InternalType=\"\">\n";
+
+  // Collect all used source files in the project
+  // Sort them into two containers, one for C/C++ implementation files
+  // which may have an acompanying header, one for all other files
+  std::string projectType;
+
+  std::map<std::string, cmSourceFile*> cFiles;
+  std::set<std::string> otherFiles;
+  for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin();
+       lg!=lgs.end(); lg++)
+    {
+    cmMakefile* makefile=(*lg)->GetMakefile();
+    cmTargets& targets=makefile->GetTargets();
+    for (cmTargets::iterator ti = targets.begin();
+         ti != targets.end(); ti++)
+      {
+
+      switch(ti->second.GetType())
+        {
+        case cmTarget::EXECUTABLE:
+          {
+          projectType = "Executable";
+          }
+        break;
+        case cmTarget::STATIC_LIBRARY:
+          {
+          projectType = "Static Library";
+          }
+        break;
+        case cmTarget::SHARED_LIBRARY:
+          {
+          projectType = "Dynamic Library";
+          }
+        break;
+        case cmTarget::MODULE_LIBRARY:
+          {
+          projectType = "Dynamic Library";
+          }
+        break;
+        default:  // intended fallthrough
+          break;
+        }
+
+      switch(ti->second.GetType())
+        {
+        case cmTarget::EXECUTABLE:
+        case cmTarget::STATIC_LIBRARY:
+        case cmTarget::SHARED_LIBRARY:
+        case cmTarget::MODULE_LIBRARY:
+          {
+          std::vector<cmSourceFile*> sources;
+          ti->second.GetSourceFiles(sources);
+          for (std::vector<cmSourceFile*>::const_iterator si=sources.begin();
+               si!=sources.end(); si++)
+            {
+            // check whether it is a C/C++ implementation file
+            bool isCFile = false;
+            if ((*si)->GetLanguage() && (*(*si)->GetLanguage() == 'C'))
+              {
+              for(std::vector<std::string>::const_iterator
+                  ext = mf->GetSourceExtensions().begin();
+                  ext !=  mf->GetSourceExtensions().end();
+                  ++ext)
+                {
+                if ((*si)->GetExtension() == *ext)
+                  {
+                  isCFile = true;
+                  break;
+                  }
+                }
+              }
+
+            // then put it accordingly into one of the two containers
+            if (isCFile)
+              {
+              cFiles[(*si)->GetFullPath()] = *si ;
+              }
+            else
+              {
+              otherFiles.insert((*si)->GetFullPath());
+              }
+            }
+          }
+        default:  // intended fallthrough
+          break;
+        }
+      }
+    }
+
+  // The following loop tries to add header files matching to implementation
+  // files to the project. It does that by iterating over all source files,
+  // replacing the file name extension with ".h" and checks whether such a
+  // file exists. If it does, it is inserted into the map of files.
+  // A very similar version of that code exists also in the kdevelop
+  // project generator.
+  for (std::map<std::string, cmSourceFile*>::const_iterator
+       sit=cFiles.begin();
+       sit!=cFiles.end();
+       ++sit)
+    {
+    std::string headerBasename=cmSystemTools::GetFilenamePath(sit->first);
+    headerBasename+="/";
+    headerBasename+=cmSystemTools::GetFilenameWithoutExtension(sit->first);
+
+    // check if there's a matching header around
+    for(std::vector<std::string>::const_iterator
+        ext = mf->GetHeaderExtensions().begin();
+        ext !=  mf->GetHeaderExtensions().end();
+        ++ext)
+      {
+      std::string hname=headerBasename;
+      hname += ".";
+      hname += *ext;
+      // if it's already in the set, don't check if it exists on disk
+      std::set<std::string>::const_iterator headerIt=otherFiles.find(hname);
+      if (headerIt != otherFiles.end())
+        {
+        break;
+        }
+
+      if(cmSystemTools::FileExists(hname.c_str()))
+        {
+        otherFiles.insert(hname);
+        break;
+        }
+      }
+    }
+
+  // Get the project path ( we need it later to convert files to
+  // their relative path)
+  std::string projectPath = cmSystemTools::GetFilenamePath(filename);
+
+  // 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";
+
+  // insert all source files in the codelite project
+  // first the C/C++ implementation files, then all others
+  for (std::map<std::string, cmSourceFile*>::const_iterator
+       sit=cFiles.begin();
+       sit!=cFiles.end();
+       ++sit)
+    {
+    std::string relativePath =
+      cmSystemTools::RelativePath(projectPath.c_str(), sit->first.c_str());
+    fout<< "    <File Name=\"" << relativePath.c_str() << "\"/>\n";
+    }
+  fout<< "  </VirtualDirectory>\n";
+  fout<< "  <VirtualDirectory Name=\"include\">\n";
+  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.c_str() << "\"/>\n";
+    }
+  fout << "  </VirtualDirectory>\n";
+
+  // Get the number of CPUs. We use this information for the make -jN
+  // command
+  cmsys::SystemInformation info;
+  info.RunCPUCheck();
+
+  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";
+}
+
+std::string
+cmExtraCodeLiteGenerator::GetCodeLiteCompilerName(const cmMakefile* mf) const
+{
+  // figure out which language to use
+  // for now care only for C and C++
+  std::string compilerIdVar = "CMAKE_CXX_COMPILER_ID";
+  if (this->GlobalGenerator->GetLanguageEnabled("CXX") == false)
+    {
+    compilerIdVar = "CMAKE_C_COMPILER_ID";
+    }
+
+  std::string compilerId = mf->GetSafeDefinition(compilerIdVar.c_str());
+  std::string compiler = "gnu g++"; // default to g++
+
+  // Since we need the compiler for parsing purposes only
+  // it does not matter if we use clang or clang++, same as
+  // "gnu gcc" vs "gnu g++"
+  if (compilerId == "MSVC")
+    {
+    compiler = "VC++";
+    }
+  else if (compilerId == "Clang")
+    {
+    compiler = "clang++";
+    }
+  else if (compilerId == "GNU")
+    {
+    compiler = "gnu g++";
+    }
+  return compiler;
+}
+
+std::string
+cmExtraCodeLiteGenerator::GetConfigurationName(const cmMakefile* mf) const
+{
+  std::string confName = mf->GetSafeDefinition("CMAKE_BUILD_TYPE");
+  // Trim the configuration name from whitespaces (left and right)
+  confName.erase(0, confName.find_first_not_of(" \t\r\v\n"));
+  confName.erase(confName.find_last_not_of(" \t\r\v\n")+1);
+  if ( confName.empty() )
+    {
+    confName = "NoConfig";
+    }
+  return confName;
+}
+
+std::string
+cmExtraCodeLiteGenerator::GetBuildCommand(const cmMakefile* mf) const
+{
+  std::stringstream ss;
+  std::string generator = mf->GetSafeDefinition("CMAKE_GENERATOR");
+  std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
+  std::string buildCommand = make; // Default
+  if ( generator == "NMake Makefiles" )
+    {
+    buildCommand = make;
+    }
+  else if ( generator == "MinGW Makefiles" ||
+            generator == "Unix Makefiles"  ||
+            generator == "Ninja" )
+    {
+    ss << make;
+    buildCommand = ss.str();
+    }
+    return buildCommand;
+}
+
+std::string
+cmExtraCodeLiteGenerator::GetCleanCommand(const cmMakefile* mf) const
+{
+  return GetBuildCommand(mf) + " clean";
+}
+
+std::string
+cmExtraCodeLiteGenerator::GetRebuildCommand(const cmMakefile* mf) const
+{
+  return GetCleanCommand(mf) + cmXMLSafe(" && ").str() + GetBuildCommand(mf);
+}
+
+std::string
+cmExtraCodeLiteGenerator::GetSingleFileBuildCommand
+(const cmMakefile* mf) const
+{
+  std::string buildCommand;
+  std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
+  std::string generator = mf->GetSafeDefinition("CMAKE_GENERATOR");
+  if ( generator == "Unix Makefiles" || generator == "MinGW Makefiles" )
+    {
+    std::stringstream ss;
+    ss << make << " -f$(ProjectPath)/Makefile $(CurrentFileName).cpp.o";
+    buildCommand = ss.str();
+    }
+  return buildCommand;
+}

Source/cmExtraCodeLiteGenerator.h

@@ -0,0 +1,54 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2004-2009 Kitware, Inc.
+  Copyright 2004 Alexander Neundorf (neundorf@kde.org)
+  Copyright 2013 Eran Ifrah (eran.ifrah@gmail.com)
+
+  Distributed under the OSI-approved BSD License (the "License");
+  see accompanying file Copyright.txt for details.
+
+  This software is distributed WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the License for more information.
+============================================================================*/
+#ifndef cmGlobalCodeLiteGenerator_h
+#define cmGlobalCodeLiteGenerator_h
+
+#include "cmExternalMakefileProjectGenerator.h"
+
+class cmLocalGenerator;
+
+class cmExtraCodeLiteGenerator : public cmExternalMakefileProjectGenerator
+{
+protected:
+  std::string ConfigName;
+  std::string WorkspacePath;
+  unsigned int CpuCount;
+
+protected:
+  std::string GetCodeLiteCompilerName(const cmMakefile* mf) const;
+  std::string GetConfigurationName( const cmMakefile* mf ) const;
+  std::string GetBuildCommand(const cmMakefile* mf) const;
+  std::string GetCleanCommand(const cmMakefile* mf) const;
+  std::string GetRebuildCommand(const cmMakefile* mf) const;
+  std::string GetSingleFileBuildCommand(const cmMakefile* mf) const;
+public:
+  cmExtraCodeLiteGenerator();
+
+  virtual const char* GetName() const
+                          { return cmExtraCodeLiteGenerator::GetActualName();}
+  static const char* GetActualName()                     { return "CodeLite";}
+  static cmExternalMakefileProjectGenerator* New()
+                                      { return new cmExtraCodeLiteGenerator; }
+  /** Get the documentation entry for this generator.  */
+  virtual void GetDocumentation(cmDocumentationEntry& entry,
+                                const char* fullName) const;
+
+  virtual void Generate();
+  void CreateProjectFile(const std::vector<cmLocalGenerator*>& lgs);
+
+  void CreateNewProjectFile(const std::vector<cmLocalGenerator*>& lgs,
+                                const std::string& filename);
+};
+
+#endif

Source/cmake.cxx

@@ -69,6 +69,7 @@
 #endif
 #include "cmGlobalUnixMakefileGenerator3.h"
 #include "cmGlobalNinjaGenerator.h"
+#include "cmExtraCodeLiteGenerator.h"
 
 #if !defined(CMAKE_BOOT_MINGW)
 # include "cmExtraCodeBlocksGenerator.h"
@@ -991,6 +992,8 @@ void cmake::AddDefaultExtraGenerators()
 
   this->AddExtraGenerator(cmExtraCodeBlocksGenerator::GetActualName(),
                           &cmExtraCodeBlocksGenerator::New);
+  this->AddExtraGenerator(cmExtraCodeLiteGenerator::GetActualName(),
+                          &cmExtraCodeLiteGenerator::New);
   this->AddExtraGenerator(cmExtraSublimeTextGenerator::GetActualName(),
                           &cmExtraSublimeTextGenerator::New);
   this->AddExtraGenerator(cmExtraKateGenerator::GetActualName(),