reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2024-12-04 09:54:15 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge topic 'cmake-tutorial'

Browse Source 
6f6a32a0f6 Tutorial: Improve Step 9
6a35d630dc Tutorial: Improve Step 8
61d4d990d6 Tutorial: Improve Step 7
a36731c634 Tutorial: Improve Step 6
df9cdf629c Tutorial: Improve Step 5
442c0f0d46 Tutorial: Improve Step 4
bc64401c3d Tutorial: Improve Step 3
49ce4d6ff4 Tutorial: Improve Step 2
...

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !3528
This commit is contained in:
Brad King 2019-08-20 13:16:35 +00:00 committed by Kitware Robot
commit b80417f0fd
59 changed files with 461 additions and 507 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
Help/guide/tutorial/Complete/CMakeLists.txt
View File

@ -1,5 +1,7 @@
cmake_minimum_required(VERSION 3.15)
project(Tutorial)
# set the project name and version
project(Tutorial VERSION 1.0)
add_library(tutorial_compiler_flags INTERFACE)
target_compile_features(tutorial_compiler_flags INTERFACE cxx_std_11)
@ -13,10 +15,6 @@ target_compile_options(tutorial_compiler_flags INTERFACE
"$<${msvc_cxx}:$<BUILD_INTERFACE:-W3>>"
)
# set the version number
set(Tutorial_VERSION_MAJOR 1)
set(Tutorial_VERSION_MINOR 0)
# control where the static and shared libraries are built so that on windows
# we don't need to tinker with the path to run the executable
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}")
@ -32,17 +30,14 @@ elseif(UNIX)
endif()
# configure a header file to pass the version number only
configure_file(
"${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
"${PROJECT_BINARY_DIR}/TutorialConfig.h"
)
configure_file(TutorialConfig.h.in TutorialConfig.h)
# add the MathFunctions library
add_subdirectory(MathFunctions)
# add the executable
add_executable(Tutorial tutorial.cxx)
target_link_libraries(Tutorial MathFunctions)
target_link_libraries(Tutorial PUBLIC MathFunctions)
# add the binary tree to the search path for include files
# so that we will find TutorialConfig.h

7
Help/guide/tutorial/Complete/CTestConfig.cmake Normal file
View File

@ -0,0 +1,7 @@
set(CTEST_PROJECT_NAME "CMakeTutorial")
set(CTEST_NIGHTLY_START_TIME "00:00:00 EST")
set(CTEST_DROP_METHOD "http")
set(CTEST_DROP_SITE "my.cdash.org")
set(CTEST_DROP_LOCATION "/submit.php?project=CMakeTutorial")
set(CTEST_DROP_SITE_CDASH TRUE)

14
Help/guide/tutorial/Complete/MathFunctions/CMakeLists.txt
View File

@ -13,11 +13,7 @@ target_include_directories(MathFunctions
option(USE_MYMATH "Use tutorial provided math implementation" ON)
if(USE_MYMATH)
# does this system provide the log and exp functions?
include(CheckSymbolExists)
set(CMAKE_REQUIRED_LIBRARIES "m")
check_symbol_exists(log "math.h" HAVE_LOG)
check_symbol_exists(exp "math.h" HAVE_EXP)
target_compile_definitions(MathFunctions PRIVATE "USE_MYMATH")
# first we add the executable that generates the table
add_executable(MakeTable MakeTable.cxx)
@ -41,18 +37,12 @@ if(USE_MYMATH)
${CMAKE_CURRENT_BINARY_DIR}
)
# state that SqrtLibrary need PIC when the default is shared libraries
set_target_properties(SqrtLibrary PROPERTIES
POSITION_INDEPENDENT_CODE ${BUILD_SHARED_LIBS}
)
target_link_libraries(SqrtLibrary PUBLIC tutorial_compiler_flags)
target_compile_definitions(MathFunctions PRIVATE "USE_MYMATH")
if(HAVE_LOG AND HAVE_EXP)
target_compile_definitions(SqrtLibrary
PRIVATE "HAVE_LOG" "HAVE_EXP")
endif()
target_link_libraries(MathFunctions PRIVATE SqrtLibrary)
endif()

13
Help/guide/tutorial/Complete/MathFunctions/mysqrt.cxx
View File

@ -4,8 +4,6 @@
// include the generated table
#include "Table.h"
#include <cmath>
namespace mathfunctions {
namespace detail {
// a hack square root calculation using simple operations
@ -15,20 +13,13 @@ double mysqrt(double x)
return 0;
}
// if we have both log and exp then use them
#if defined(HAVE_LOG) && defined(HAVE_EXP)
double result = exp(log(x) * 0.5);
std::cout << "Computing sqrt of " << x << " to be " << result << " using log"
<< std::endl;
#else
// use the table to help find an initial value
double result = x;
if (x >= 1 && x < 10) {
std::cout << "Use the table to help find an initial value " << std::endl;
result = sqrtTable[static_cast<int>(x)];
}
// if we have both log and exp then use them
// do ten iterations
for (int i = 0; i < 10; ++i) {
if (result <= 0) {
@ -38,7 +29,7 @@ double mysqrt(double x)
result = result + 0.5 * delta / result;
std::cout << "Computing sqrt of " << x << " to be " << result << std::endl;
}
#endif
return result;
}
}

2
Help/guide/tutorial/Complete/TutorialConfig.h.in
View File

@ -1,3 +1,3 @@
// the configured version number
// the configured options and settings for Tutorial
#define Tutorial_VERSION_MAJOR @Tutorial_VERSION_MAJOR@
#define Tutorial_VERSION_MINOR @Tutorial_VERSION_MINOR@

5
Help/guide/tutorial/Complete/tutorial.cxx
View File

@ -15,10 +15,11 @@ int main(int argc, char* argv[])
return 1;
}
double inputValue = std::stod(argv[1]);
// convert input to double
const double inputValue = std::stod(argv[1]);
// calculate square root
const double outputValue = mathfunctions::sqrt(inputValue);
std::cout << "The square root of " << inputValue << " is " << outputValue
<< std::endl;
return 0;

2
Help/guide/tutorial/Consumer/CMakeLists.txt
View File

@ -1,4 +1,4 @@
cmake_minimum_required(VERSION 3.3)
cmake_minimum_required(VERSION 3.10)
if(NOT DEFINED CMAKE_CXX_STANDARD)
set(CMAKE_CXX_STANDARD 11)

16
Help/guide/tutorial/MultiPackage/CMakeLists.txt
View File

@ -1,12 +1,11 @@
cmake_minimum_required(VERSION 3.3)
project(Tutorial)
cmake_minimum_required(VERSION 3.10)
# set the project name and version
project(Tutorial VERSION 1.0)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED True)
# set the version number
set(Tutorial_VERSION_MAJOR 1)
set(Tutorial_VERSION_MINOR 0)
# control where the static and shared libraries are built so that on windows
# we don't need to tinker with the path to run the executable
@ -23,17 +22,14 @@ elseif(UNIX)
endif()
# configure a header file to pass the version number only
configure_file(
"${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
"${PROJECT_BINARY_DIR}/TutorialConfig.h"
)
configure_file(TutorialConfig.h.in TutorialConfig.h)
# add the MathFunctions library
add_subdirectory(MathFunctions)
# add the executable
add_executable(Tutorial tutorial.cxx)
target_link_libraries(Tutorial MathFunctions)
target_link_libraries(Tutorial PUBLIC MathFunctions)
# add the binary tree to the search path for include files
# so that we will find TutorialConfig.h

13
Help/guide/tutorial/MultiPackage/MathFunctions/CMakeLists.txt
View File

@ -13,11 +13,7 @@ target_include_directories(MathFunctions
option(USE_MYMATH "Use tutorial provided math implementation" ON)
if(USE_MYMATH)
# does this system provide the log and exp functions?
include(CheckSymbolExists)
set(CMAKE_REQUIRED_LIBRARIES "m")
check_symbol_exists(log "math.h" HAVE_LOG)
check_symbol_exists(exp "math.h" HAVE_EXP)
target_compile_definitions(MathFunctions PRIVATE "USE_MYMATH")
# first we add the executable that generates the table
add_executable(MakeTable MakeTable.cxx)
@ -40,19 +36,14 @@ if(USE_MYMATH)
${CMAKE_CURRENT_BINARY_DIR}
)
# state that SqrtLibrary need PIC when the default is shared libraries
set_target_properties(SqrtLibrary PROPERTIES
POSITION_INDEPENDENT_CODE ${BUILD_SHARED_LIBS}
)
target_compile_definitions(SqrtLibrary PRIVATE
"$<$<BOOL:${HAVE_LOG}>:HAVE_LOG>"
"$<$<BOOL:${HAVE_EXP}>:HAVE_EXP>"
)
target_link_libraries(MathFunctions PRIVATE SqrtLibrary)
endif()
target_compile_definitions(MathFunctions PRIVATE "$<$<BOOL:${USE_MYMATH}>:USE_MYMATH>")
# define the symbol stating we are using the declspec(dllexport) when
# building on windows
target_compile_definitions(MathFunctions PRIVATE "EXPORTING_MYMATH")

10
Help/guide/tutorial/MultiPackage/MathFunctions/mysqrt.cxx
View File

