kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
CMake/Modules/CMakeDetermineFortranCompil...

202 lines
9.1 KiB
CMake
Raw Normal View History

ENH: add documentation support for modules
2005-12-14 21:51:08 +03:00
Convert CMake non-find modules to BSD License 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.
2009-09-28 19:46:51 +04:00
#=============================================================================
# Copyright 2004-2009 Kitware, Inc.
#
# 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.
#=============================================================================
Modules: Fix spelling 'To distributed' -> 'To distribute'
2010-08-07 04:48:47 +04:00
# (To distribute this file outside of CMake, substitute the full
Convert CMake non-find modules to BSD License 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.
2009-09-28 19:46:51 +04:00
# License text for the above reference.)
STYLE: fdcorrect comments about FC/CC Alex
2007-05-18 17:16:07 +04:00
# determine the compiler to use for Fortran programs
# NOTE, a generator may set CMAKE_Fortran_COMPILER before
ENH: initial fortran support
2004-08-06 22:51:41 +04:00
# loading this file to force a compiler.
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 21:42:58 +04:00
# use environment variable FC first if defined by user, next use
STYLE: fdcorrect comments about FC/CC Alex
2007-05-18 17:16:07 +04:00
# the cmake variable CMAKE_GENERATOR_FC which can be defined by a generator
ENH: initial fortran support
2004-08-06 22:51:41 +04:00
# as a default compiler
STYLE: fdcorrect comments about FC/CC Alex
2007-05-18 17:16:07 +04:00
Factor common code out of CMakeDetermine(ASM|C|CXX|Fortran)Compiler 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).
2012-08-02 19:08:55 +04:00
INCLUDE(${CMAKE_ROOT}/Modules/CMakeDetermineCompiler.cmake)
Prefer generic system compilers by default for C, C++, and Fortran 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.
2012-08-02 19:53:25 +04:00
INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-Fortran OPTIONAL)
IF(NOT CMAKE_Fortran_COMPILER_NAMES)
SET(CMAKE_Fortran_COMPILER_NAMES f95)
ENDIF()
Factor common code out of CMakeDetermine(ASM|C|CXX|Fortran)Compiler 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).
2012-08-02 19:08:55 +04:00
ENH: more uniform approach to enable language, one step closer to being able to enable a language without modifing cmake source code
2004-08-26 22:55:55 +04:00
IF(NOT CMAKE_Fortran_COMPILER)
ENH: initial fortran support
2004-08-06 22:51:41 +04:00
# prefer the environment variable CC
IF($ENV{FC} MATCHES ".+")
ENH: more uniform approach to enable language, one step closer to being able to enable a language without modifing cmake source code
2004-08-26 22:55:55 +04:00
GET_FILENAME_COMPONENT(CMAKE_Fortran_COMPILER_INIT $ENV{FC} PROGRAM PROGRAM_ARGS CMAKE_Fortran_FLAGS_ENV_INIT)
ENH: make sure flags set in CC or CXX environment variables stay with the compiler
2005-07-20 23:44:55 +04:00
IF(CMAKE_Fortran_FLAGS_ENV_INIT)
ENH: fix more than one argument passed in to compilers via environment
2006-01-25 19:41:05 +03:00
SET(CMAKE_Fortran_COMPILER_ARG1 "${CMAKE_Fortran_FLAGS_ENV_INIT}" CACHE STRING "First argument to Fortran compiler")
ENH: make sure flags set in CC or CXX environment variables stay with the compiler
2005-07-20 23:44:55 +04:00
ENDIF(CMAKE_Fortran_FLAGS_ENV_INIT)
ENH: more uniform approach to enable language, one step closer to being able to enable a language without modifing cmake source code
2004-08-26 22:55:55 +04:00
IF(EXISTS ${CMAKE_Fortran_COMPILER_INIT})
ELSE(EXISTS ${CMAKE_Fortran_COMPILER_INIT})
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 21:42:58 +04:00
MESSAGE(FATAL_ERROR "Could not find compiler set in environment variable FC:\n$ENV{FC}.")
ENH: more uniform approach to enable language, one step closer to being able to enable a language without modifing cmake source code
2004-08-26 22:55:55 +04:00
ENDIF(EXISTS ${CMAKE_Fortran_COMPILER_INIT})
ENH: initial fortran support
2004-08-06 22:51:41 +04:00
ENDIF($ENV{FC} MATCHES ".+")
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 21:42:58 +04:00
ENH: initial fortran support
2004-08-06 22:51:41 +04:00
# next try prefer the compiler specified by the generator
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 21:42:58 +04:00
IF(CMAKE_GENERATOR_FC)
ENH: more uniform approach to enable language, one step closer to being able to enable a language without modifing cmake source code
2004-08-26 22:55:55 +04:00
IF(NOT CMAKE_Fortran_COMPILER_INIT)
SET(CMAKE_Fortran_COMPILER_INIT ${CMAKE_GENERATOR_FC})
ENDIF(NOT CMAKE_Fortran_COMPILER_INIT)
ENH: initial fortran support
2004-08-06 22:51:41 +04:00
ENDIF(CMAKE_GENERATOR_FC)
BUG: Search for the compiler only once and store a full path to it in the cache. This avoids problems with the case of locations in the PATH variable on Windows that change the compiler name when CMake is re-run. CMakeFiles/CMake*Compiler.cmake files should hold the full path to the compiler always.
2006-08-29 21:59:15 +04:00
# finally list compilers to try
Factor common code out of CMakeDetermine(ASM|C|CXX|Fortran)Compiler 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).
2012-08-02 19:08:55 +04:00
IF(NOT CMAKE_Fortran_COMPILER_INIT)
ENH: try to find fortran compiler before adding the test
2004-08-27 00:34:06 +04:00
# Known compilers:
Add a fortran test if there is a fortran compiler
2004-08-26 23:50:39 +04:00
# f77/f90/f95: generic compiler names
# g77: GNU Fortran 77 compiler
# gfortran: putative GNU Fortran 95+ compiler (in progress)
# fort77: native F77 compiler under HP-UX (and some older Crays)
# frt: Fujitsu F77 compiler
Detect PathScale Fortran compiler tools Include names pathf(90|95|2003) in the search for a Fortran compiler. Also associate the names with PathScale for the vendor-specific search.
2010-04-26 21:28:52 +04:00
# pathf90/pathf95/pathf2003: PathScale Fortran compiler
detect "pgfortran" as PGI Fortran compiler (#12425) See http://www.pgroup.com/doc/pgiug.pdf, page xviii.
2012-02-08 23:26:27 +04:00
# pgf77/pgf90/pgf95/pgfortran: Portland Group F77/F90/F95 compilers
Add a fortran test if there is a fortran compiler
2004-08-26 23:50:39 +04:00
# xlf/xlf90/xlf95: IBM (AIX) F77/F90/F95 compilers
# lf95: Lahey-Fujitsu F95 compiler
# fl32: Microsoft Fortran 77 "PowerStation" compiler
# af77: Apogee F77 compiler for Intergraph hardware running CLIX
# epcf90: "Edinburgh Portable Compiler" F90
# fort: Compaq (now HP) Fortran 90/95 compiler for Tru64 and Linux/Alpha
# ifc: Intel Fortran 95 compiler for Linux/x86
# efc: Intel Fortran 95 compiler for IA64
ENH: try to find fortran compiler before adding the test
2004-08-27 00:34:06 +04:00
#
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 21:42:58 +04:00
# The order is 95 or newer compilers first, then 90,
ENH: try to find fortran compiler before adding the test
2004-08-27 00:34:06 +04:00
# then 77 or older compilers, gnu is always last in the group,
# so if you paid for a compiler it is picked by default.
BUG: Search for the compiler only once and store a full path to it in the cache. This avoids problems with the case of locations in the PATH variable on Windows that change the compiler name when CMake is re-run. CMakeFiles/CMake*Compiler.cmake files should hold the full path to the compiler always.
2006-08-29 21:59:15 +04:00
SET(CMAKE_Fortran_COMPILER_LIST
detect "pgfortran" as PGI Fortran compiler (#12425) See http://www.pgroup.com/doc/pgiug.pdf, page xviii.
2012-02-08 23:26:27 +04:00
ifort ifc af95 af90 efc f95 pathf2003 pathf95 pgf95 pgfortran lf95 xlf95
fort gfortran gfortran-4 g95 f90 pathf90 pgf90 xlf90 epcf90 fort77
Detect PathScale Fortran compiler tools Include names pathf(90|95|2003) in the search for a Fortran compiler. Also associate the names with PathScale for the vendor-specific search.
2010-04-26 21:28:52 +04:00
frt pgf77 xlf fl32 af77 g77 f77
BUG: Search for the compiler only once and store a full path to it in the cache. This avoids problems with the case of locations in the PATH variable on Windows that change the compiler name when CMake is re-run. CMakeFiles/CMake*Compiler.cmake files should hold the full path to the compiler always.
2006-08-29 21:59:15 +04:00
)
Bias Fortran compiler search with C/C++ compilers When CMAKE_Fortran_COMPILER and ENV{FC} are not defined CMake searches for an available Fortran compiler. This commit teaches the search code to look for compiler executables next to the C and C++ compilers if they are already found. Furthermore, we bias the compiler executable name preference order based on the vendor of the C and C++ compilers, which increases the chance of finding a compatible compiler by default.
2009-09-10 00:39:47 +04:00
# Vendor-specific compiler names.
SET(_Fortran_COMPILER_NAMES_GNU gfortran gfortran-4 g95 g77)
SET(_Fortran_COMPILER_NAMES_Intel ifort ifc efc)
Add Absoft Fortran compiler id and basic flags Identification at preprocessing time depends on definition of __ABSOFT__ to be added in service pack V11.1.2 of the compiler.
2011-01-21 21:09:22 +03:00
SET(_Fortran_COMPILER_NAMES_Absoft af95 af90 af77)
detect "pgfortran" as PGI Fortran compiler (#12425) See http://www.pgroup.com/doc/pgiug.pdf, page xviii.
2012-02-08 23:26:27 +04:00
SET(_Fortran_COMPILER_NAMES_PGI pgf95 pgfortran pgf90 pgf77)
Detect PathScale Fortran compiler tools Include names pathf(90|95|2003) in the search for a Fortran compiler. Also associate the names with PathScale for the vendor-specific search.
2010-04-26 21:28:52 +04:00
SET(_Fortran_COMPILER_NAMES_PathScale pathf2003 pathf95 pathf90)
Bias Fortran compiler search with C/C++ compilers When CMAKE_Fortran_COMPILER and ENV{FC} are not defined CMake searches for an available Fortran compiler. This commit teaches the search code to look for compiler executables next to the C and C++ compilers if they are already found. Furthermore, we bias the compiler executable name preference order based on the vendor of the C and C++ compilers, which increases the chance of finding a compatible compiler by default.
2009-09-10 00:39:47 +04:00
SET(_Fortran_COMPILER_NAMES_XL xlf)
SET(_Fortran_COMPILER_NAMES_VisualAge xlf95 xlf90 xlf)
Factor common code out of CMakeDetermine(ASM|C|CXX|Fortran)Compiler 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).
2012-08-02 19:08:55 +04:00
ENDIF()
Bias Fortran compiler search with C/C++ compilers When CMAKE_Fortran_COMPILER and ENV{FC} are not defined CMake searches for an available Fortran compiler. This commit teaches the search code to look for compiler executables next to the C and C++ compilers if they are already found. Furthermore, we bias the compiler executable name preference order based on the vendor of the C and C++ compilers, which increases the chance of finding a compatible compiler by default.
2009-09-10 00:39:47 +04:00
Factor common code out of CMakeDetermine(ASM|C|CXX|Fortran)Compiler 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).
2012-08-02 19:08:55 +04:00
_cmake_find_compiler(Fortran)
Bias Fortran compiler search with C/C++ compilers When CMAKE_Fortran_COMPILER and ENV{FC} are not defined CMake searches for an available Fortran compiler. This commit teaches the search code to look for compiler executables next to the C and C++ compilers if they are already found. Furthermore, we bias the compiler executable name preference order based on the vendor of the C and C++ compilers, which increases the chance of finding a compatible compiler by default.
2009-09-10 00:39:47 +04:00
BUG: fix for #8089, fix rebuild with fortran and -D
2008-11-15 01:45:56 +03:00
ELSE(NOT CMAKE_Fortran_COMPILER)
# we only get here if CMAKE_Fortran_COMPILER was specified using -D or a pre-made CMakeCache.txt
# (e.g. via ctest) or set in CMAKE_TOOLCHAIN_FILE
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 21:42:58 +04:00
# if CMAKE_Fortran_COMPILER is a list of length 2, use the first item as
BUG: fix for #8089, fix rebuild with fortran and -D
2008-11-15 01:45:56 +03:00
# CMAKE_Fortran_COMPILER and the 2nd one as CMAKE_Fortran_COMPILER_ARG1
LIST(LENGTH CMAKE_Fortran_COMPILER _CMAKE_Fortran_COMPILER_LIST_LENGTH)
IF("${_CMAKE_Fortran_COMPILER_LIST_LENGTH}" EQUAL 2)
LIST(GET CMAKE_Fortran_COMPILER 1 CMAKE_Fortran_COMPILER_ARG1)
LIST(GET CMAKE_Fortran_COMPILER 0 CMAKE_Fortran_COMPILER)
ENDIF("${_CMAKE_Fortran_COMPILER_LIST_LENGTH}" EQUAL 2)
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 21:42:58 +04:00
# if a compiler was specified by the user but without path,
BUG: fix for #8089, fix rebuild with fortran and -D
2008-11-15 01:45:56 +03:00
# now try to find it with the full path
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 21:42:58 +04:00
# if it is found, force it into the cache,
BUG: fix for #8089, fix rebuild with fortran and -D
2008-11-15 01:45:56 +03:00
# if not, don't overwrite the setting (which was given by the user) with "NOTFOUND"
# if the C compiler already had a path, reuse it for searching the CXX compiler
GET_FILENAME_COMPONENT(_CMAKE_USER_Fortran_COMPILER_PATH "${CMAKE_Fortran_COMPILER}" PATH)
IF(NOT _CMAKE_USER_Fortran_COMPILER_PATH)
FIND_PROGRAM(CMAKE_Fortran_COMPILER_WITH_PATH NAMES ${CMAKE_Fortran_COMPILER})
MARK_AS_ADVANCED(CMAKE_Fortran_COMPILER_WITH_PATH)
IF(CMAKE_Fortran_COMPILER_WITH_PATH)
SET(CMAKE_Fortran_COMPILER ${CMAKE_Fortran_COMPILER_WITH_PATH}
CACHE STRING "Fortran compiler" FORCE)
ENDIF(CMAKE_Fortran_COMPILER_WITH_PATH)
ENDIF(NOT _CMAKE_USER_Fortran_COMPILER_PATH)
ENH: more uniform approach to enable language, one step closer to being able to enable a language without modifing cmake source code
2004-08-26 22:55:55 +04:00
ENDIF(NOT CMAKE_Fortran_COMPILER)
ENH: initial fortran support
2004-08-06 22:51:41 +04:00
Remove trailing whitespace from most CMake and C/C++ code Our Git commit hooks disallow modification or addition of lines with trailing whitespace. Wipe out all remnants of trailing whitespace everywhere except third-party code. Run the following shell code: git ls-files -z -- \ bootstrap doxygen.config '*.readme' \ '*.c' '*.cmake' '*.cpp' '*.cxx' \ '*.el' '*.f' '*.f90' '*.h' '*.in' '*.in.l' '*.java' \ '*.mm' '*.pike' '*.py' '*.txt' '*.vim' | egrep -z -v '^(Utilities/cm|Source/(kwsys|CursesDialog/form)/)' | egrep -z -v '^(Modules/CPack\..*\.in)' | xargs -0 sed -i 's/ \+$//'
2012-08-13 21:42:58 +04:00
MARK_AS_ADVANCED(CMAKE_Fortran_COMPILER)
ENH: initial fortran support
2004-08-06 22:51:41 +04:00
ENH: Merging CompilerId updates from branch CMake-Modules-CompilerId to the main tree. Changes between CMake-Modules-CompilerId-mp1 and CMake-Modules-CompilerId-mp2 are included.
2007-05-03 16:24:32 +04:00
# Build a small source file to identify the compiler.
ENH: do not check for gnu for visual studio
2004-09-15 18:32:28 +04:00
IF(${CMAKE_GENERATOR} MATCHES "Visual Studio")
ENH: Merging CompilerId updates from branch CMake-Modules-CompilerId to the main tree. Changes between CMake-Modules-CompilerId-mp1 and CMake-Modules-CompilerId-mp2 are included.
2007-05-03 16:24:32 +04:00
SET(CMAKE_Fortran_COMPILER_ID_RUN 1)
SET(CMAKE_Fortran_PLATFORM_ID "Windows")
Set CMAKE_<lang>_COMPILER_ID for VS generators 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.
2011-09-02 16:37:05 +04:00
SET(CMAKE_Fortran_COMPILER_ID "Intel")
ENH: Merging CompilerId updates from branch CMake-Modules-CompilerId to the main tree. Changes between CMake-Modules-CompilerId-mp1 and CMake-Modules-CompilerId-mp2 are included.
2007-05-03 16:24:32 +04:00
ENDIF(${CMAKE_GENERATOR} MATCHES "Visual Studio")
IF(NOT CMAKE_Fortran_COMPILER_ID_RUN)
SET(CMAKE_Fortran_COMPILER_ID_RUN 1)
ENH: Add support to CMAKE_DETERMINE_COMPILER_ID macro to try building the id source more than once with different extra flags added to the compiler. Use the support to correctly identify the Intel Fortran compiler on windows which does not preprocess by default without special flags.
2008-01-07 18:27:28 +03:00
# Each entry in this list is a set of extra flags to try
# adding to the compile line to see if it helps produce
# a valid identification executable.
SET(CMAKE_Fortran_COMPILER_ID_TEST_FLAGS
ENH: When detecting the compiler id try compiling only to an object file.
2008-02-12 01:00:54 +03:00
# Try compiling to an object file only.
"-c"
ENH: Add support to CMAKE_DETERMINE_COMPILER_ID macro to try building the id source more than once with different extra flags added to the compiler. Use the support to correctly identify the Intel Fortran compiler on windows which does not preprocess by default without special flags.
2008-01-07 18:27:28 +03:00
# Intel on windows does not preprocess by default.
"-fpp"
)
Recognize the Compaq Fortran compiler The compiler documents symbols _DF_VERSION_ and _VF_VERSION_ but they do not seem to be available to the preprocessor. Instead we add a vendor query table entry for Compaq. Running "f90 -what" produces Compaq Visual Fortran Optimizing Compiler Version ... This clearly identifies the compiler.
2010-02-02 15:21:36 +03:00
# Table of per-vendor compiler id flags with expected output.
LIST(APPEND CMAKE_Fortran_COMPILER_ID_VENDORS Compaq)
SET(CMAKE_Fortran_COMPILER_ID_VENDOR_FLAGS_Compaq "-what")
SET(CMAKE_Fortran_COMPILER_ID_VENDOR_REGEX_Compaq "Compaq Visual Fortran")
Recognize the NAG Fortran compiler The Numerical Algorithms Group (NAG) Fortran compiler does not document a preprocessor macro to identify it. Check for identifying output using the -V option.
2010-12-10 01:11:18 +03:00
LIST(APPEND CMAKE_Fortran_COMPILER_ID_VENDORS NAG) # Numerical Algorithms Group
SET(CMAKE_Fortran_COMPILER_ID_VENDOR_FLAGS_NAG "-V")
SET(CMAKE_Fortran_COMPILER_ID_VENDOR_REGEX_NAG "NAG Fortran Compiler")
Recognize the Compaq Fortran compiler The compiler documents symbols _DF_VERSION_ and _VF_VERSION_ but they do not seem to be available to the preprocessor. Instead we add a vendor query table entry for Compaq. Running "f90 -what" produces Compaq Visual Fortran Optimizing Compiler Version ... This clearly identifies the compiler.
2010-02-02 15:21:36 +03:00
ENH: Merging CompilerId updates from branch CMake-Modules-CompilerId to the main tree. Changes between CMake-Modules-CompilerId-mp1 and CMake-Modules-CompilerId-mp2 are included.
2007-05-03 16:24:32 +04:00
# Try to identify the compiler.
SET(CMAKE_Fortran_COMPILER_ID)
INCLUDE(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerId.cmake)
ENH: Identify Fortran compilers with fixed format This enhances the Fortran compiler id detection by using a source that can compile either as free or fixed format. As long as the compiler knows it should preprocess the source file (.F) the identification can work. Even free-format compilers may try fixed-format parsing if the user specifies certain flags, so we must support both.
2009-06-25 16:45:19 +04:00
CMAKE_DETERMINE_COMPILER_ID(Fortran FFLAGS CMakeFortranCompilerId.F)
ENH: Merging CompilerId updates from branch CMake-Modules-CompilerId to the main tree. Changes between CMake-Modules-CompilerId-mp1 and CMake-Modules-CompilerId-mp2 are included.
2007-05-03 16:24:32 +04:00
# Fall back to old is-GNU test.
IF(NOT CMAKE_Fortran_COMPILER_ID)
EXEC_PROGRAM(${CMAKE_Fortran_COMPILER}
ARGS ${CMAKE_Fortran_COMPILER_ID_FLAGS_LIST} -E "\"${CMAKE_ROOT}/Modules/CMakeTestGNU.c\""
OUTPUT_VARIABLE CMAKE_COMPILER_OUTPUT RETURN_VALUE CMAKE_COMPILER_RETURN)
IF(NOT CMAKE_COMPILER_RETURN)
IF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" )
SET(CMAKE_Fortran_COMPILER_ID "GNU")
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
"Determining if the Fortran compiler is GNU succeeded with "
"the following output:\n${CMAKE_COMPILER_OUTPUT}\n\n")
ELSE("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" )
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
"Determining if the Fortran compiler is GNU failed with "
"the following output:\n${CMAKE_COMPILER_OUTPUT}\n\n")
ENDIF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" )
IF(NOT CMAKE_Fortran_PLATFORM_ID)
IF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_MINGW.*" )
SET(CMAKE_Fortran_PLATFORM_ID "MinGW")
ENDIF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_MINGW.*" )
IF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_CYGWIN.*" )
SET(CMAKE_Fortran_PLATFORM_ID "Cygwin")
ENDIF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_CYGWIN.*" )
ENDIF(NOT CMAKE_Fortran_PLATFORM_ID)
ENDIF(NOT CMAKE_COMPILER_RETURN)
ENDIF(NOT CMAKE_Fortran_COMPILER_ID)
ENH: initial fortran support
2004-08-06 22:51:41 +04:00
ENH: Merging CompilerId updates from branch CMake-Modules-CompilerId to the main tree. Changes between CMake-Modules-CompilerId-mp1 and CMake-Modules-CompilerId-mp2 are included.
2007-05-03 16:24:32 +04:00
# Set old compiler and platform id variables.
IF("${CMAKE_Fortran_COMPILER_ID}" MATCHES "GNU")
SET(CMAKE_COMPILER_IS_GNUG77 1)
ENDIF("${CMAKE_Fortran_COMPILER_ID}" MATCHES "GNU")
IF("${CMAKE_Fortran_PLATFORM_ID}" MATCHES "MinGW")
SET(CMAKE_COMPILER_IS_MINGW 1)
ELSEIF("${CMAKE_Fortran_PLATFORM_ID}" MATCHES "Cygwin")
SET(CMAKE_COMPILER_IS_CYGWIN 1)
ENDIF("${CMAKE_Fortran_PLATFORM_ID}" MATCHES "MinGW")
ENDIF(NOT CMAKE_Fortran_COMPILER_ID_RUN)
ENH: initial fortran support
2004-08-06 22:51:41 +04:00
ENH: merge CMake-CrossCompileBasic to HEAD -add a RESULT_VARIABLE to INCLUDE() -add CMAKE_TOOLCHAIN_FILE for specifiying your (potentially crosscompiling) toolchain -have TRY_RUN() complain if you try to use it in crosscompiling mode (which were compiled but cannot run on this system) -use CMAKE_EXECUTABLE_SUFFIX in TRY_RUN(), probably TRY_RUN won't be able to run the executables if they have a different suffix because they are probably crosscompiled, but nevertheless it should be able to find them -make several cmake variables presettable by the user: CMAKE_C/CXX_COMPILER, CMAKE_C/CXX_OUTPUT_EXTENSION, CMAKE_SYSTEM_NAME, CMAKE_SYSTEM_INFO_FILE -support prefix for GNU toolchains (arm-elf-gcc, arm-elf-ar, arm-elf-strip etc.) -move ranlib on OSX from the file command to a command in executed in cmake_install.cmake -add support for stripping during install in cmake_install.cmake -split out cl.cmake from Windows-cl.cmake, first (very incomplete) step to support MS crosscompiling tools -remove stdio.h from the simple C program which checks if the compiler works, since this may not exist for some embedded platforms -create a new CMakeFindBinUtils.cmake which collects the search fro ar, ranlib, strip, ld, link, install_name_tool and other tools like these -add support for CMAKE_FIND_ROOT_PATH for all FIND_XXX commands, which is a list of directories which will be prepended to all search directories, right now as a cmake variable, turning it into a global cmake property may need some more work -remove cmTestTestHandler::TryExecutable(), it's unused -split cmFileCommand::HandleInstall() into slightly smaller functions Alex
2007-05-17 21:20:44 +04:00
INCLUDE(CMakeFindBinUtils)
Detect Fortran target architecture on Windows Commit 4430bccc (Change the way 32/64 bit compiles are detected with MSVC and intel, 2009-11-19) added detection of the target processor to C and CXX language builds with MS and Intel tools. Do the same for Intel Fortran for Windows (ifort). Use /machine:<arch> to link executables.
2010-12-16 17:33:06 +03:00
IF(MSVC_Fortran_ARCHITECTURE_ID)
SET(SET_MSVC_Fortran_ARCHITECTURE_ID
"SET(MSVC_Fortran_ARCHITECTURE_ID ${MSVC_Fortran_ARCHITECTURE_ID})")
ENDIF()
ENH: initial fortran support
2004-08-06 22:51:41 +04:00
# configure variables set in this file for fast reload later on
BUG: When forcing the C and CXX compilers do not try to detect the ABI information. Cleanup configured language compiler info files by always using @ONLY. This addresses bug#6297.
2008-02-04 01:24:50 +03:00
CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeFortranCompiler.cmake.in
${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeFortranCompiler.cmake
BUG: When configuring compiler information files into the CMakeFiles directory in the project build tree, use IMMEDIATE option for CONFIGURE_FILE explicitly. It is needed in case the user sets CMAKE_BACKWARDS_COMPATIBILITY to 2.0 or lower.
2008-02-04 18:04:23 +03:00
@ONLY IMMEDIATE # IMMEDIATE must be here for compatibility mode <= 2.0
)
ENH: more uniform approach to enable language, one step closer to being able to enable a language without modifing cmake source code
2004-08-26 22:55:55 +04:00
SET(CMAKE_Fortran_COMPILER_ENV_VAR "FC")