1. 25 Sep, 2015 1 commit
  2. 18 Sep, 2015 1 commit
    • Brad King's avatar
      Ninja: Detect MSVC /showIncludes prefix with compiler flags (#15596) · 109a7a24
      Brad King authored
      Move detection over to the compiler id logic where we have already
      constructed the list of compiler flags from ARG1 and CMAKE_<LANG>_FLAGS.
      Pass the flags when we execute "cl" with "/showIncludes".  Also pass "/c"
      because we only need to compile, not link.  Check the compiler process
      exit code before trusting its output.
      109a7a24
  3. 20 Aug, 2015 1 commit
  4. 30 Jun, 2015 1 commit
  5. 18 Jun, 2015 1 commit
    • Brad King's avatar
      CMakeDetermineCompilerId: Optionally try some flags before no flags · c65a060e
      Brad King authored
      Teach CMAKE_DETERMINE_COMPILER_ID to optionally try detecting the
      compiler id using some given flags before trying to detect it with no
      special flags.  This will be useful for Fortran detection to distinguish
      some compilers that use the preprocessors of others but have no macro of
      their own by getting verbose output.
      c65a060e
  6. 05 Sep, 2014 1 commit
    • Brad King's avatar
      Fix finding binutils when cross-compiling with Clang · 72d66818
      Brad King authored
      Since commit v3.0.0-rc1~342^2~2 (Add compiler target compile options,
      2013-05-19) we use CMAKE_<LANG>_COMPILER_TARGET as the binutils prefix
      when cross-compiling with Clang.  Fix the implementation to use the
      compiler target as the prefix only when it is set.  Otherwise toolchain
      files not using CMAKE_<LANG>_COMPILER_TARGET cause the logic to use
      a prefix of just "-" and of course cannot find "-ar" or "-ld".
      72d66818
  7. 14 Apr, 2014 2 commits
  8. 10 Mar, 2014 2 commits
  9. 22 Jan, 2014 1 commit
  10. 19 Nov, 2013 1 commit
    • Stephen Kelly's avatar
      Add compiler target compile options. · 76552d59
      Stephen Kelly authored
      For clang, this allows passing -target <triple> to the compiler, and
      for qcc, -V<arch> using toolchain files containing something like
      
       set(triple arm-linux-gnueabihf)
       set(CMAKE_C_COMPILER "/usr/bin/clang")
       set(CMAKE_C_COMPILER_TARGET ${triple})
       set(CMAKE_CXX_COMPILER "/usr/bin/clang++")
       set(CMAKE_CXX_COMPILER_TARGET ${triple})
      
      or
      
       set(arch gcc_ntoarmv7le)
       set(CMAKE_C_COMPILER /opt/qnx650/host/linux/x86/usr/bin/qcc)
       set(CMAKE_C_COMPILER_TARGET ${arch})
       set(CMAKE_CXX_COMPILER /opt/qnx650/host/linux/x86/usr/bin/QCC)
       set(CMAKE_CXX_COMPILER_TARGET ${arch})
      
      Both clang and qcc are inherently cross compiler( driver)s.
      
      When cross-compiling with clang, use the CMAKE_${lang}_COMPILER_TARGET
      as the _CMAKE_TOOLCHAIN_PREFIX to find the appropriate binutils.
      
      When cross-compiling with QNX qcc, use the CMAKE_${lang}_COMPILER_TARGET
      to set the appropriate _CMAKE_TOOLCHAIN_PREFIX.
      76552d59
  11. 13 Nov, 2013 1 commit
  12. 25 Oct, 2013 1 commit
  13. 24 Oct, 2013 2 commits
    • Peter Kümmel's avatar
      Ninja: use deps = gcc/msvc feature · eeb4aece
      Peter Kümmel authored
      cmcldeps is now only used for .rc file processing
      eeb4aece
    • Brad King's avatar
      CMakeDetermine*Compiler: Remove temporary cache entry · 332771c9
      Brad King authored
      When the user or toolchain file sets CMAKE_<LANG>_COMPILER to a name
      without a path we use find_program with CMAKE_<LANG>_COMPILER_WITH_PATH
      to search for the tool.  Remove the temporary cache entry afterward to
      avoid exposing it to projects.  It is not set by other logic paths so no
      one should be using it.
      332771c9
  14. 15 Apr, 2013 1 commit
  15. 14 Mar, 2013 3 commits
  16. 24 Aug, 2012 1 commit
    • Brad King's avatar
      Make platform information files specific to the CMake version · 7195aca5
      Brad King authored
      At the top of a build tree we configure inside the CMakeFiles directory
      files such as "CMakeSystem.cmake" and "CMake<lang>Compiler.cmake" to
      save information detected about the system and compilers in use.  The
      method of detection and the exact results store varies across CMake
      versions as things improve.  This leads to problems when loading files
      configured by a different version of CMake.  Previously we ignored such
      existing files only if the major.minor part of the CMake version
      component changed, and depended on the CMakeCache.txt to tell us the
      last version of CMake that wrote the files.  This led to problems if the
      user deletes the CMakeCache.txt or we add required information to the
      files in a patch-level release of CMake (still a "feature point" release
      by modern CMake versioning convention).
      
      Ensure that we always have version-consistent platform information files
      by storing them in a subdirectory named with the CMake version.  Every
      version of CMake will do its own system and compiler identification
      checks even when a build tree has already been configured by another
      version of CMake.  Stored results will not clobber those from other
      versions of CMake which may be run again on the same tree in the future.
      Loaded results will match what the system and language modules expect.
      
      Rename the undocumented variable CMAKE_PLATFORM_ROOT_BIN to
      CMAKE_PLATFORM_INFO_DIR to clarify its purpose.  The new variable points
      at the version-specific directory while the old variable did not.
      7195aca5
  17. 22 Aug, 2012 3 commits
    • Brad King's avatar
      VS: Detect the compiler id and tool location · 66cb3356
      Brad King authored
      Configure a hand-generated Visual Studio project to build the compiler id
      source file since we cannot run the compiler command-line tool directly.
      Add a post-build command to print out the full path to the compiler tool.
      Parse the full path to the compiler tool from the build output.
      66cb3356
    • Brad King's avatar
      Xcode: Detect the compiler id and tool location · 965a69dc
      Brad King authored
      Configure a hand-generated Xcode project to build the compiler id source
      file since we cannot run the compiler command-line tool directly.  Add a
      post-build shell script phase to print out the compiler toolset build
      setting.  Run xcodebuild to compile the identification binary.  Parse
      the full path to the compiler tool from the xcodebuild output.
      965a69dc
    • Brad King's avatar
      Re-order C/C++/Fortran compiler determination logic · b8b5c834
      Brad King authored
      Re-organize CMakeDetermine(C|CXX|Fortran)Compiler.cmake to search for
      the compiler command-line tool only under generators for which it makes
      sense.  For the Visual Studio generators we do not expect to find the
      compiler tool from the environment, nor would we use the result anyway.
      
      Furthermore, set CMAKE_${lang}_COMPILER_ID_TEST_FLAGS only when it has a
      chance to be used.  Extract _CMAKE_TOOLCHAIN_LOCATION from the compiler
      path after running the compiler id step so in the future that step can
      help find the path to the compiler.
      b8b5c834
  18. 15 Aug, 2012 1 commit
  19. 13 Aug, 2012 2 commits
    • Kitware Robot's avatar
      Remove CMake-language block-end command arguments · 9db31162
      Kitware Robot authored
      Ancient versions of CMake required else(), endif(), and similar block
      termination commands to have arguments matching the command starting the
      block.  This is no longer the preferred style.
      
      Run the following shell code:
      
      for c in else endif endforeach endfunction endmacro endwhile; do
          echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/'
      done >convert.sed &&
      git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' |
      egrep -z -v '^(Utilities/cm|Source/kwsys/)' |
      egrep -z -v 'Tests/CMakeTests/While-Endwhile-' |
      xargs -0 sed -i -f convert.sed &&
      rm convert.sed
      9db31162
    • Kitware Robot's avatar
      Convert CMake-language commands to lower case · 77543bde
      Kitware Robot authored
      Ancient CMake versions required upper-case commands.  Later command
      names became case-insensitive.  Now the preferred style is lower-case.
      
      Run the following shell code:
      
      cmake --help-command-list |
      grep -v "cmake version" |
      while read c; do
          echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g'
      done >convert.sed &&
      git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' |
      egrep -z -v '^(Utilities/cm|Source/kwsys/)' |
      xargs -0 sed -i -f convert.sed &&
      rm convert.sed
      77543bde
  20. 02 Aug, 2012 2 commits
    • Brad King's avatar
      Prefer generic system compilers by default for C, C++, and Fortran · 7e58e5bb
      Brad King authored
      Teach CMake to prefer the system default compiler automatically when no
      compiler is specified.  By default use "cc" for C, "CC" for C++, and
      "f95" for Fortran.  Load a new Platform/<os>-<lang>.cmake module to
      allow each platform to specify for each language its system compiler
      name(s) and/or exclude certain names.
      
      Create Platform/(CYGWIN|Darwin|Linux|Windows)-CXX.cmake modules to
      specify "c++" as the system C++ compiler name for these platforms.  On
      systems that use case-insensitive filesystems exclude C++ compiler names
      that are distinguished from C compiler names only by case.
      
      This will change the default compiler selection for existing build
      scripts that do not specify a compiler when run on machines with
      separate system and GNU compilers both installed in the PATH.  We do not
      make this change in default behavior lightly.  However:
      
      (1) If a given build really needs specific compilers one should specify
          them explicitly e.g. by setting CC, CXX, and FC in the environment.
      
      (2) The motivating case is to prefer the system Clang on newer OS X
          systems over the older GNU compilers typically also installed.  On
          such systems the names "cc" and "c++" link to Clang.  This is the
          first platform known to CMake on which "c++" is not a GNU compiler.
          The old behavior selected "gcc" for C and "c++" C++ and therefore
          chooses GNU for C and Clang for C++ by default.  The new behavior
          selects GNU or Clang consistently for both languages on older or
          newer OS X systems, respectively.
      
      (3) Other than the motivating OS X case the conditions under which the
          behavior changes do not tend to exist in default OS installations.
          They typically occur only on non-GNU systems with manually-installed
          GNU compilers.
      
      (4) The consequences of the new behavior are not dire.  At worst the
          project fails to compile with the system compiler when it previously
          worked with the non-system GNU compiler.  Such failure is easy to
          work around (see #1).
      
      In short this change creates a more sensible default behavior everywhere
      and fixes poor default behavior on a widely-used platform at the cost of
      a modest change in behavior in less-common conditions.
      7e58e5bb
    • Brad King's avatar
      Factor common code out of CMakeDetermine(ASM|C|CXX|Fortran)Compiler · 796e3373
      Brad King authored
      The compiler candidate list selection and search code for C, C++, ASM,
      and Fortran languages was duplicated across four modules.  To look for
      compilers adjacent to already-enabled languages the C and CXX modules
      each used _CMAKE_USER_(C|CXX)_COMPILER_PATH and the ASM module used
      _CMAKE_TOOLCHAIN_LOCATION.  Since commit 4debb7ac (Bias Fortran compiler
      search with C/C++ compilers, 2009-09-09) CMake prefers Fortran compilers
      matching the vendor and directory of an enabled C or C++ compiler.
      
      Factor out the common functionality among the four languages into a new
      CMakeDetermineCompiler module.  Generalize the Fortran implementation so
      that all languages may each use the vendor and directory of the other
      languages that have already been enabled.  For now do not list any
      vendor-specific names for C, C++, or ASM so that only the directory
      preference is used for these languages (existing behavior).
      796e3373
  21. 31 Jul, 2012 1 commit
  22. 08 Jun, 2012 1 commit
  23. 02 Sep, 2011 1 commit
    • Brad King's avatar
      Set CMAKE_<lang>_COMPILER_ID for VS generators · 38aab379
      Brad King authored
      Currently the VS generators do not support Intel C/C++ .icproj files and
      the MS tools do not include a Fortran compiler.  Therefore we can always
      set the C and CXX compiler IDs to "MSVC" and the Fortran ID to "Intel".
      
      This fixes a regression in support for the Intel Fortran compiler under
      the VS plugin introduced by commit cd43636c (Modernize Intel compiler
      info on Windows, 2010-12-16).  The commit moved the compiler information
      into platform files that only load when the proper compiler id is set.
      It worked for the NMake Makefiles generator but not for the VS IDE
      generator because it did not set the compiler id.
      38aab379
  24. 26 Jan, 2011 2 commits
  25. 09 Aug, 2010 1 commit
  26. 28 Jan, 2010 1 commit
  27. 19 Nov, 2009 1 commit
  28. 01 Oct, 2009 1 commit
  29. 28 Sep, 2009 1 commit
    • Brad King's avatar
      Convert CMake non-find modules to BSD License · 3a666595
      Brad King authored
      This adds copyright/license notification blocks CMake's non-find
      modules.  Most of the modules had no notices at all.  Some had notices
      referring to the BSD license already.  This commit normalizes existing
      notices and adds missing notices.
      3a666595
  30. 08 Sep, 2008 1 commit