@ -4,8 +4,6 @@
// include the generated table
#include "Table.h"
#include <cmath>
namespace mathfunctions {
namespace detail {
// a hack square root calculation using simple operations
@ -15,12 +13,6 @@ double mysqrt(double x)
return 0;
}
// if we have both log and exp then use them
#if defined(HAVE_LOG) && defined(HAVE_EXP)
double result = exp(log(x) * 0.5);
std::cout << "Computing sqrt of " << x << " to be " << result << " using log"
<< std::endl;
#else
// use the table to help find an initial value
double result = x;
if (x >= 1 && x < 10) {
@ -38,7 +30,7 @@ double mysqrt(double x)
result = result + 0.5 * delta / result;
std::cout << "Computing sqrt of " << x << " to be " << result << std::endl;
}
#endif
return result;
}
}

2
Help/guide/tutorial/MultiPackage/tutorial.cxx
View File

@ -1,6 +1,5 @@
// A simple program that computes the square root of a number
#include <iostream>
#include <sstream>
#include <string>
#include "MathFunctions.h"
@ -15,6 +14,7 @@ int main(int argc, char* argv[])
return 1;
}
// convert input to double
double inputValue = std::stod(argv[1]);
const double outputValue = mathfunctions::sqrt(inputValue);

3
Help/guide/tutorial/Step1/CMakeLists.txt
View File

@ -1,3 +0,0 @@
project(Tutorial)
add_executable(Tutorial tutorial.cxx)

3
Help/guide/tutorial/Step1/TutorialConfig.h.in
View File

@ -1,3 +0,0 @@
// the configured options and settings for Tutorial
#define Tutorial_VERSION_MAJOR @Tutorial_VERSION_MAJOR@
#define Tutorial_VERSION_MINOR @Tutorial_VERSION_MINOR@

6
Help/guide/tutorial/Step1/tutorial.cxx
View File

@ -11,9 +11,11 @@ int main(int argc, char* argv[])
return 1;
}
double inputValue = atof(argv[1]);
// convert input to double
const double inputValue = atof(argv[1]);
double outputValue = sqrt(inputValue);
// calculate square root
const double outputValue = sqrt(inputValue);
std::cout << "The square root of " << inputValue << " is " << outputValue
<< std::endl;
return 0;

20
Help/guide/tutorial/Step10/CMakeLists.txt
View File

@ -1,13 +1,12 @@
cmake_minimum_required(VERSION 3.3)
project(Tutorial)
cmake_minimum_required(VERSION 3.10)
# set the project name and version
project(Tutorial VERSION 1.0)
# specify the C++ standard
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED True)
# Set the version number
set(Tutorial_VERSION_MAJOR 1)
set(Tutorial_VERSION_MINOR 0)
# control where the static and shared libraries are built so that on windows
# we don't need to tinker with the path to run the executable
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}")
@ -17,17 +16,14 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}")
option(BUILD_SHARED_LIBS "Build using shared libraries" ON)
# configure a header file to pass the version number only
configure_file(
"${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
"${PROJECT_BINARY_DIR}/TutorialConfig.h"
)
configure_file(TutorialConfig.h.in TutorialConfig.h)
# add the MathFunctions library
add_subdirectory(MathFunctions)
# add the executable
add_executable(Tutorial tutorial.cxx)
target_link_libraries(Tutorial MathFunctions)
target_link_libraries(Tutorial PUBLIC MathFunctions)
# add the binary tree to the search path for include files
# so that we will find TutorialConfig.h
@ -42,7 +38,7 @@ install(FILES "${PROJECT_BINARY_DIR}/TutorialConfig.h"
)
# enable testing
enable_testing()
include(CTest)
# does the application run
add_test(NAME Runs COMMAND Tutorial 25)

7
Help/guide/tutorial/Step10/CTestConfig.cmake Normal file
View File

@ -0,0 +1,7 @@
set(CTEST_PROJECT_NAME "CMakeTutorial")
set(CTEST_NIGHTLY_START_TIME "00:00:00 EST")
set(CTEST_DROP_METHOD "http")
set(CTEST_DROP_SITE "my.cdash.org")
set(CTEST_DROP_LOCATION "/submit.php?project=CMakeTutorial")
set(CTEST_DROP_SITE_CDASH TRUE)

12
Help/guide/tutorial/Step10/MathFunctions/CMakeLists.txt
View File

@ -11,11 +11,7 @@ target_include_directories(MathFunctions
option(USE_MYMATH "Use tutorial provided math implementation" ON)
if(USE_MYMATH)
# does this system provide the log and exp functions?
include(CheckSymbolExists)
set(CMAKE_REQUIRED_LIBRARIES "m")
check_symbol_exists(log "math.h" HAVE_LOG)
check_symbol_exists(exp "math.h" HAVE_EXP)
target_compile_definitions(MathFunctions PRIVATE "USE_MYMATH")
# first we add the executable that generates the table
add_executable(MakeTable MakeTable.cxx)
@ -43,12 +39,6 @@ if(USE_MYMATH)
POSITION_INDEPENDENT_CODE ${BUILD_SHARED_LIBS}
)
target_compile_definitions(MathFunctions PRIVATE "USE_MYMATH")
if(HAVE_LOG AND HAVE_EXP)
target_compile_definitions(SqrtLibrary
PRIVATE "HAVE_LOG" "HAVE_EXP")
endif()
target_link_libraries(MathFunctions PRIVATE SqrtLibrary)
endif()

13
Help/guide/tutorial/Step10/MathFunctions/mysqrt.cxx
View File

@ -4,8 +4,6 @@
// include the generated table
#include "Table.h"
#include <cmath>
namespace mathfunctions {
namespace detail {
// a hack square root calculation using simple operations
@ -15,20 +13,13 @@ double mysqrt(double x)
return 0;
}
// if we have both log and exp then use them
#if defined(HAVE_LOG) && defined(HAVE_EXP)
double result = exp(log(x) * 0.5);
std::cout << "Computing sqrt of " << x << " to be " << result << " using log"
<< std::endl;
#else
// use the table to help find an initial value
double result = x;
if (x >= 1 && x < 10) {
std::cout << "Use the table to help find an initial value " << std::endl;
result = sqrtTable[static_cast<int>(x)];
}
// if we have both log and exp then use them
// do ten iterations
for (int i = 0; i < 10; ++i) {
if (result <= 0) {
@ -38,7 +29,7 @@ double mysqrt(double x)
result = result + 0.5 * delta / result;
std::cout << "Computing sqrt of " << x << " to be " << result << std::endl;
}
#endif
return result;
}
}

2
Help/guide/tutorial/Step10/TutorialConfig.h.in
View File

@ -1,3 +1,3 @@
// the configured version number
// the configured options and settings for Tutorial
#define Tutorial_VERSION_MAJOR @Tutorial_VERSION_MAJOR@
#define Tutorial_VERSION_MINOR @Tutorial_VERSION_MINOR@

3
Help/guide/tutorial/Step10/tutorial.cxx
View File

@ -16,7 +16,8 @@ int main(int argc, char* argv[])
return 1;
}
double inputValue = std::stod(argv[1]);
// convert input to double
const double inputValue = std::stod(argv[1]);
const double outputValue = mathfunctions::sqrt(inputValue);

15
Help/guide/tutorial/Step11/CMakeLists.txt
View File

@ -1,5 +1,7 @@
cmake_minimum_required(VERSION 3.15)
project(Tutorial)
# set the project name and version
project(Tutorial VERSION 1.0)
add_library(tutorial_compiler_flags INTERFACE)
target_compile_features(tutorial_compiler_flags INTERFACE cxx_std_11)
@ -13,10 +15,6 @@ target_compile_options(tutorial_compiler_flags INTERFACE
"$<${msvc_cxx}:$<BUILD_INTERFACE:-W3>>"
)
# set the version number
set(Tutorial_VERSION_MAJOR 1)
set(Tutorial_VERSION_MINOR 0)
# control where the static and shared libraries are built so that on windows
# we don't need to tinker with the path to run the executable
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}")
@ -26,17 +24,14 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}")
option(BUILD_SHARED_LIBS "Build using shared libraries" ON)
# configure a header file to pass the version number only
configure_file(
"${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
"${PROJECT_BINARY_DIR}/TutorialConfig.h"
)
configure_file(TutorialConfig.h.in TutorialConfig.h)
# add the MathFunctions library
add_subdirectory(MathFunctions)
# add the executable
add_executable(Tutorial tutorial.cxx)
target_link_libraries(Tutorial MathFunctions)
target_link_libraries(Tutorial PUBLIC MathFunctions)
# add the binary tree to the search path for include files
# so that we will find TutorialConfig.h

7
Help/guide/tutorial/Step11/CTestConfig.cmake Normal file
View File

@ -0,0 +1,7 @@
set(CTEST_PROJECT_NAME "CMakeTutorial")
set(CTEST_NIGHTLY_START_TIME "00:00:00 EST")
set(CTEST_DROP_METHOD "http")
set(CTEST_DROP_SITE "my.cdash.org")
set(CTEST_DROP_LOCATION "/submit.php?project=CMakeTutorial")
set(CTEST_DROP_SITE_CDASH TRUE)

