Home>Programming related>C# source code
Download

CMake Cookbook

This repository collects sources for the recipes contained in the CMake Cookbook published by Packt and authored by Radovan Bast and Roberto Di Remigio

  • Contributing
  • Testing

Table of contents

Chapter 1: From a Simple Executable to Libraries

  • 1. Compiling a single source file into an executable
  • 2. Switching generators
  • 3. Building and linking static and shared libraries
  • 4. Controlling compilation with conditionals
  • 5. Presenting options to the user
  • 6. Specifying the compiler
  • 7. Switching the build type
  • 8. Controlling compiler flags
  • 9. Setting the standard for the language
  • 10. Using control flow constructs

Chapter 2: Detecting the Environment

  • 1. Discovering the operating system
  • 2. Dealing with platform-dependent source code
  • 3. Dealing with compiler-dependent source code
  • 4. Discovering the host processor architecture
  • 5. Discovering the host processor instruction set
  • 6. Enabling vectorization for the Eigen library

Chapter 3: Detecting External Libraries and Programs

  • 1. Detecting the Python interpreter
  • 2. Detecting the Python library
  • 3. Detecting Python modules and packages
  • 4. Detecting the BLAS and LAPACK math libraries
  • 5. Detecting the OpenMP parallel environment
  • 6. Detecting the MPI parallel environment
  • 7. Detecting the Eigen library
  • 8. Detecting the Boost libraries
  • 9. Detecting external libraries: I. Using pkg-config
  • 10. Detecting external libraries: II. Writing a find-module

Chapter 4: Creating and Running Tests

  • 1. Creating a simple unit test
  • 2. Defining a unit test using the Catch2 library
  • 3. Defining a unit test and linking against Google Test
  • 4. Defining a unit test and linking against Boost test
  • 5. Using dynamic analysis to detect memory defects
  • 6. Testing expected failures
  • 7. Using timeouts for long tests
  • 8. Running tests in parallel
  • 9. Running a subset of tests
  • 10. Using test fixtures

Chapter 5: Configure-time and Build-time Operations

  • 1. Using platform-independent file operations
  • 2. Running a custom command at configure time
  • 3. Running a custom command at build time: I. Using add_custom_command
  • 4. Running a custom command at build time: II. Using add_custom_target
  • 5. Running custom commands for specific targets at build time
  • 6. Probing compilation and linking
  • 7. Probing compiler flags
  • 8. Probing execution
  • 9. Fine-tuning configuration and compilation with generator expressions

Chapter 6: Generating Source Code

  • 1. Generating sources at configure time
  • 2. Generating source code at configure time using Python
  • 3. Generating source code at build time using Python
  • 4. Recording the project version information for reproducibility
  • 5. Recording the project version from a file
  • 6. Recording the Git hash at configure time
  • 7. Recording the Git hash at build time

Chapter 7: Structuring Projects

  • 1. Code reuse with functions and macros
  • 2. Splitting CMake sources into modules
  • 3. Writing a function to test and set compiler flags
  • 4. Defining a function or macro with named arguments
  • 5. Redefining functions and macros
  • 6. Deprecating functions, macros, and variables
  • 7. Limiting scope with add_subdirectory
  • 8. Avoiding global variables using target_sources
  • 9. Organizing Fortran projects

Chapter 8: The Superbuild Pattern

  • 1. Using the superbuild pattern
  • 2. Managing dependencies with a superbuild: I. The Boost libraries
  • 3. Managing dependencies with a superbuild: II. The FFTW library
  • 4. Managing dependencies with a superbuild: III. The Google Test framework
  • 5. Managing your project as a superbuild

Chapter 9: Mixed-language Projects

  • 1. Building Fortran projects that use C/C++ libraries
  • 2. Building C/C++ projects that use Fortran libraries
  • 3. Building C++ and Python projects using Cython
  • 4. Building C++ and Python projects using Boost.Python
  • 5. Building C++ and Python projects using pybind11
  • 6. Mixing C, C++, Fortran, and Python using Python CFFI

Chapter 10: Writing an Installer

  • 1. Installing your project
  • 2. Generating export headers
  • 3. Exporting your targets
  • 4. Installing a superbuild

Chapter 11: Packaging Projects

  • 1. Generating source and binary packages
  • 2. Distributing a C++/Python project built with CMake/pybind11 via PyPI
  • 3. Distributing a C/Fortran/Python project built with CMake/CFFI via PyPI
  • 4. Distributing a simple project as Conda package
  • 5. Distributing a project with dependencies as Conda package

Chapter 12: Building Documentation

  • 1. Building documentation using Doxygen
  • 2. Building documentation using Sphinx
  • 3. Combining Doxygen and Sphinx

Chapter 13: Alternative Generators and Cross-compilation

  • 1. Cross-compiling a hello world example
  • 2. Cross-compiling a Windows binary with OpenMP parallelization

Chapter 14: Testing Dashboards

  • 1. Deploying tests to the CDash dashboard
  • 2. Reporting test coverage to the CDash dashboard
  • 3. Using the AddressSanitizer and reporting memory defects to CDash
  • 4. Using the ThreadSanitizer and reporting data races to CDash

Chapter 15: Porting a Project to CMake

Expand
Additional Information
Related Applications
Recommended for You
Related Information All