1. 29 Jun, 2017 3 commits
  2. 03 Apr, 2017 1 commit
  3. 07 Feb, 2017 1 commit
  4. 06 Feb, 2017 1 commit
    • Michael Maltese's avatar
      CMakeDetermineCompilerId: check with and without user-specified flags · 72ed051b
      Michael Maltese authored
      Clang may raise an error when passed a `-march=` option that doesn't
      correspond to the current target triple.  CMake cannot pass the target
      triple when determining the compiler id because it doesn't know how yet,
      but it does pass along user-specified flags.  This breaks when those
      user-specified flags include `-march=`.  Fix this use case by also
      trying to find the compiler id without the user-specified flags.
      
      Fixes: #16587
      72ed051b
  5. 02 Dec, 2016 1 commit
  6. 27 Sep, 2016 1 commit
    • Brad King's avatar
      Simplify CMake per-source license notices · 86578ecc
      Brad King authored
      Per-source copyright/license notice headers that spell out copyright holder
      names and years are hard to maintain and often out-of-date or plain wrong.
      Precise contributor information is already maintained automatically by the
      version control tool.  Ultimately it is the receiver of a file who is
      responsible for determining its licensing status, and per-source notices are
      merely a convenience.  Therefore it is simpler and more accurate for
      each source to have a generic notice of the license name and references to
      more detailed information on copyright holders and full license terms.
      
      Our `Copyright.txt` file now contains a list of Contributors whose names
      appeared source-level copyright notices.  It also references version control
      history for more precise information.  Therefore we no longer need to spell
      out the list of Contributors in each source file notice.
      
      Replace CMake per-source copyright/license notice headers with a short
      description of the license and links to `Copyright.txt` and online information
      available from "https://cmake.org/licensing".  The online URL also handles
      cases of modules being copied out of our source into other projects, so we
      can drop our notices about replacing links with full license text.
      
      Run the `Utilities/Scripts/filter-notices.bash` script to perform the majority
      of the replacements mechanically.  Manually fix up shebang lines and trailing
      newlines in a few files.  Manually update the notices in a few files that the
      script does not handle.
      86578ecc
  7. 02 Nov, 2015 1 commit
  8. 14 Apr, 2014 1 commit
  9. 10 Mar, 2014 1 commit
  10. 22 Jan, 2014 1 commit
  11. 13 Nov, 2013 1 commit
  12. 24 Oct, 2013 1 commit
    • 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
  13. 14 Jun, 2013 1 commit
  14. 15 Apr, 2013 1 commit
  15. 14 Mar, 2013 1 commit
  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. 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
  18. 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
  19. 06 Oct, 2011 1 commit
  20. 01 Mar, 2011 3 commits
  21. 23 Feb, 2011 4 commits
  22. 30 Jan, 2011 1 commit
    • Alexander Neundorf's avatar
      Rework the way assembler is handled, use the C/CXX compiler by default · 4b40d429
      Alexander Neundorf authored
      This commit changes the way how the assembler support works in cmake.
      The language "ASM" now always uses the C/Cxx compiler instead
      of the assembler directly. This fixes #8392, assembler files are
      not preprocessed.
      If one wants to use the assembler directly, the specific
      assembler "dialect" has to be enabled. I.e. to get as/gas,
      you have to use now ASM-ATT, the same way for ASM_MASM and ASM_NASM.
      
      Implemented this now for gcc.
      SunStudio, IBM, HP and Intel still todo.
      
      Alex
      4b40d429
  23. 26 Jan, 2011 1 commit
  24. 28 Dec, 2010 1 commit
    • Wojciech Migda's avatar
      Recognize the Texas Instruments DSP compiler (#11645) · f1392dc9
      Wojciech Migda authored
      The TI DSP compiler predefines "__TI_COMPILER_VERSION__".  Use this to
      identify the C and C++ compilers.  For assembler language the C compiler
      executable is used:
      
        $ cl6x -h
        TMS320C6x C/C++ Compiler v6.1.11
        Tools Copyright (c) 1996-2009 Texas Instruments Incorporated
      
      Use this command-line option and output to recognize the assembler.
      f1392dc9
  25. 17 Nov, 2010 1 commit
  26. 15 Aug, 2010 2 commits
    • Alexander Neundorf's avatar
      Detect a COMPILER_ID also for ASM. · b333779e
      Alexander Neundorf authored
      For assembler, the "compiler ID" cannot be detected by "compiling" a
      source file, since there is not source file all assemblers understand.
      Instead the function CMAKE_DETERMINE_COMPILER_ID_VENDOR() is used to
      run the assembler and check its output.
      For this the CMAKE_DETERMINE_COMPILER_ID_VENDOR() function had to be
      extended so that it creates the run directory if it doesn't exist yet.
      
      In CMakeASMInformation.cmake now also CMAKE_ASM_COMPILER_ID is used
      (but there are no such files yet, will come with the support for the
      IAR toolchain).
      
      Alex
      b333779e
    • Alexander Neundorf's avatar
      Remove trailing spaces · 691fc2ba
      Alexander Neundorf authored
      Alex
      691fc2ba
  27. 09 Aug, 2010 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. 26 Sep, 2009 1 commit