13
Help/guide/tutorial/Step11/MathFunctions/CMakeLists.txt
View File

@ -11,11 +11,7 @@ target_include_directories(MathFunctions
option(USE_MYMATH "Use tutorial provided math implementation" ON)
if(USE_MYMATH)
# does this system provide the log and exp functions?
include(CheckSymbolExists)
set(CMAKE_REQUIRED_LIBRARIES "m")
check_symbol_exists(log "math.h" HAVE_LOG)
check_symbol_exists(exp "math.h" HAVE_EXP)
target_compile_definitions(MathFunctions PRIVATE "USE_MYMATH")
# first we add the executable that generates the table
add_executable(MakeTable MakeTable.cxx)
@ -39,17 +35,12 @@ if(USE_MYMATH)
${CMAKE_CURRENT_BINARY_DIR}
)
# state that SqrtLibrary need PIC when the default is shared libraries
set_target_properties(SqrtLibrary PROPERTIES
POSITION_INDEPENDENT_CODE ${BUILD_SHARED_LIBS}
)
target_link_libraries(SqrtLibrary PUBLIC tutorial_compiler_flags)
target_compile_definitions(MathFunctions PRIVATE "USE_MYMATH")
if(HAVE_LOG AND HAVE_EXP)
target_compile_definitions(SqrtLibrary
PRIVATE "HAVE_LOG" "HAVE_EXP")
endif()
target_link_libraries(MathFunctions PRIVATE SqrtLibrary)
endif()

13
Help/guide/tutorial/Step11/MathFunctions/mysqrt.cxx
View File

@ -4,8 +4,6 @@
// include the generated table
#include "Table.h"
#include <cmath>
namespace mathfunctions {
namespace detail {
// a hack square root calculation using simple operations
@ -15,20 +13,13 @@ double mysqrt(double x)
return 0;
}
// if we have both log and exp then use them
#if defined(HAVE_LOG) && defined(HAVE_EXP)
double result = exp(log(x) * 0.5);
std::cout << "Computing sqrt of " << x << " to be " << result << " using log"
<< std::endl;
#else
// use the table to help find an initial value
double result = x;
if (x >= 1 && x < 10) {
std::cout << "Use the table to help find an initial value " << std::endl;
result = sqrtTable[static_cast<int>(x)];
}
// if we have both log and exp then use them
// do ten iterations
for (int i = 0; i < 10; ++i) {
if (result <= 0) {
@ -38,7 +29,7 @@ double mysqrt(double x)
result = result + 0.5 * delta / result;
std::cout << "Computing sqrt of " << x << " to be " << result << std::endl;
}
#endif
return result;
}
}

2
Help/guide/tutorial/Step11/TutorialConfig.h.in
View File

@ -1,3 +1,3 @@
// the configured version number
// the configured options and settings for Tutorial
#define Tutorial_VERSION_MAJOR @Tutorial_VERSION_MAJOR@
#define Tutorial_VERSION_MINOR @Tutorial_VERSION_MINOR@

4
Help/guide/tutorial/Step11/tutorial.cxx
View File

@ -1,5 +1,4 @@
// A simple program that computes the square root of a number
#include <cmath>
#include <iostream>
#include <string>
@ -16,7 +15,8 @@ int main(int argc, char* argv[])
return 1;
}
double inputValue = std::stod(argv[1]);
// convert input to double
const double inputValue = std::stod(argv[1]);
const double outputValue = mathfunctions::sqrt(inputValue);

16
Help/guide/tutorial/Step2/CMakeLists.txt
View File

@ -1,19 +1,15 @@
cmake_minimum_required(VERSION 3.3)
project(Tutorial)
cmake_minimum_required(VERSION 3.10)
# set the project name and version
project(Tutorial VERSION 1.0)
# specify the C++ standard
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED True)
# set the version number
set(Tutorial_VERSION_MAJOR 1)
set(Tutorial_VERSION_MINOR 0)
# configure a header file to pass some of the CMake settings
# to the source code
configure_file(
"${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
"${PROJECT_BINARY_DIR}/TutorialConfig.h"
)
configure_file(TutorialConfig.h.in TutorialConfig.h)
# add the executable
add_executable(Tutorial tutorial.cxx)

1
Help/guide/tutorial/Step2/MathFunctions/CMakeLists.txt
View File

@ -1 +0,0 @@
add_library(MathFunctions mysqrt.cxx)

1
Help/guide/tutorial/Step2/MathFunctions/mysqrt.cxx
View File

@ -1,4 +1,3 @@
#include "MathFunctions.h"
#include <iostream>
// a hack square root calculation using simple operations

6
Help/guide/tutorial/Step2/tutorial.cxx
View File

@ -15,9 +15,11 @@ int main(int argc, char* argv[])
return 1;
}
double inputValue = std::stod(argv[1]);
// convert input to double
const double inputValue = std::stod(argv[1]);
double outputValue = sqrt(inputValue);
// calculate square root
const double outputValue = sqrt(inputValue);
std::cout << "The square root of " << inputValue << " is " << outputValue
<< std::endl;
return 0;

22
Help/guide/tutorial/Step3/CMakeLists.txt
View File

@ -1,34 +1,30 @@
cmake_minimum_required(VERSION 3.3)
project(Tutorial)
cmake_minimum_required(VERSION 3.10)
# set the project name and version
project(Tutorial VERSION 1.0)
# specify the C++ standard
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED True)
# should we use our own math functions
option(USE_MYMATH "Use tutorial provided math implementation" ON)
# set the version number
set(Tutorial_VERSION_MAJOR 1)
set(Tutorial_VERSION_MINOR 0)
# configure a header file to pass some of the CMake settings
# to the source code
configure_file(
"${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
"${PROJECT_BINARY_DIR}/TutorialConfig.h"
)
configure_file(TutorialConfig.h.in TutorialConfig.h)
# add the MathFunctions library?
# add the MathFunctions library
if(USE_MYMATH)
add_subdirectory(MathFunctions)
list(APPEND EXTRA_LIBS MathFunctions)
list(APPEND EXTRA_INCLUDES "${PROJECT_SOURCE_DIR}/MathFunctions")
endif(USE_MYMATH)
endif()
# add the executable
add_executable(Tutorial tutorial.cxx)
target_link_libraries(Tutorial ${EXTRA_LIBS})
target_link_libraries(Tutorial PUBLIC ${EXTRA_LIBS})
# add the binary tree to the search path for include files
# so that we will find TutorialConfig.h

7
Help/guide/tutorial/Step3/tutorial.cxx
View File

@ -20,13 +20,14 @@ int main(int argc, char* argv[])
return 1;
}
double inputValue = std::stod(argv[1]);
// convert input to double
const double inputValue = std::stod(argv[1]);
// which square root function should we use?
#ifdef USE_MYMATH
double outputValue = mysqrt(inputValue);
const double outputValue = mysqrt(inputValue);
#else
double outputValue = sqrt(inputValue);
const double outputValue = sqrt(inputValue);
#endif
std::cout << "The square root of " << inputValue << " is " << outputValue

20
Help/guide/tutorial/Step4/CMakeLists.txt
View File

@ -1,28 +1,24 @@
cmake_minimum_required(VERSION 3.3)
project(Tutorial)
cmake_minimum_required(VERSION 3.10)
# set the project name and version
project(Tutorial VERSION 1.0)
# specify the C++ standard
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED True)
# should we use our own math functions
option(USE_MYMATH "Use tutorial provided math implementation" ON)
# set the version number
set(Tutorial_VERSION_MAJOR 1)
set(Tutorial_VERSION_MINOR 0)
# configure a header file to pass some of the CMake settings
# to the source code
configure_file(
"${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
"${PROJECT_BINARY_DIR}/TutorialConfig.h"
)
configure_file(TutorialConfig.h.in TutorialConfig.h)
# add the MathFunctions library?
# add the MathFunctions library
if(USE_MYMATH)
add_subdirectory(MathFunctions)
list(APPEND EXTRA_LIBS MathFunctions)
endif(USE_MYMATH)
endif()
# add the executable
add_executable(Tutorial tutorial.cxx)

7
Help/guide/tutorial/Step4/tutorial.cxx
View File

@ -20,13 +20,14 @@ int main(int argc, char* argv[])
return 1;
}
double inputValue = std::stod(argv[1]);
// convert input to double
const double inputValue = std::stod(argv[1]);
// which square root function should we use?
#ifdef USE_MYMATH
double outputValue = mysqrt(inputValue);
const double outputValue = mysqrt(inputValue);
#else
double outputValue = sqrt(inputValue);
const double outputValue = sqrt(inputValue);
#endif
std::cout << "The square root of " << inputValue << " is " << outputValue

18
Help/guide/tutorial/Step5/CMakeLists.txt
View File

@ -1,24 +1,20 @@
cmake_minimum_required(VERSION 3.3)
project(Tutorial)
cmake_minimum_required(VERSION 3.10)
# set the project name and version
project(Tutorial VERSION 1.0)
# specify the C++ standard
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED True)
# should we use our own math functions
option(USE_MYMATH "Use tutorial provided math implementation" ON)
# set the version number
set(Tutorial_VERSION_MAJOR 1)
set(Tutorial_VERSION_MINOR 0)
# configure a header file to pass some of the CMake settings
# to the source code
configure_file(
"${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
"${PROJECT_BINARY_DIR}/TutorialConfig.h"
)
configure_file(TutorialConfig.h.in TutorialConfig.h)
# add the MathFunctions library?
# add the MathFunctions library
if(USE_MYMATH)
add_subdirectory(MathFunctions)
list(APPEND EXTRA_LIBS MathFunctions)

7
Help/guide/tutorial/Step5/tutorial.cxx
View File

@ -20,13 +20,14 @@ int main(int argc, char* argv[])
return 1;
}
double inputValue = std::stod(argv[1]);
// convert input to double
const double inputValue = std::stod(argv[1]);
// which square root function should we use?
#ifdef USE_MYMATH
double outputValue = mysqrt(inputValue);
const double outputValue = mysqrt(inputValue);
#else
double outputValue = sqrt(inputValue);
const double outputValue = sqrt(inputValue);
#endif
std::cout << "The square root of " << inputValue << " is " << outputValue

24
Help/guide/tutorial/Step6/CMakeLists.txt
View File

@ -1,30 +1,20 @@
cmake_minimum_required(VERSION 3.3)
project(Tutorial)
cmake_minimum_required(VERSION 3.10)
# set the project name and version
project(Tutorial VERSION 1.0)
# specify the C++ standard
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED True)
# set the version number
set(Tutorial_VERSION_MAJOR 1)
set(Tutorial_VERSION_MINOR 0)
# does this system provide the log and exp functions?
include(CheckSymbolExists)
set(CMAKE_REQUIRED_LIBRARIES "m")
check_symbol_exists(log "math.h" HAVE_LOG)
check_symbol_exists(exp "math.h" HAVE_EXP)
# should we use our own math functions
option(USE_MYMATH "Use tutorial provided math implementation" ON)
# configure a header file to pass some of the CMake settings
# to the source code
configure_file(
"${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
"${PROJECT_BINARY_DIR}/TutorialConfig.h"
)
configure_file(TutorialConfig.h.in TutorialConfig.h)
# add the MathFunctions library?
# add the MathFunctions library
if(USE_MYMATH)
add_subdirectory(MathFunctions)
list(APPEND EXTRA_LIBS MathFunctions)

14
Help/guide/tutorial/Step6/MathFunctions/CMakeLists.txt
View File

@ -2,13 +2,21 @@ add_library(MathFunctions mysqrt.cxx)
# state that anybody linking to us needs to include the current source dir
# to find MathFunctions.h, while we don't.
# state that we depend on Tutorial_BINARY_DIR but consumers don't, as the
# TutorialConfig.h include is an implementation detail
target_include_directories(MathFunctions
INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}
PRIVATE ${Tutorial_BINARY_DIR}
)
# does this system provide the log and exp functions?
include(CheckSymbolExists)
set(CMAKE_REQUIRED_LIBRARIES "m")
check_symbol_exists(log "math.h" HAVE_LOG)
check_symbol_exists(exp "math.h" HAVE_EXP)
if(HAVE_LOG AND HAVE_EXP)
target_compile_definitions(MathFunctions
PRIVATE "HAVE_LOG" "HAVE_EXP")
endif()
# install rules
install(TARGETS MathFunctions DESTINATION lib)
install(FILES MathFunctions.h DESTINATION include)

5
Help/guide/tutorial/Step6/MathFunctions/mysqrt.cxx
View File

@ -1,5 +1,4 @@
#include "MathFunctions.h"
#include "TutorialConfig.h"
#include <iostream>
#include <cmath>
@ -14,8 +13,8 @@ double mysqrt(double x)
// if we have both log and exp then use them
#if defined(HAVE_LOG) && defined(HAVE_EXP)
double result = exp(log(x) * 0.5);
std::cout << "Computing sqrt of " << x << " to be " << result << " using log"
<< std::endl;
std::cout << "Computing sqrt of " << x << " to be " << result
<< " using log and exp" << std::endl;
#else
double result = x;

4
Help/guide/tutorial/Step6/TutorialConfig.h.in
View File

@ -2,7 +2,3 @@
#define Tutorial_VERSION_MAJOR @Tutorial_VERSION_MAJOR@
#define Tutorial_VERSION_MINOR @Tutorial_VERSION_MINOR@
#cmakedefine USE_MYMATH
// does the platform provide exp and log functions?
#cmakedefine HAVE_LOG
#cmakedefine HAVE_EXP

7
Help/guide/tutorial/Step6/tutorial.cxx
View File

@ -20,13 +20,14 @@ int main(int argc, char* argv[])
return 1;
}
double inputValue = std::stod(argv[1]);
// convert input to double
const double inputValue = std::stod(argv[1]);
// which square root function should we use?
#ifdef USE_MYMATH
double outputValue = mysqrt(inputValue);
const double outputValue = mysqrt(inputValue);
#else
double outputValue = sqrt(inputValue);
const double outputValue = sqrt(inputValue);
#endif
std::cout << "The square root of " << inputValue << " is " << outputValue

28
Help/guide/tutorial/Step7/CMakeLists.txt
View File

@ -1,34 +1,24 @@
cmake_minimum_required(VERSION 3.3)
project(Tutorial)
cmake_minimum_required(VERSION 3.10)
# set the project name and version
project(Tutorial VERSION 1.0)
# specify the C++ standard
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED True)
# set the version number
set(Tutorial_VERSION_MAJOR 1)
set(Tutorial_VERSION_MINOR 0)
# does this system provide the log and exp functions?
include(CheckSymbolExists)
set(CMAKE_REQUIRED_LIBRARIES "m")
check_symbol_exists(log "math.h" HAVE_LOG)
check_symbol_exists(exp "math.h" HAVE_EXP)
# should we use our own math functions
option(USE_MYMATH "Use tutorial provided math implementation" ON)
# configure a header file to pass some of the CMake settings
# to the source code
configure_file(
"${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
"${PROJECT_BINARY_DIR}/TutorialConfig.h"
)
configure_file(TutorialConfig.h.in TutorialConfig.h)
# add the MathFunctions library?
# add the MathFunctions library
if(USE_MYMATH)
add_subdirectory(MathFunctions)
list(APPEND EXTRA_LIBS MathFunctions)
endif(USE_MYMATH)
endif()
# add the executable
add_executable(Tutorial tutorial.cxx)
@ -38,7 +28,7 @@ target_link_libraries(Tutorial PUBLIC ${EXTRA_LIBS})
# so that we will find TutorialConfig.h
target_include_directories(Tutorial PUBLIC
"${PROJECT_BINARY_DIR}"
)
)
# add the install targets
install(TARGETS Tutorial DESTINATION bin)

3
Help/guide/tutorial/Step7/MathFunctions/CMakeLists.txt
View File

@ -21,8 +21,7 @@ add_library(MathFunctions
# state that we depend on our binary dir to find Table.h
target_include_directories(MathFunctions
INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}
PRIVATE ${Tutorial_BINARY_DIR}
${CMAKE_CURRENT_BINARY_DIR}
PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
)
# install rules

4
Help/guide/tutorial/Step7/MathFunctions/mysqrt.cxx
View File

@ -1,12 +1,9 @@
#include "MathFunctions.h"
#include "TutorialConfig.h"
#include <iostream>
// include the generated table
#include "Table.h"
#include <cmath>
// a hack square root calculation using simple operations
double mysqrt(double x)
{
@ -17,6 +14,7 @@ double mysqrt(double x)
// use the table to help find an initial value
double result = x;
if (x >= 1 && x < 10) {
std::cout << "Use the table to help find an initial value " << std::endl;
result = sqrtTable[static_cast<int>(x)];
}

4
Help/guide/tutorial/Step7/TutorialConfig.h.in
View File

@ -2,7 +2,3 @@
#define Tutorial_VERSION_MAJOR @Tutorial_VERSION_MAJOR@
#define Tutorial_VERSION_MINOR @Tutorial_VERSION_MINOR@
#cmakedefine USE_MYMATH
// does the platform provide exp and log functions?
#cmakedefine HAVE_LOG
#cmakedefine HAVE_EXP

7
Help/guide/tutorial/Step7/tutorial.cxx
View File

@ -20,13 +20,14 @@ int main(int argc, char* argv[])
return 1;
}
double inputValue = std::stod(argv[1]);
// convert input to double
const double inputValue = std::stod(argv[1]);
// which square root function should we use?
#ifdef USE_MYMATH
double outputValue = mysqrt(inputValue);
const double outputValue = mysqrt(inputValue);
#else
double outputValue = sqrt(inputValue);
const double outputValue = sqrt(inputValue);
#endif
std::cout << "The square root of " << inputValue << " is " << outputValue

28
Help/guide/tutorial/Step8/CMakeLists.txt
View File

@ -1,34 +1,24 @@
cmake_minimum_required(VERSION 3.3)
project(Tutorial)
cmake_minimum_required(VERSION 3.10)
# set the project name and version
project(Tutorial VERSION 1.0)
# specify the C++ standard
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED True)
# set the version number
set(Tutorial_VERSION_MAJOR 1)
set(Tutorial_VERSION_MINOR 0)
# does this system provide the log and exp functions?
include(CheckSymbolExists)
set(CMAKE_REQUIRED_LIBRARIES "m")
check_symbol_exists(log "math.h" HAVE_LOG)
check_symbol_exists(exp "math.h" HAVE_EXP)
# should we use our own math functions
option(USE_MYMATH "Use tutorial provided math implementation" ON)
# configure a header file to pass some of the CMake settings
# to the source code
configure_file(
"${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
"${PROJECT_BINARY_DIR}/TutorialConfig.h"
)
configure_file(TutorialConfig.h.in TutorialConfig.h)
# add the MathFunctions library?
# add the MathFunctions library
if(USE_MYMATH)
add_subdirectory(MathFunctions)
list(APPEND EXTRA_LIBS MathFunctions)
endif(USE_MYMATH)
endif()
# add the executable
add_executable(Tutorial tutorial.cxx)
@ -60,7 +50,7 @@ set_tests_properties(Usage
# define a function to simplify adding tests
function(do_test target arg result)
add_test(NAME Comp${arg} COMMAND ${target} ${arg})
add_test(NAME Comp${arg} COMMAND ${target} ${arg})
set_tests_properties(Comp${arg}
PROPERTIES PASS_REGULAR_EXPRESSION ${result}
)

3
Help/guide/tutorial/Step8/MathFunctions/CMakeLists.txt
View File

@ -21,8 +21,7 @@ add_library(MathFunctions
# state that we depend on our binary dir to find Table.h
target_include_directories(MathFunctions
INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}
PRIVATE ${Tutorial_BINARY_DIR}
${CMAKE_CURRENT_BINARY_DIR}
PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
)
# install rules

14
Help/guide/tutorial/Step8/MathFunctions/mysqrt.cxx
View File

@ -1,12 +1,9 @@
#include "MathFunctions.h"
#include "TutorialConfig.h"
#include <iostream>
// include the generated table
#include "Table.h"
#include <cmath>
// a hack square root calculation using simple operations
double mysqrt(double x)
{
@ -14,20 +11,13 @@ double mysqrt(double x)
return 0;
}
// if we have both log and exp then use them
#if defined(HAVE_LOG) && defined(HAVE_EXP)
double result = exp(log(x) * 0.5);
std::cout << "Computing sqrt of " << x << " to be " << result << " using log"
<< std::endl;
#else
// use the table to help find an initial value
double result = x;
if (x >= 1 && x < 10) {
std::cout << "Use the table to help find an initial value " << std::endl;
result = sqrtTable[static_cast<int>(x)];
}
// if we have both log and exp then use them
// do ten iterations
for (int i = 0; i < 10; ++i) {
if (result <= 0) {
@ -37,6 +27,6 @@ double mysqrt(double x)
result = result + 0.5 * delta / result;
std::cout << "Computing sqrt of " << x << " to be " << result << std::endl;
}
#endif
return result;
}

4
Help/guide/tutorial/Step8/TutorialConfig.h.in
View File

@ -2,7 +2,3 @@
#define Tutorial_VERSION_MAJOR @Tutorial_VERSION_MAJOR@
#define Tutorial_VERSION_MINOR @Tutorial_VERSION_MINOR@
#cmakedefine USE_MYMATH
// does the platform provide exp and log functions?
#cmakedefine HAVE_LOG
#cmakedefine HAVE_EXP

7
Help/guide/tutorial/Step8/tutorial.cxx
View File

@ -20,13 +20,14 @@ int main(int argc, char* argv[])
return 1;
}
double inputValue = std::stod(argv[1]);
// convert input to double
const double inputValue = std::stod(argv[1]);
// which square root function should we use?
#ifdef USE_MYMATH
double outputValue = mysqrt(inputValue);
const double outputValue = mysqrt(inputValue);
#else
double outputValue = sqrt(inputValue);
const double outputValue = sqrt(inputValue);
#endif
std::cout << "The square root of " << inputValue << " is " << outputValue

27
Help/guide/tutorial/Step9/CMakeLists.txt
View File

@ -1,29 +1,20 @@
cmake_minimum_required(VERSION 3.3)
project(Tutorial)
cmake_minimum_required(VERSION 3.10)
# set the project name and version
project(Tutorial VERSION 1.0)
# specify the C++ standard
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED True)
# set the version number
set(Tutorial_VERSION_MAJOR 1)
set(Tutorial_VERSION_MINOR 0)
# does this system provide the log and exp functions?
include(CheckSymbolExists)
set(CMAKE_REQUIRED_LIBRARIES "m")
check_symbol_exists(log "math.h" HAVE_LOG)
check_symbol_exists(exp "math.h" HAVE_EXP)
# should we use our own math functions
option(USE_MYMATH "Use tutorial provided math implementation" ON)
# configure a header file to pass the version number only
configure_file(
"${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
"${PROJECT_BINARY_DIR}/TutorialConfig.h"
)
# configure a header file to pass some of the CMake settings
# to the source code
configure_file(TutorialConfig.h.in TutorialConfig.h)
# add the MathFunctions library?
# add the MathFunctions library
if(USE_MYMATH)
add_subdirectory(MathFunctions)
list(APPEND EXTRA_LIBS MathFunctions)

8
Help/guide/tutorial/Step9/CTestConfig.cmake
View File

@ -1,11 +1,3 @@
## This file should be placed in the root directory of your project.
## Then modify the CMakeLists.txt file in the root directory of your
## project to incorporate the testing dashboard.
##
## # The following are required to submit to the CDash dashboard:
## ENABLE_TESTING()
## INCLUDE(CTest)
set(CTEST_PROJECT_NAME "CMakeTutorial")
set(CTEST_NIGHTLY_START_TIME "00:00:00 EST")

9
Help/guide/tutorial/Step9/MathFunctions/CMakeLists.txt
View File

@ -22,15 +22,6 @@ target_include_directories(MathFunctions
PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
)
# use compile definitions to state if we have enabled USE_MYMATH
# and that anything that links to use will get this define
target_compile_definitions(MathFunctions INTERFACE "USE_MYMATH")
if(HAVE_LOG AND HAVE_EXP)
target_compile_definitions(MathFunctions
PRIVATE "HAVE_LOG" "HAVE_EXP")
endif()
# install rules
install(TARGETS MathFunctions DESTINATION lib)
install(FILES MathFunctions.h DESTINATION include)

13
Help/guide/tutorial/Step9/MathFunctions/mysqrt.cxx
View File

@ -4,8 +4,6 @@
// include the generated table
#include "Table.h"
#include <cmath>
// a hack square root calculation using simple operations
double mysqrt(double x)
{
@ -13,20 +11,13 @@ double mysqrt(double x)
return 0;
}
// if we have both log and exp then use them
#if defined(HAVE_LOG) && defined(HAVE_EXP)
double result = exp(log(x) * 0.5);
std::cout << "Computing sqrt of " << x << " to be " << result << " using log"
<< std::endl;
#else
// use the table to help find an initial value
double result = x;
if (x >= 1 && x < 10) {
std::cout << "Use the table to help find an initial value " << std::endl;
result = sqrtTable[static_cast<int>(x)];
}
// if we have both log and exp then use them
// do ten iterations
for (int i = 0; i < 10; ++i) {
if (result <= 0) {
@ -36,6 +27,6 @@ double mysqrt(double x)
result = result + 0.5 * delta / result;
std::cout << "Computing sqrt of " << x << " to be " << result << std::endl;
}
#endif
return result;
}

3
Help/guide/tutorial/Step9/TutorialConfig.h.in
View File

@ -1,3 +1,4 @@
// the configured version number
// the configured options and settings for Tutorial
#define Tutorial_VERSION_MAJOR @Tutorial_VERSION_MAJOR@
#define Tutorial_VERSION_MINOR @Tutorial_VERSION_MINOR@
#cmakedefine USE_MYMATH

8
Help/guide/tutorial/Step9/tutorial.cxx
View File

@ -1,7 +1,6 @@
// A simple program that computes the square root of a number
#include <cmath>
#include <iostream>
#include <sstream>
#include <string>
#include "TutorialConfig.h"
@ -21,13 +20,14 @@ int main(int argc, char* argv[])
return 1;
}
double inputValue = std::stod(argv[1]);
// convert input to double
const double inputValue = std::stod(argv[1]);
// which square root function should we use?
#ifdef USE_MYMATH
double outputValue = mysqrt(inputValue);
const double outputValue = mysqrt(inputValue);
#else
double outputValue = sqrt(inputValue);
const double outputValue = sqrt(inputValue);
#endif
std::cout << "The square root of " << inputValue << " is " << outputValue

411
Help/guide/tutorial/index.rst
View File

@ -5,33 +5,38 @@ CMake Tutorial
.. contents::
This tutorial provides a step-by-step guide that covers common build
The CMake tutorial provides a step-by-step guide that covers common build
system issues that CMake helps address. Seeing how various topics all
work together in an example project can be very helpful. This tutorial
can be found in the ``Help/guide/tutorial`` directory of the CMake
source code tree. Each topic has its own subdirectory containing code
that may be used as a starting point for that step. The tutorial
examples are progressive so that each step provides the complete
work together in an example project can be very helpful. The tutorial
documentation and source code for examples can be found in the
``Help/guide/tutorial`` directory of the CMake source code tree. Each step has
its own subdirectory containing code that may be used as a starting point. The
tutorial examples are progressive so that each step provides the complete
solution for the previous step.
A Basic Starting Point (Step 1)
===============================
The most basic project is an executable built from source code files.
For simple projects, a two line CMakeLists file is all that is required.
This will be the starting point for our tutorial. The CMakeLists file
looks like:
For simple projects, a three line CMakeLists file is all that is required.
This will be the starting point for our tutorial. Create a ``CMakeLists.txt``
file in the ``Step1`` directory that looks like:
.. code-block:: cmake
cmake_minimum_required(VERSION 3.10)
# set the project name
project(Tutorial)
# add the executable
add_executable(Tutorial tutorial.cxx)
.. literalinclude:: Step1/CMakeLists.txt
:language: cmake
Note that this example uses lower case commands in the CMakeLists file.
Upper, lower, and mixed case commands are supported by CMake. The source
code for ``tutorial.cxx`` will compute the square root of a number and
the first version of it is very simple, as follows:
.. literalinclude:: Step1/tutorial.cxx
:language: c++
code for ``tutorial.cxx`` is provided in the ``Step1`` directory and can be
used to compute the square root of a number.
Adding a Version Number and Configured Header File
--------------------------------------------------
@ -40,55 +45,70 @@ The first feature we will add is to provide our executable and project with a
version number. While we could do this exclusively in the source code, using
CMakeLists provides more flexibility.
To add a version number we modify the CMakeLists file as follows:
First, modify the CMakeLists file to set the version number.
.. literalinclude:: Step2/CMakeLists.txt
:language: cmake
:start-after: # set the version number
:end-before: # configure a header file
:end-before: # specify the C++ standard
Then, configure a header file to pass the version number to the source
code:
.. literalinclude:: Step2/CMakeLists.txt
:language: cmake
:start-after: # to the source code
:end-before: # add the executable
Since the configured file will be written into the binary tree, we
must add that directory to the list of paths to search for include
files.
files. Add the following lines to the end of the CMakeLists file:
.. literalinclude:: Step2/CMakeLists.txt
:language: cmake
:start-after: # so that we will find TutorialConfig.h
We then create a ``TutorialConfig.h.in`` file in the source tree with the
following contents:
Using your favorite editor, create ``TutorialConfig.h.in`` in the source
directory with the following contents:
.. literalinclude:: Step1/TutorialConfig.h.in
.. literalinclude:: Step2/TutorialConfig.h.in
:language: cmake
When CMake configures this header file the values for
``@Tutorial_VERSION_MAJOR@`` and ``@Tutorial_VERSION_MINOR@`` will be
replaced by the values from the CMakeLists file. Next we modify
``tutorial.cxx`` to include the configured header file and to make use of the
version numbers. The updated source code is listed below.
replaced.
Next modify ``tutorial.cxx`` to include the configured header file,
``TutorialConfig.h``.
Finally, let's print out the version number by updating ``tutorial.cxx`` as
follows:
.. literalinclude:: Step2/tutorial.cxx
:language: c++
:start-after: // report version
:end-before: return 1;
The main changes are the inclusion of the ``TutorialConfig.h`` header
file and printing out a version number as part of the usage message.
:start-after: {
:end-before: // convert input to double
Specify the C++ Standard
-------------------------
Next let's add some C++11 features to our project. We will need to explicitly
state in the CMake code that it should use the correct flags. The easiest way
to enable C++11 support for CMake is by using the ``CMAKE_CXX_STANDARD``
variable.
Next let's add some C++11 features to our project by replacing ``atof`` with
``std::stod`` in ``tutorial.cxx``. At the same time, remove
``#include <cstdlib>``.
First, replace ``atof`` with ``std::stod`` in ``tutorial.cxx``.
.. literalinclude:: Step2/tutorial.cxx
:language: c++
:start-after: // convert input to double
:end-before: // calculate square root
Then, set the ``CMAKE_CXX_STANDARD`` variable in the CMakeLists file.
We will need to explicitly state in the CMake code that it should use the
correct flags. The easiest way to enable support for a specific C++ standard
in CMake is by using the ``CMAKE_CXX_STANDARD`` variable. For this tutorial,
set the ``CMAKE_CXX_STANDARD`` variable in the CMakeLists file to 11 and
``CMAKE_CXX_STANDARD_REQUIRED`` to True:
Which variable can we set in the CMakeLists file to treat the
``CMAKE_CXX_STANDARD`` value as a requirement?
.. literalinclude:: Step2/CMakeLists.txt
:language: cmake
:end-before: # configure a header file to pass some of the CMake settings
Build and Test
--------------
@ -96,8 +116,19 @@ Build and Test
Run **cmake** or **cmake-gui** to configure the project and then build it
with your chosen build tool.
cd to the directory where Tutorial was built (likely the make directory or
a Debug or Release build configuration subdirectory) and run these commands:
For example, from the command line we could navigate to the
``Help/guide/tutorial`` directory of the CMake source code tree and run the
following commands:
.. code-block:: console
mkdir Step1_build
cd Step1_build
cmake ../Step1
cmake --build .
Navigate to the directory where Tutorial was built (likely the make directory
or a Debug or Release build configuration subdirectory) and run these commands:
.. code-block:: console
@ -114,18 +145,22 @@ then use this library instead of the standard square root function provided by
the compiler.
For this tutorial we will put the library into a subdirectory
called MathFunctions. It will have the following one line CMakeLists file:
called MathFunctions. This directory already contains a header file,
``MathFunctions.h``, and a source file ``mysqrt.cxx``. The source file has one
function called ``mysqrt`` that provides similar functionality to the
compiler's ``sqrt`` function.
.. literalinclude:: Step2/MathFunctions/CMakeLists.txt
Add the following one line ``CMakeLists.txt`` file to the MathFunctions
directory:
.. literalinclude:: Step3/MathFunctions/CMakeLists.txt
:language: cmake
The source file ``mysqrt.cxx`` has one function called ``mysqrt`` that
provides similar functionality to the compiler’s ``sqrt`` function. To make use
of the new library we add an ``add_subdirectory`` call in the top-level
CMakeLists file so that the library will get built. We add the new library to
the executable, and add MathFunctions as an include directory so that the
``mqsqrt.h`` header file can be found. The last few lines of the top-level
CMakeLists file now look like:
To make use of the new library we will add an ``add_subdirectory`` call in the
top-level CMakeLists file so that the library will get built. We add the new
library to the executable, and add MathFunctions as an include directory so
that the ``mqsqrt.h`` header file can be found. The last few lines of the
top-level CMakeLists file should now look like:
.. code-block:: cmake
@ -135,7 +170,7 @@ CMakeLists file now look like:
# add the executable
add_executable(Tutorial tutorial.cxx)
target_link_libraries(Tutorial MathFunctions)
target_link_libraries(Tutorial PUBLIC MathFunctions)
# add the binary tree to the search path for include files
# so that we will find TutorialConfig.h
@ -152,12 +187,12 @@ file.
.. literalinclude:: Step3/CMakeLists.txt
:language: cmake
:start-after: # should we use our own math functions
:end-before: # set the version number
:end-before: # add the MathFunctions library
This will show up in the CMake GUI and ccmake with a default value of ON
that can be changed by the user. This setting will be stored in the cache so
that the user does not need to set the value each time they run CMake on this
build directory.
This option will be displayed in the CMake GUI and ccmake with a default
value of ON that can be changed by the user. This setting will be stored in
the cache so that the user does not need to set the value each time they run
CMake on a build directory.
The next change is to make building and linking the MathFunctions library
conditional. To do this we change the end of the top-level CMakeLists file to
@ -165,22 +200,24 @@ look like the following:
.. literalinclude:: Step3/CMakeLists.txt
:language: cmake
:start-after: # add the MathFunctions library?
:start-after: # add the MathFunctions library
Note the use of the variables ``EXTRA_LIBS`` and ``EXTRA_INCLUDES`` to collect
up any optional libraries to later be linked into the executable. This is a
classic approach when dealing with many optional components, we will cover the
modern approach in the next step.
Note the use of the variable ``EXTRA_LIBS`` to collect up any optional
libraries to later be linked into the executable. The variable
``EXTRA_INCLUDES`` is used similarly for optional header files. This is a
classic approach when dealing with many optional components, we will cover
the modern approach in the next step.
The corresponding changes to the source code are fairly straightforward. First,
include the MathFunctions header if we need it:
in ``tutorial.cxx``, include the MathFunctions header if we need it:
.. literalinclude:: Step3/tutorial.cxx
:language: c++
:start-after: // should we include the MathFunctions header
:end-before: int main
Then make which square root function is used dependent on ``USE_MYMATH``:
Then, in the same file, make which square root function is used dependent on
``USE_MYMATH``:
.. literalinclude:: Step3/tutorial.cxx
:language: c++
@ -194,10 +231,14 @@ Since the source code now requires ``USE_MYMATH`` we can add it to
:language: c
:lines: 4
**Exercise**: Why is it important that we configure ``TutorialConfig.h.in``
after the option for ``USE_MYMATH``? What would happen if we inverted the two?
Run **cmake** or **cmake-gui** to configure the project and then build it
with your chosen build tool. Then run the built Tutorial executable.
Which function gives better results, Step1’s sqrt or Step2’s mysqrt?
Use ccmake or the CMake GUI to update the value of ``USE_MYMATH``. Rebuild and
run the tutorial again. Which function gives better results, sqrt or mysqrt?
Adding Usage Requirements for Library (Step 3)
==============================================
@ -212,12 +253,14 @@ requirements are:
- ``target_include_directories``
- ``target_link_libraries``
First up is MathFunctions. We first state that anybody linking to MathFunctions
needs to include the current source directory, while MathFunctions itself
doesn't. So this can become an ``INTERFACE`` usage requirement.
Let's refactor our code from `Adding a Library (Step 2)`_ to use the modern
CMake approach of usage requirements. We first state that anybody linking to
MathFunctions needs to include the current source directory, while
MathFunctions itself doesn't. So this can become an ``INTERFACE`` usage
requirement.
Remember ``INTERFACE`` means things that consumers require but the producer
doesn't. Update ``MathFunctions/CMakeLists.txt`` with:
doesn't. Add the following lines to the end of ``MathFunctions/CMakeLists.txt``:
.. literalinclude:: Step4/MathFunctions/CMakeLists.txt
:language: cmake
@ -225,7 +268,18 @@ doesn't. Update ``MathFunctions/CMakeLists.txt`` with:
Now that we've specified usage requirements for MathFunctions we can safely
remove our uses of the ``EXTRA_INCLUDES`` variable from the top-level
CMakeLists.
CMakeLists, here:
.. literalinclude:: Step4/CMakeLists.txt
:language: cmake
:start-after: # add the MathFunctions library
:end-before: # add the executable
And here:
.. literalinclude:: Step4/CMakeLists.txt
:language: cmake
:start-after: # so that we will find TutorialConfig.h
Once this is done, run **cmake** or **cmake-gui** to configure the project
and then build it with your chosen build tool or by using ``cmake --build .``
@ -239,17 +293,17 @@ Now we can start adding install rules and testing support to our project.
Install Rules
-------------
The install rules are fairly simple for MathFunctions we want to install the
The install rules are fairly simple: for MathFunctions we want to install the
library and header file and for the application we want to install the
executable and configured header.
So to ``MathFunctions/CMakeLists.txt`` we add:
So to the end of ``MathFunctions/CMakeLists.txt`` we add:
.. literalinclude:: Step5/MathFunctions/CMakeLists.txt
:language: cmake
:start-after: # install rules
And the to top-level ``CMakeLists.txt`` we add:
And to the end of the top-level ``CMakeLists.txt`` we add:
.. literalinclude:: Step5/CMakeLists.txt
:language: cmake
@ -260,21 +314,25 @@ That is all that is needed to create a basic local install of the tutorial.
Run **cmake** or **cmake-gui** to configure the project and then build it
with your chosen build tool. Run the install step by typing
``cmake --install .`` or from the command line, or build the ``INSTALL``
target from an IDE. This will install the appropriate header files, libraries,
and executables.
``cmake --install .`` (introduced in 3.15, older versions of CMake must use
``make install``) from the command line, or build the ``INSTALL`` target from
an IDE. This will install the appropriate header files, libraries, and
executables.
Verify that the installed Tutorial runs. Note: The CMake variable
``CMAKE_INSTALL_PREFIX`` is used to determine the root of where the files will
be installed. If using ``cmake --install`` a custom installation directory can
be given via ``--prefix`` argument.
The CMake variable ``CMAKE_INSTALL_PREFIX`` is used to determine the root of
where the files will be installed. If using ``cmake --install`` a custom
installation directory can be given via ``--prefix`` argument. For
multi-configuration tools, use the ``--config`` argument to specify the
configuration.
Verify that the installed Tutorial runs.
Testing Support
---------------
Next let's test our application. At the end of the top-level CMakeLists file we
can add a number of basic tests to verify that the application is
working correctly.
can enable testing and then add a number of basic tests to verify that the
application is working correctly.
.. literalinclude:: Step5/CMakeLists.txt
:language: cmake
@ -285,7 +343,7 @@ otherwise crash, and has a zero return value. This is the basic form of a CTest
test.
The next test makes use of the ``PASS_REGULAR_EXPRESSION`` test property to
verify that the output of the test contains certain strings, in this case:
verify that the output of the test contains certain strings. In this case,
verifying that the the usage message is printed when an incorrect number of
arguments are provided.
@ -295,7 +353,11 @@ invocation of ``do_test``, another test is added to the project with a name,
input, and expected results based on the passed arguments.
Rebuild the application and then cd to the binary directory and run
``ctest -N`` and ``ctest -VV``.
``ctest -N`` and ``ctest -VV``. For multi-config generators (e.g. Visual
Studio), the configuration type must be specified. To run tests in Debug mode,
for example, use ``ctest -C Debug -VV`` from the build directory (not the
Debug subdirectory!). Alternatively, build the ``RUN_TESTS`` target from the
IDE.
Adding System Introspection (Step 5)
====================================
@ -309,72 +371,108 @@ tutorial assume that they are not common.
If the platform has ``log`` and ``exp`` then we will use them to compute the
square root in the ``mysqrt`` function. We first test for the availability of
these functions using the ``CheckSymbolExists.cmake`` macro in the top-level
CMakeLists file as follows:
CMakeLists. We're going to use the new defines in ``TutorialConfig.h.in``,
so be sure to set them before that file is configured.
.. literalinclude:: Step6/CMakeLists.txt
.. literalinclude:: Step6/MathFunctions/CMakeLists.txt
:language: cmake
:start-after: # does this system provide the log and exp functions?
:end-before: # should we use our own math functions
:end-before: if(HAVE_LOG AND HAVE_EXP)
Now let's add these defines to ``TutorialConfig.h.in`` so that we can use them
from ``mysqrt.cxx``:
.. literalinclude:: Step6/TutorialConfig.h.in
:language: c
:start-after: // does the platform provide exp and log functions?
.. code-block:: console
Finally, in the ``mysqrt`` function we can provide an alternate implementation
based on ``log`` and ``exp`` if they are available on the system using the
following code:
// does the platform provide exp and log functions?
#cmakedefine HAVE_LOG
#cmakedefine HAVE_EXP
Modify ``mysqrt.cxx`` to include cmath. Next, in that same file in the
``mysqrt`` function we can provide an alternate implementation based on
``log`` and ``exp`` if they are available on the system using the following
code (don't forget the ``#endif`` before returning the result!):
.. literalinclude:: Step6/MathFunctions/mysqrt.cxx
:language: c++
:start-after: // if we have both log and exp then use them
:end-before: #else
:end-before: // do ten iterations
Run **cmake** or **cmake-gui** to configure the project and then build it
with your chosen build tool.
with your chosen build tool and run the Tutorial executable.
You will notice that even though ``HAVE_LOG`` and ``HAVE_EXP`` are both
defined ``mysqrt`` isn't using them. We should realize quickly that we have
forgotten to include ``TutorialConfig.h`` in ``mysqrt.cxx``.
You will notice that we're not using ``log`` and ``exp``, even if we think they
should be available. We should realize quickly that we have forgotten to include
``TutorialConfig.h`` in ``mysqrt.cxx``.
After making this update, go ahead and build the project again.
We will also need to update MathFunctions/CMakeLists so ``mysqrt.cxx`` knows
where this file is located:
Run the built Tutorial executable. Which function gives better results now,
Step1’s sqrt or Step5’s mysqrt?
**Exercise**: Why is it important that we configure ``TutorialConfig.h.in``
after the checks for ``HAVE_LOG`` and ``HAVE_EXP``? What would happen if we
inverted the two?
.. code-block:: cmake
**Exercise**: Is there a better place for us to save the ``HAVE_LOG`` and
``HAVE_EXP`` values other than in ``TutorialConfig.h``?
target_include_directories(MathFunctions
INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}
PRIVATE ${CMAKE_BINARY_DIR}
)
After making this update, go ahead and build the project again and run the built
Tutorial executable. If ``log`` and ``exp`` are still not being used, open the
generated ``TutorialConfig.h`` file from the build directory. Maybe they aren't
available on the current system?
Which function gives better results now, sqrt or mysqrt?
Specify Compile Definition
--------------------------
Is there a better place for us to save the ``HAVE_LOG`` and ``HAVE_EXP`` values
other than in ``TutorialConfig.h``? Let's try to use
``target_compile_definitions``.
First, remove the defines from ``TutorialConfig.h.in``. We no longer need to
include ``TutorialConfig.h`` from ``mysqrt.cxx`` or the extra include in
MathFunctions/CMakeLists.
Next, we can move the check for ``HAVE_LOG`` and ``HAVE_EXP`` to
MathFunctions/CMakeLists and then add specify those values as ``PRIVATE``
compile definitions.
.. literalinclude:: Step6/MathFunctions/CMakeLists.txt
:language: cmake
:start-after: # does this system provide the log and exp functions?
:end-before: # install rules
After making these updates, go ahead and build the project again. Run the
built Tutorial executable and verify that the results are same as earlier in
this step.
Adding a Custom Command and Generated File (Step 6)
===================================================
In this section, we will add a generated source file into the build process
of an application. For this example, we will create a table of precomputed
square roots as part of the build process, and then compile that
table into our application.
Suppose, for the purpose of this tutorial, we decide that we never want to use
the platform ``log`` and ``exp`` functions and instead would like to
generate a table of precomputed values to use in the ``mysqrt`` function.
In this section, we will create the table as part of the build process,
and then compile that table into our application.
To accomplish this, we first need a program that will generate the table. In
the MathFunctions subdirectory a new source file named ``MakeTable.cxx`` will
do just that.
First, let's remove the check for the ``log`` and ``exp`` functions in
MathFunctions/CMakeLists. Then remove the check for ``HAVE_LOG`` and
``HAVE_EXP`` from ``mysqrt.cxx``. At the same time, we can remove
:code:`#include <cmath>`.
.. literalinclude:: Step7/MathFunctions/MakeTable.cxx
:language: c++
In the MathFunctions subdirectory, a new source file named ``MakeTable.cxx``
has been provided to generate the table.
Note that the table is produced as valid C++ code and that the output filename
is passed in as an argument.
After reviewing the file, we can see that the table is produced as valid C++
code and that the output filename is passed in as an argument.
The next step is to add the appropriate commands to MathFunctions' CMakeLists
The next step is to add the appropriate commands to MathFunctions CMakeLists
file to build the MakeTable executable and then run it as part of the build
process. A few commands are needed to accomplish this.
First, the executable for ``MakeTable`` is added as any other executable would
be added.
First, at the top of MathFunctions/CMakeLists, the executable for ``MakeTable``
is added as any other executable would be added.
.. literalinclude:: Step7/MathFunctions/CMakeLists.txt
:language: cmake
@ -413,10 +511,14 @@ Now let's use the generated table. First, modify ``mysqrt.cxx`` to include
:start-after: // a hack square root calculation using simple operations
Run **cmake** or **cmake-gui** to configure the project and then build it
with your chosen build tool. When this project is built it will first build
the ``MakeTable`` executable. It will then run ``MakeTable`` to produce
``Table.h``. Finally, it will compile ``mysqrt.cxx`` which includes
``Table.h`` to produce the MathFunctions library.
with your chosen build tool.
When this project is built it will first build the ``MakeTable`` executable.
It will then run ``MakeTable`` to produce ``Table.h``. Finally, it will
compile ``mysqrt.cxx`` which includes ``Table.h`` to produce the MathFunctions
library.
Run the Tutorial executable and verify that it is using the table.
Building an Installer (Step 7)
==============================
@ -439,38 +541,46 @@ That is all there is to it. We start by including
``InstallRequiredSystemLibraries``. This module will include any runtime
libraries that are needed by the project for the current platform. Next we
set some CPack variables to where we have stored the license and version
information for this project. The version information makes use of the
variables we set earlier in this tutorial. Finally we include the CPack
module which will use these variables and some other properties of the system
you are on to setup an installer.
information for this project. The version information was set earlier in this
tutorial and the ``license.txt`` has been included in the top-level source
directory for this step.
Finally we include the CPack module which will use these variables and some
other properties of the current system to setup an installer.
The next step is to build the project in the usual manner and then run
CPack on it. To build a binary distribution you would run:
CPack on it. To build a binary distribution, from the binary directory run:
.. code-block:: console
cpack
To specify the generator, use the ``-G`` option. For multi-config builds, use
``-C`` to specify the configuration. For example:
.. code-block:: console
cpack -G ZIP -C Debug
To create a source distribution you would type:
.. code-block:: console
cpack -C CPackSourceConfig.cmake
cpack --config CPackSourceConfig.cmake
Alternatively, run ``make package`` or right click the ``Package`` target and
``Build Project`` from an IDE.
Run the installer executable found in the binary directory. Then run the
Run the installer found in the binary directory. Then run the
installed executable and verify that it works.
Adding Support for a Dashboard (Step 8)
=======================================
Adding support for submitting our test results to a dashboard is very easy. We
already defined a number of tests for our project in the earlier steps of this
tutorial. We just have to run those tests and submit them to a dashboard. To
include support for dashboards we include the CTest module in our top-level
``CMakeLists.txt``.
already defined a number of tests for our project in `Testing Support`_. Now we
just have to run those tests and submit them to a dashboard. To include support
for dashboards we include the CTest module in our top-level ``CMakeLists.txt``.
Replace:
@ -489,21 +599,25 @@ With:
The CTest module will automatically call ``enable_testing()``, so
we can remove it from our CMake files.
We will also need to create a ``CTestConfig.cmake`` file where we can specify
the name of the project and where to submit the dashboard.
We will also need to create a ``CTestConfig.cmake`` file in the top-level
directory where we can specify the name of the project and where to submit the
dashboard.
.. literalinclude:: Step9/CTestConfig.cmake
:language: cmake
CTest will read in this file when it runs. To create a simple dashboard you can
run **cmake** or **cmake-gui** to configure the project, but do not build it
yet. Instead, change directory to the binary tree, and then run:
yet. Instead, change directory to the binary tree, and then run::
.. code-block:: console
ctest [-VV] –D Experimental
'ctest [-VV] –D Experimental'
Remember, for multi-config generators (e.g. Visual Studio), the configuration
type must be specified::
On Windows, build the EXPERIMENTAL target.
ctest [-VV] -C Debug –D Experimental
Or, from an IDE, build the ``Experimental`` target.
Ctest will build and test the project and submit the results to the Kitware
public dashboard. The results of your dashboard will be uploaded to Kitware's
@ -531,7 +645,6 @@ The first step is to update the starting section of the top-level
.. literalinclude:: Step10/CMakeLists.txt
:language: cmake
:start-after: set(Tutorial_VERSION_MINOR
:end-before: # add the binary tree
Now that we have made MathFunctions always be used, we will need to update
@ -544,7 +657,7 @@ The end result is that ``MathFunctions/CMakeLists.txt`` should look like:
.. literalinclude:: Step10/MathFunctions/CMakeLists.txt
:language: cmake
:lines: 1-40,46-
:lines: 1-36,42-
Next, update ``MathFunctions/mysqrt.cxx`` to use the ``mathfunctions`` and
``detail`` namespaces:
@ -557,6 +670,7 @@ uses ``USE_MYMATH``:
#. Always include ``MathFunctions.h``
#. Always use ``mathfunctions::sqrt``
#. Don't include cmath
Finally, update ``MathFunctions/MathFunctions.h`` to use dll export defines:
@ -569,9 +683,14 @@ library that has position enabled code. The solution to this is to explicitly
set the ``POSITION_INDEPENDENT_CODE`` target property of SqrtLibrary to be
True no matter the build type.
.. literalinclude:: Step10/MathFunctions/CMakeLists.txt
:language: cmake
:lines: 37-42
**Exercise**: We modified ``MathFunctions.h`` to use dll export defines.
Using CMake documentation can you find a helper module to simplify this?
Adding Generator Expressions (Step 10)
======================================
@ -609,14 +728,14 @@ So the following code:
.. literalinclude:: Step10/CMakeLists.txt
:language: cmake
:start-after: project(Tutorial)
:end-before: # Set the version number
:start-after: project(Tutorial VERSION 1.0)
:end-before: # control where the static and shared libraries are built so that on windows
Would be replaced with:
.. literalinclude:: Step11/CMakeLists.txt
:language: cmake
:start-after: project(Tutorial)
:start-after: project(Tutorial VERSION 1.0)
:end-before: # add compiler warning flags just when building this project via
@ -629,7 +748,7 @@ below:
.. literalinclude:: Step11/CMakeLists.txt
:language: cmake
:start-after: # the BUILD_INTERFACE genex
:end-before: # set the version number
:end-before: # control where the static and shared libraries are built so that on windows
Looking at this we see that the warning flags are encapsulated inside a
``BUILD_INTERFACE`` condition. This is done so that consumers of our installed

6
Tests/CMakeLists.txt
View File

@ -1598,7 +1598,7 @@ ${CMake_SOURCE_DIR}/Utilities/Release/push.bash --dir dev -- '${CMake_BUILD_NIGH
endfunction()
if(NOT CMake_TEST_EXTERNAL_CMAKE)
foreach(STP RANGE 1 11)
foreach(STP RANGE 2 11)
add_tutorial_test(Step${STP} TRUE)
endforeach()
add_tutorial_test(Complete TRUE)
@ -2130,8 +2130,8 @@ ${CMake_SOURCE_DIR}/Utilities/Release/push.bash --dir dev -- '${CMake_BUILD_NIGH
macro(add_test_VSWinCE name generator systemName systemVersion generatorPlatform)
# TODO: Fix the tutorial to make it work in cross compile
# currently the MakeTable is build for target and can not be used on the host
# This happens in part 5 so we build only part 1-4 of the tutorial
foreach(STP RANGE 1 4)
# This happens in part 5 so we build only through part 4 of the tutorial.
foreach(STP RANGE 2 4)
add_test(NAME "TutorialStep${STP}.${name}" COMMAND ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Help/guide/tutorial/Step${STP}"