diff --git a/CMakeLists.txt b/CMakeLists.txt
index d284dd1..03bbc68 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,181 +1,188 @@
-cmake_minimum_required(VERSION 2.8.8)
+cmake_minimum_required(VERSION 3.3.0)
# Start project, set version here.
project("RoSA")
# NOTE: Adjust the variables version and release in docs/conf.py according to
# version changes here.
set(ROSA_VERSION_MAJOR 0)
set(ROSA_VERSION_MINOR 1)
set(ROSA_VERSION_PATCH 0)
# Add path for custom modules
set(CMAKE_MODULE_PATH
${CMAKE_MODULE_PATH}
"${CMAKE_CURRENT_SOURCE_DIR}/cmake"
"${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules"
)
# Package information
if( NOT PACKAGE_VERSION )
set(PACKAGE_VERSION "${ROSA_VERSION_MAJOR}.${ROSA_VERSION_MINOR}.${ROSA_VERSION_PATCH}")
endif()
set(PACKAGE_NAME "Research on Self-Awareness Framework")
set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
set(PACKAGE_BUGREPORT "david.juhasz@tuwien.ac.at")
#TODO: cpack?
# Sanity check we are to make out-of-tree build
if( CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR )
message(FATAL_ERROR "In-source builds are not allowed.")
endif()
string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
# Set various paths
set(ROSA_MAIN_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR})
set(ROSA_MAIN_INCLUDE_DIR ${ROSA_MAIN_SRC_DIR}/include)
set(ROSA_MAIN_BIN_DIR ${ROSA_MAIN_SRC_DIR}/bin)
set(ROSA_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
set(ROSA_RUNTIME_OUTPUT_INTDIR ${ROSA_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin)
set(ROSA_LIBRARY_OUTPUT_INTDIR ${ROSA_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib)
-set(ROSA_TOOLS_BINARY_DIR ${ROSA_RUNTIME_OUTPUT_INTDIR})
-set(ROSA_LIBRARY_DIR ${ROSA_LIBRARY_OUTPUT_INTDIR})
+set(ROSA_EXEC_BINARY_DIR ${ROSA_BINARY_DIR}/bin)
+set(ROSA_LIBRARY_DIR ${ROSA_BINARY_DIR}/lib)
set(ROSA_INCLUDE_DIR ${ROSA_BINARY_DIR}/include)
+# Add some generic helpers.
+include(AddCMakeTools)
+
# Set build options
option(ROSA_INCLUDE_TOOLS "Generate build targets for RoSA tools." ON)
option(ROSA_INCLUDE_EXAMPLES "Generate build targets for RoSA examples." ON)
option(ROSA_ENABLE_PEDANTIC "Compile with pedantic enabled." ON)
# Assertions are always enabled for Debug builds, this option is respected only
# for non-Debug builds.
option(ROSA_ENABLE_ASSERTIONS "Enable assertions for non-Debug builds." OFF)
option(ROSA_ENABLE_CLANG_TIDY "Run clang-tidy checks when building RoSA." OFF)
option(ROSA_INCLUDE_CLANG_FORMAT "Generate build target for formatting RoSA sources with clang-format." OFF)
option(ROSA_INCLUDE_DOCS "Generate build targets for RoSA documentation." ON)
option(ROSA_BUILD_DOCS "Build RoSA documentation." OFF)
option(ROSA_ENABLE_DOXYGEN "Use doxygen to generate RoSA API documentation." OFF)
option(ROSA_ENABLE_SPHINX "Use Sphinx to generate RoSA documentation." OFF)
set(ROSA_LOG_LEVEL "" CACHE STRING "Level of logging to be used.")
+set(ROSA_INCLUDE_APPS "" CACHE STRING "Generate build targets for the defined RoSA applications.")
+
# All options referred to from HandleROSAOptions have to be specified
# BEFORE this include, otherwise options will not be correctly set on
# first cmake run
include(config-ix)
include(HandleROSAOptions)
# Configure the ROSA configuration header file.
if( NOT ROSA_LOG_LEVEL STREQUAL "")
if( ${ROSA_LOG_LEVEL} EQUAL 5 )
set(ROSA_LOG_LEVEL_INT -1)
else()
set(ROSA_LOG_LEVEL_INT ${ROSA_LOG_LEVEL})
endif()
else()
set(ROSA_LOG_LEVEL_INT -1)
endif()
configure_file(
${ROSA_MAIN_INCLUDE_DIR}/rosa/config/rosa_config.h.cmake
${ROSA_INCLUDE_DIR}/rosa/config/rosa_config.h
)
# They are not referenced. See set_output_directory().
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${ROSA_BINARY_DIR}/bin)
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${ROSA_BINARY_DIR}/lib)
-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${ROSA_BINARY_DIR}/lib)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${ROSA_EXEC_BINARY_DIR})
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${ROSA_LIBRARY_DIR})
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${ROSA_LIBRARY_DIR})
# Set include directories
set(CMAKE_INCLUDE_CURRENT_DIR ON)
include_directories(${ROSA_INCLUDE_DIR} ${ROSA_MAIN_INCLUDE_DIR})
# Set up YCM
set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
message("Set compilation_database_folder in .ymc_extra_conf.py in the source directory if you want to use YMC.")
# Add parts of the project
include(AddROSATools)
add_subdirectory(lib)
+add_subdirectory(apps)
if( ROSA_INCLUDE_TOOLS )
add_subdirectory(tools)
endif()
if( ROSA_INCLUDE_EXAMPLES )
add_subdirectory(examples)
endif()
if( ROSA_INCLUDE_DOCS )
add_subdirectory(docs)
endif()
#TODO: install?
# Print summary
set(ROSA_ENABLE_ASSERTIONS_STR "OFF")
if( ROSA_ENABLE_ASSERTIONS_INT EQUAL 1 )
set(ROSA_ENABLE_ASSERTIONS_STR "ON")
endif()
set(LOG_LEVEL_STR "disabled")
if( NOT ROSA_LOG_LEVEL STREQUAL "" )
if( ${ROSA_LOG_LEVEL} EQUAL 0 )
set(LOG_LEVEL_STR "ERROR")
elseif( ${ROSA_LOG_LEVEL} EQUAL 1 )
set(LOG_LEVEL_STR "WARNING")
elseif( ${ROSA_LOG_LEVEL} EQUAL 2 )
set(LOG_LEVEL_STR "INFO")
elseif( ${ROSA_LOG_LEVEL} EQUAL 3 )
set(LOG_LEVEL_STR "DEBUG")
elseif( ${ROSA_LOG_LEVEL} EQUAL 4 )
set(LOG_LEVEL_STR "TRACE")
elseif( ${ROSA_LOG_LEVEL} EQUAL 5 )
set(LOG_LEVEL_STR "disabled")
else()
set(LOG_LEVEL_STR "invalid")
endif()
endif()
message(STATUS
"\n====================| Build Summary |===================="
"\n"
"\nRoSA version: ${PACKAGE_VERSION}"
"\n"
"\nBuild type: ${CMAKE_BUILD_TYPE}"
"\nAssertions: ${ROSA_ENABLE_ASSERTIONS_STR}"
"\nClang-tidy: ${ROSA_ENABLE_CLANG_TIDY}"
"\nClang-format: ${ROSA_INCLUDE_CLANG_FORMAT}"
"\nLog level: ${LOG_LEVEL_STR}"
"\n"
+ "\nBuild apps: ${ROSA_INCLUDE_APPS}"
"\nBuild tools: ${ROSA_INCLUDE_TOOLS}"
"\nBuild examples: ${ROSA_INCLUDE_EXAMPLES}"
"\nInclude docs: ${ROSA_INCLUDE_DOCS}"
"\nBuild docs: ${ROSA_BUILD_DOCS}"
"\n -enable doxygen: ${ROSA_ENABLE_DOXYGEN}"
"\n -enable Sphinx: ${ROSA_ENABLE_SPHINX}"
"\n"
"\nCC: ${CMAKE_C_COMPILER}"
"\nCFLAGS: ${CMAKE_C_FLAGS}"
"\nCXX: ${CMAKE_CXX_COMPILER}"
"\nCXXFLAGS: ${CMAKE_CXX_FLAGS}"
"\nLIBRARIES: ${LD_FLAGS}"
"\n"
"\nSource directory: ${ROSA_MAIN_SRC_DIR}"
"\nBuild directory: ${ROSA_BINARY_DIR}"
- "\nExecutable path: ${ROSA_TOOLS_BINARY_DIR}"
+ "\nExecutable path: ${ROSA_EXEC_BINARY_DIR}"
"\nLibrary path: ${ROSA_LIBRARY_DIR}"
"\nGenerator: ${CMAKE_GENERATOR}"
"\n"
"\n===========================================================\n")
diff --git a/tools/CMakeLists.txt b/apps/CMakeLists.txt
similarity index 68%
copy from tools/CMakeLists.txt
copy to apps/CMakeLists.txt
index 615687a..813fd09 100644
--- a/tools/CMakeLists.txt
+++ b/apps/CMakeLists.txt
@@ -1,2 +1,2 @@
# Add the different subdirectories
-
+ADDALLSUBDIRS()
diff --git a/cmake/modules/AddCMakeTools.cmake b/cmake/modules/AddCMakeTools.cmake
new file mode 100644
index 0000000..0db8fde
--- /dev/null
+++ b/cmake/modules/AddCMakeTools.cmake
@@ -0,0 +1,19 @@
+# Stores a list of subdirectories of directory ${curdir} into result.
+macro(SUBDIRLIST result curdir)
+ file(GLOB children RELATIVE ${curdir} ${curdir}/*)
+ set(dirlist "")
+ foreach( child ${children} )
+ if( IS_DIRECTORY ${curdir}/${child} )
+ list(APPEND dirlist ${child})
+ endif()
+ endforeach()
+ set(${result} ${dirlist})
+endmacro()
+
+# Adds all subdirs of the current list directory.
+macro(ADDALLSUBDIRS)
+ SUBDIRLIST(subdirs ${CMAKE_CURRENT_SOURCE_DIR})
+ foreach( subdir ${subdirs})
+ add_subdirectory(${subdir})
+ endforeach()
+endmacro()
diff --git a/cmake/modules/AddROSATools.cmake b/cmake/modules/AddROSATools.cmake
index 24d6c5c..9ded653 100644
--- a/cmake/modules/AddROSATools.cmake
+++ b/cmake/modules/AddROSATools.cmake
@@ -1,18 +1,30 @@
# Use this to set include paths which needs to be used by any target depending
# on a library. After the library name, you pass any number of paths.
macro(ROSA_set_external_include_reqs library)
set(${library}_EXTERNAL_INCLUDES ${ARGN}
CACHE INTERNAL "Externally required include paths for ${library}")
endmacro()
# Use this for a target to register library dependencies.
# It also adds external include paths if the library have set any.
+# It ignores dependencies for ignored apps.
macro(ROSA_add_library_dependencies target dependencies)
- foreach( dependency ${dependencies} )
- target_link_libraries(${target} ${dependency})
- if( ${dependency}_EXTERNAL_INCLUDES )
- include_directories(${${dependency}_EXTERNAL_INCLUDES})
- endif()
- endforeach()
+ if( NOT DEFINED ${target}_APP_IGNORED )
+ foreach( dependency ${dependencies} )
+ target_link_libraries(${target} ${dependency})
+ if( ${dependency}_EXTERNAL_INCLUDES )
+ include_directories(${${dependency}_EXTERNAL_INCLUDES})
+ endif()
+ endforeach()
+ endif()
endmacro()
+# Use this for an app to register its executable. If the app is not included in
+# the build, it will be ignored.
+macro(ROSA_add_app app sources)
+ if( ${app} IN_LIST ROSA_INCLUDE_APPS )
+ add_executable(${app} ${sources})
+ else()
+ set(${app}_APP_IGNORED true)
+ endif()
+endmacro()
diff --git a/cmake/modules/HandleROSAOptions.cmake b/cmake/modules/HandleROSAOptions.cmake
index c64f194..ac48f20 100644
--- a/cmake/modules/HandleROSAOptions.cmake
+++ b/cmake/modules/HandleROSAOptions.cmake
@@ -1,204 +1,211 @@
# This CMake module is responsible for interpreting the user defined ROSA_
# options and executing the appropriate CMake commands to realize the users'
# selections.
include(CheckCCompilerFlag)
include(CheckCXXCompilerFlag)
if ( "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" )
set(ROSA_COMPILER_IS_CLANG ON)
# Enforce minimum version.
if ( CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.9.0" )
message(FATAL_ERROR "Insufficient LLVM version")
endif()
else()
set(ROSA_COMPILER_IS_CLANG OFF)
endif()
if( CMAKE_COMPILER_IS_GNUCXX )
set(ROSA_COMPILER_IS_GCC_COMPATIBLE ON)
elseif( MSVC )
set(ROSA_COMPILER_IS_GCC_COMPATIBLE OFF)
elseif( ROSA_COMPILER_IS_CLANG )
set(ROSA_COMPILER_IS_GCC_COMPATIBLE ON)
else()
message(FATAL_ERROR "Unexpected C++ compiler!")
endif()
function(append value)
foreach(variable ${ARGN})
set(${variable} "${${variable}} ${value}" PARENT_SCOPE)
endforeach(variable)
endfunction()
function(append_if condition value)
if (${condition})
foreach(variable ${ARGN})
set(${variable} "${${variable}} ${value}" PARENT_SCOPE)
endforeach(variable)
endif()
endfunction()
# NDEBUG on non-Debug builds
append("-DNDEBUG" CMAKE_CXX_FLAGS_RELEASE
CMAKE_CXX_FLAGS_RELWITHDEBINFO
CMAKE_CXX_FLAGS_MINSIZEREL
CMAKE_C_FLAGS_RELEASE
CMAKE_C_FLAGS_RELWITHDEBINFO
CMAKE_C_FLAGS_MINSIZEREL)
# Assertions are always enabled on Debug builds, this is interesting for
# non-Debug builds.
if( NOT "${uppercase_CMAKE_BUILD_TYPE}" STREQUAL "DEBUG" AND ${ROSA_ENABLE_ASSERTIONS} )
# MSVC doesn't like _DEBUG on release builds. See PR 4379.
if( NOT MSVC )
add_definitions( -D_DEBUG )
set(ENABLE_ASSERTIONS "1")
else()
set(ENABLE_ASSERTIONS "0")
endif()
# On non-Debug builds we NDEBUG, but in this case we need to undefine it:
add_definitions(-UNDEBUG)
# Also remove /D NDEBUG to avoid MSVC warnings about conflicting defines.
foreach (flags_var_to_scrub
CMAKE_CXX_FLAGS_RELEASE
CMAKE_CXX_FLAGS_RELWITHDEBINFO
CMAKE_CXX_FLAGS_MINSIZEREL
CMAKE_C_FLAGS_RELEASE
CMAKE_C_FLAGS_RELWITHDEBINFO
CMAKE_C_FLAGS_MINSIZEREL)
string (REGEX REPLACE "(^| )[/-]D *NDEBUG($| )" " "
"${flags_var_to_scrub}" "${${flags_var_to_scrub}}")
endforeach()
endif()
set(ROSA_ENABLE_ASSERTIONS_INT -1)
if( "${uppercase_CMAKE_BUILD_TYPE}" STREQUAL "DEBUG" OR ${ROSA_ENABLE_ASSERTIONS} )
set(ROSA_ENABLE_ASSERTIONS_INT 1)
endif()
if( ROSA_COMPILER_IS_GCC_COMPATIBLE )
append("-Wall -Wextra -Wdocumentation -Werror" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
append_if(ROSA_ENABLE_PEDANTIC "-pedantic -Wno-long-long" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
append("-fno-rtti -fno-exceptions" CMAKE_CXX_FLAGS)
append("-Wno-c++1z-compat" CMAKE_CXX_FLAGS)
check_cxx_compiler_flag("-std=c++17" CXX_SUPPORTS_CXX17)
if ( CXX_SUPPORTS_CXX17 )
append("-std=c++17" CMAKE_CXX_FLAGS)
else()
message(FATAL_ERROR "RoSA requires C++17 support but the '-std=c++17' flag isn't supported.")
endif()
check_c_compiler_flag("-std=c11" C_SUPPORTS_C11)
if ( C_SUPPORTS_C11 )
append("-std=c11" CMAKE_C_FLAGS)
else()
message(FATAL_ERROR "RoSA requires C11 support but the '-std=c11' flag isn't supported.")
endif()
elseif ( MSVC )
if (ROSA_COMPILER_IS_CLANG)
# Remove/adjsut incorrect flags that might be generated automatically.
foreach (flags_var_to_scrub
CMAKE_CXX_FLAGS
CMAKE_CXX_FLAGS_DEBUG
CMAKE_CXX_FLAGS_RELEASE
CMAKE_CXX_FLAGS_RELWITHDEBINFO
CMAKE_CXX_FLAGS_MINSIZEREL
CMAKE_C_FLAGS
CMAKE_C_FLAGS_DEBUG
CMAKE_C_FLAGS_RELEASE
CMAKE_C_FLAGS_RELWITHDEBINFO
CMAKE_C_FLAGS_MINSIZEREL)
string (REGEX REPLACE "(^| )-Wall($| )" " "
"${flags_var_to_scrub}" "${${flags_var_to_scrub}}")
string (REGEX REPLACE "(^| )-frtti($| )" " "
"${flags_var_to_scrub}" "${${flags_var_to_scrub}}")
string (REGEX REPLACE "(^| )-fexceptions($| )" " "
"${flags_var_to_scrub}" "${${flags_var_to_scrub}}")
string (REGEX REPLACE "(^| )-fno-inline($| )" " -Ob0 "
"${flags_var_to_scrub}" "${${flags_var_to_scrub}}")
string (REGEX REPLACE "(^| )-gline-tables-only($| )" " "
"${flags_var_to_scrub}" "${${flags_var_to_scrub}}")
message("${flags_var_to_scrub}: ${${flags_var_to_scrub}}")
endforeach()
endif()
# Flags matching GCC-compatible "-Wall -Wextra -Werror".
# NOTE: Do not use -Wall for MSVC because it generates silly warning (e.g.,
# warnings about things in external libraries), use -W4 instead.
append("/W4 /WX" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
if ( ROSA_COMPILER_IS_CLANG )
# GCC-compatible flags without corresponding MSVC options.
append("-Wdocumentation" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
# The flag "-pedantic" is not in the MSVC flavour.
append_if(ROSA_ENABLE_PEDANTIC "-Wno-long-long" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
endif()
# Flags matching GCC-compatible "-fno-rtti".
append("/GR-" CMAKE_CXX_FLAGS)
# NOTE: We cannot disable unwind semantics (i.e., -fno-exceptions) for Windows
# libraries...
append("/EHsc" CMAKE_CXX_FLAGS)
if ( ROSA_COMPILER_IS_CLANG )
append("-Wno-c++1z-compat" CMAKE_CXX_FLAGS)
# MSVC puts there some garbage which needs to be ignored...
append("-Qunused-arguments" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
endif()
if ( ROSA_COMPILER_IS_CLANG )
check_cxx_compiler_flag("-Xclang -std=c++17" CXX_SUPPORTS_CXX17)
if ( CXX_SUPPORTS_CXX17 )
append("-Xclang -std=c++17" CMAKE_CXX_FLAGS)
else()
message(FATAL_ERROR "RoSA requires C++17 support but the '-std=c++17' flag isn't supported.")
endif()
check_c_compiler_flag("-Xclang -std=c11" C_SUPPORTS_C11)
if ( C_SUPPORTS_C11 )
append("-Xclang -std=c11" CMAKE_C_FLAGS)
else()
message(FATAL_ERROR "RoSA requires C11 support but the '-std=c11' flag isn't supported.")
endif()
else ()
check_cxx_compiler_flag("/std:c++17 /permissive-" CXX_SUPPORTS_CXX17)
if ( CXX_SUPPORTS_CXX17 )
append("/std:c++17 /permissive-" CMAKE_CXX_FLAGS)
else()
message(FATAL_ERROR "RoSA requires C++17 support but the '/std:c++17 /permissive-' flags aren't supported.")
endif()
message(WARNING "RoSA is supposed to use C11 code in C files, which MSVC might not fully support.")
# Make MSVC ignore warning LNK4221 in libraries. The warning is caused by
# empty object files that correspond to the empty .cpp files, which we have
# for generating compile database entries for all header files.
append("/IGNORE:4221" CMAKE_STATIC_LINKER_FLAGS)
endif()
endif()
if( ROSA_ENABLE_CLANG_TIDY )
# Set clang-tidy arguments, use the same for both C and CXX.
set(CMAKE_C_CLANG_TIDY "${CLANGTIDY_EXECUTABLE};-header-filter=.*")
set(CMAKE_CXX_CLANG_TIDY ${CMAKE_C_CLANG_TIDY})
# Apply suggested fixes if requested.
append_if(ROSA_CLANG_TIDY_FIX ",-fix" CMAKE_C_CLANG_TIDY CMAKE_CXX_CLANG_TIDY)
endif( ROSA_ENABLE_CLANG_TIDY )
+
+if( ROSA_INCLUDE_APPS STREQUAL "")
+ message(STATUS "Include all apps by default.")
+ SUBDIRLIST(ROSA_INCLUDE_APPS ${ROSA_MAIN_SRC_DIR}/apps)
+else()
+ message(STATUS "Include apps: ${ROSA_INCLUDE_APPS}.")
+endif()
diff --git a/docs/Build.rst b/docs/Build.rst
index 6b84461..042b40d 100755
--- a/docs/Build.rst
+++ b/docs/Build.rst
@@ -1,318 +1,321 @@
===========================
Building the RoSA Framework
===========================
.. contents::
:local:
.. _build_deps:
Build Dependencies
==================
In order to build RoSA, the following tools are required:
* `CMake `_ (minimum version 3.6.0 if clang-tidy is used,
- 2.8.8 otherwise);
+ 3.3.0 otherwise);
* Build system of your choice that can be targeted by CMake -- including a
compiler supporting *C++17*.
* Clang/LLVM -- minimum version 5.0.0
* Visual Studio 2017 -- minimum version 15.7
The following additional tools are required to generate documentation:
* `Doxygen `_ -- for generating API documentation;
* `Graphviz `_ -- not necessary, but the API
documentation has nicer graphics when `dot` is available;
* `Sphinx `_ (with *Python 2*) -- for generating
documentation.
The following additional tools are required to check and possibly enforce coding
standard:
* `clang-tidy `_
* `clang-format `_
General notes
=============
* The framework is delivered with a CMake project, which can be used to generate
build projects to build the framework.
* The provided CMake project supports out-of-tree builds only, i.e. one must use
a separate build directory outside of the RoSA source directory.
.. _doxygen-warnings:
* Doxygen warnings -- typically indicating actual errors -- are printed to
`stderr`, do check that when generating API documentation.
.. _cmake-variables:
CMake Variables
===============
Beyond the usual CMake variables, the following project-related options are
available:
+`ROSA_INCLUDE_APPS`
+ Generate build targets for the defined RoSA applications. The option is a string that is a list of app names. All apps that are present in the option are built, others are ignored. All apps are built by default.
+
`ROSA_INCLUDE_TOOLS`
Generate build targets for RoSA tools. The tools are also built when the
option is set to `ON`, which is the default setting.
`ROSA_INCLUDE_EXAMPLES`
Generate build targets for RoSA examples. The examples are also built when the
option is set to `ON`, which is the default setting.
`ROSA_ENABLE_PEDANTIC`
Compile the framework with using `-pedantic` for GCC-compatible compilers,
otherwise ignored. The option defaults to `ON`.
`ROSA_ENABLE_ASSERTIONS`
Enable assertions for non-Debug builds, which defaults to `OFF`.
Note that assertions are always enabled for Debug builds and this option is
ignored for such builds.
.. _CMake_clang_tidy:
`ROSA_ENABLE_CLANG_TIDY`
Run *clang-tidy* checks when building RoSA, which defaults to `OFF`.
When the variable is enabled, build targets created by *Makefile* and *Ninja*
generators include calls for clang-tidy. Other generators ignore this option.
Note that CMake variables `CMAKE__CLANG_TIDY` are set when enabled.
Settings for clang-tidy are defined by the file `.clang-tidy` in the RoSA
source directory.
Consider the following options when the option is enabled:
`ROSA_CLANG_TIDY_PATH`
Custom path for `clang-tidy` executable.
In order to use clang-tidy, CMake needs to find the `clang-tidy`
executable. If `clang-tidy` to be used is available via `PATH`, just leave
the option empty -- which is default. Set the absolute path of the
directory containing the `clang-tidy` executable otherwise, in which case
no default path is searched for `clang-tidy`.
`ROSA_CLANG_TIDY_FIX`
Apply suggested clang-tidy fixes to the sources, which defaults to `OFF`.
Enable the option only if you know what you are doing.
.. _CMake_clang_format:
`ROSA_INCLUDE_CLANG_FORMAT` **[experimental]**
Generate build target -- `format-rosa` -- for formatting RoSA sources with
*clang-format*, which defatuls to `OFF`.
When the variable is enabled and *CMake is not running on a Windows host*, a
build target is generated which can be used to have all the RoSA sources
formatted with clang-format. Settings for clang-format are defined by the file
`.clang-format` in the RoSA source directory.
Note that executing build target `format-rosa` will reformat all the source
files *inplace*.
Consider the following option when a build target for clang-format is to be
generated:
`ROSA_CLANG_FORMAT_PATH`
Custom path for `clang-format` executable.
In order to use clang-format, CMake needs to find the `clang-format`
executable. If `clang-format` to be used is available via `PATH`, just
leave the option empty -- which is default. Set the absolute path of the
directory containing the `clang-format` executable otherwise, in which case
no default path is search for `clang-format`.
`ROSA_LOG_LEVEL`
Level of logging to be used, use one of the following valid integer values.
======== =========
Variable Log Level
======== =========
`0` `ERROR`
`1` `WARNING`
`2` `INFO`
`3` `DEBUG`
`4` `TRACE`
`5` *disabled*
======== =========
Level of logging defaults to *disabled*.
`ROSA_INCLUDE_DOCS`
Generate build targets for RoSA documentation, defaults to `ON`.
Note that the automatic execution of the generated build targets is
controlled by the option `ROSA_BUILD_DOCS`. The actual documentations to
build are controlled by the options `ROSA_ENABLE_DOXYGEN` and
`ROSA_ENABLE_SPHINX`.
`ROSA_BUILD_DOCS`
Build RoSA documentation automatically as part of the build process. The
option defaults to `OFF` and takes effect only if the option
`ROSA_INCLUDE_DOCS` is enabled.
.. _CMake_doxygen:
`ROSA_ENABLE_DOXYGEN`
Use *doxygen* to generate RoSA API documentation. The option defaults to `OFF`
and takes effect only if the option `ROSA_INCLUDE_DOCS` is enabled.
Doxygen documentation may be generated by executing build target
`doxygen-rosa`, which is done as part of the default build process if
`ROSA_BUILD_DOCS` is enabled.
Doxygen must be available via `PATH` if the option is enabled.
The following options are also available to tune doxygen:
`ROSA_DOXYGEN_SVG`
Use *svg* instead of *png* files for doxygen graphs. The option defaults to
`OFF` and takes effect if the tool *dot* is available via `PATH` to be used
to generated graph images.
`ROSA_DOXYGEN_EXTERNAL_SEARCH`
Enable doxygen external search, which defatuls to `OFF`.
The following options need to be set if the option is enabled:
`ROSA_DOXYGEN_SEARCHENGINE_URL`
URL to use for external search.
`ROSA_DOXYGEN_SEARCH_MAPPINGS`
Doxygen Search Mappings.
.. _CMake_sphinx:
`ROSA_ENABLE_SPHINX`
Use *Sphinx* to generate RoSA documentation. The option defaults to `OFF` and
takes effect only if the option `ROSA_INCLUDE_DOCS` is enabled.
Sphinx must be available via `PATH` if the option is enabled.
The following options are also available to tune Sphinx:
`SPHINX_OUTPUT_HTML`
Output standalone HTML files. The option defaults to `ON`.
Documentation may be generated by executing build target `docs-rosa-html`,
which is done as part of the default build process if `ROSA_BUILD_DOCS` is
enabled.
`SPHINX_OUTPUT_MAN`
Output man pages for RoSA tools. The option defaults to `ON`.
Man pages may be generated by executing build target `docs-rosa-man`, which
is done as part of the default build process if `ROSA_BUILD_DOCS` is
enabled.
`SPHINX_WARNINGS_AS_ERRORS`
When building documentation, treat Sphinx warnings as errors. The option
defaults to `ON`.
Building RoSA Step-by-Step
==========================
Building on Linux with Make
---------------------------
Configuring and building the framework on Linux using *Make* is a
straightforward process which does not require performing any tricks.
Set C and C++ compilers with the variables `CC` and `CXX`, respectively. Use the
CMake variable `CMAKE_BUILD_TYPE` to set the type of build: `Debug`, `Release`.
Follows an example on building the framework with all options turned on. CMake
variables may be skipped as necessary. You need to have RoSA sources on your
computer.::
rosa-src$ cd ..
$ mkdir rosa-build
$ cd rosa-build
rosa-build$ CC= CXX= -G "Unix Makefiles" -DROSA_ENABLE_CLANG_TIDY=ON -DROSA_CLANG_TIDY_PATH= -DROSA_INCLUDE_CLANG_FORMAT=ON -DROSA_CLANG_FORMAT_PATH= -DROSA_LOG_LEVEL=4 -DROSA_ENABLE_DOXYGEN=ON -DROSA_DOXYGEN_SVG=ON -DROSA_ENABLE_SPHINX=ON -DCMAKE_BUILD_TYPE=Debug ../rosa-src
[CMake configures and generates without errors]
$ make
[Make builds the project]
You just need to re-run Make in order to re-build the project after changing
the source code and the CMake project. In case the CMake project is changed,
Make automatically calls CMake to update the build project.
In order to build documentation and enforce coding standard, refer to
corresponding :ref:`cmake-variables`.
.. _Build_VS:
Building on Windows with Visual Studio
--------------------------------------
This is how to use the native MSVC compiler to build RoSA.
Having your build system prepared (see `Build Dependencies`_) and RoSA sources
fetched to your computer, configure and build the framework like this:
#. Generate Visual Studio solution with CMake:
#. Start CMake.
#. Define *source directory* and a separate *build directory* in CMake.
#. Click *Configure*.
#. Select the proper *generator* for your version of Visual Studio.
#. Click *Finish*.
#. Tune CMake variables as you wish.
* Note that Visual Studio Generators are multi-configuration generators,
hence you cannot set `CMAKE_BUILD_TYPE`. You need to select a
configuration to build in Visual Studio.
#. Click *Generate*.
#. Build the framework with Visual Studio:
#. Open the generated `RoSA.sln` from the build directory with Visual
Studio.
#. Build the project `ALL_BUILD`.
You just need to re-build the project in Visual Studio after changing the
source code and the CMake project.
In case the CMake project is changed, Visual Studio automatically calls CMake
the update the build project.
Build Result
============
The build process works in the build directory. After a successful build, one
can find the following final outputs there -- besides some intermediate files.
.. _Build_Result_Software:
Software
--------
In the build directory, `include` contains header files which are generated by
CMake and provide configuration-specific information.
The build process generates static libraries in `lib` and executables --
-examples and tools -- in `bin`. Projects generated by a multi-configuration
-generator result in the actual libraries and executables being located in
-subdirectories corresponding to different build configurations.
+examples, apps, and tools -- in `bin`. Projects generated by a
+multi-configuration generator result in the actual libraries and executables
+being located in subdirectories corresponding to different build configurations.
.. _Build_Result_Documentation:
Documentation
-------------
Documentation is generated in `docs`.
-The general documentation can be found in `docs/html`. Man pages for tools can
-be found in `docs/man`.
+The general documentation can be found in `docs/html`. Man pages for apps and
+tools can be found in `docs/man`.
The API documentation can be found in `docs/doxygen/html`.
.. rubric:: Footnotes
diff --git a/docs/Dev.rst b/docs/Dev.rst
index 4da5fb0..78ed678 100755
--- a/docs/Dev.rst
+++ b/docs/Dev.rst
@@ -1,359 +1,373 @@
=============================
Developing the RoSA Framework
=============================
.. contents::
:local:
This document provides information that might be useful for contributing to
RoSA. Please also consult :doc:`Build`.
.. _Dev_Source_Directory:
The Source Directory
====================
The source directory consists of the following subdirectories:
`cmake`
Contains files used for configuring the `CMake Project`_.
`docs`
Contains `Documentation`_-related files.
`examples`
Contains `Examples`_ on using the public API.
`include/rosa`
Contains the RoSA public API -- that is the interface of RoSA `Libraries`_.
The directory `include` is to be used as include directory and RoSA header
files are to be included in C++ sources as `"rosa/"`.
`lib`
Contains the implementation of the RoSA public API -- that is the
implementation of RoSA `Libraries`_.
+`apps`
+ Contains `Apps`_ based on RoSA features.
+
`tools`
Contains `Tools`_ based on RoSA features.
Software Sources
================
The section describes the `Logical Structure`_ of the software sources and what
`Coding Standards`_ are supposed to be followed for the implementation.
Logical Structure
-----------------
Various features provided by RoSA are sorted into different `Libraries`_.
-`Examples`_ and `Tools`_ using those `Libraries`_ are separated from the
-implementation of the RoSA features into different directories.
+`Examples`_ , `Apps`_, and `Tools`_ using those `Libraries`_ are separated from
+the implementation of the RoSA features into different directories.
Libraries
~~~~~~~~~
The framework consists of separate libraries providing different features. The
public interfaces for RoSA libraries are defined in `include/rosa`, while
corresponding implementation is in `lib`. Each library has its own subdirectory
in the mentioned directories.
RoSA provides the following libraries:
`config`
Provides information on the configuration used to build the framework, e.g.,
version number, log level, assertions, and debugging.
`support`
Provides general features -- template metaprograms dealing with types, for
instance -- for implementing other libraries.
`core`
Provides the basic RoSA features, like systems managing agents passing
messages.
`agent`
Provides features to be used for implementing agents.
`deluxe`
Provides a somewhat more modular interface for defining systems with RoSA.
.. _Library_Dependencies:
Dependencies
''''''''''''
The following table summarizes dependencies among libraries.
A marking in a row denotes that the library in the beginning of the row depends
on the library in the head of the given column.
+---------+--------+---------+------+--------+-------+
| | config | support | core | deluxe | agent |
+=========+========+=========+======+========+=======+
| config | | | | | |
+---------+--------+---------+------+--------+-------+
| support | | | | | |
+---------+--------+---------+------+--------+-------+
| core | | × | | | |
+---------+--------+---------+------+--------+-------+
| deluxe | | | × | | |
+---------+--------+---------+------+--------+-------+
| agent | | | | | |
+---------+--------+---------+------+--------+-------+
Examples
~~~~~~~~
Some simple samples are provided in `examples` to demonstrate how to to use
different parts of the RoSA API.
+Apps
+~~~~
+
+Apps, actual applications based on the RoSA libraries, are implemented in
+`apps`.
+
Tools
~~~~~
-Tools, programs based on the RoSA libraries, are implemented in `tools`.
+Tools, programs based on the RoSA libraries and providing standalone
+functionalities, are implemented in `tools`.
.. _Coding_Standards:
Coding Standards
----------------
RoSA is implemented in standard *C++17* code. All the software sources are to
be written in accordance to the `LLVM Coding Standards`_.
.. _nortti-noexceptions:
Feature Restrictions
~~~~~~~~~~~~~~~~~~~~
Pay attention `not to use RTTI and Exceptions`_. Those features are disabled in
the CMake project.
Documentation Comments
~~~~~~~~~~~~~~~~~~~~~~
It is important to remember to document source code using `doxygen comments`_
as `API Documentation`_ is generated directly from sources.
Note that the syntax of documentation comments is checked during compilation --
at least when using a GCC-compatible compiler. Further, check
:ref:`Doxygen warnings ` as issues not being detected by the
compiler may be found when actually generating the documentation.
Whenever you work on a source file, make sure your name is in the author-list
defined in the header comment of the file. Each author should be defined with a
separate `\\author` command so that recent authors come first. Authors not
participating in further development of a file anymore may be marked with the
period of their contribution.
If declarations belonging to a namespace are spread to more than one source
files, document the namespace in a separate `namespace.h` in the directory
belonging to the library. Otherwise, document the namespace in the only file in
which entities of the namespace are declared.
Header Files
~~~~~~~~~~~~
Follow the recommendations on public and private header files and the usage of
`#include` from the `LLVM Coding Standards`_.
Use `.h` and `.hpp` extensions to indicate the content of the header file:
* header files containing any *definition* -- template or inline definition --
or including another header file with `.hpp` extension have `.hpp` extension;
* header files containing only *declarations* and including only header files
with `.h` extension have `.h` extension.
It may happen that a header file does not need any corresponding implementation
in a `.cpp` file. Nevertheless, do create a corresponding `.cpp` file which only
includes the header file in this case. That makes sure that the header file is
compiled and hence checked for errors, and also a corresponding entry in the
compilation database is generated.
Checking and Enforcing the Coding Standards
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The tools `clang-tidy `_ and
`clang-format `_ can be used to
check and enforce the coding standards. The two tools are integrated into the
CMake project, refer to CMake variables
:ref:`ROSA_ENABLE_CLANG_TIDY ` and
:ref:`ROSA_INCLUDE_CLANG_FORMAT `.
Note that there may be situations when `clang-tidy` checks result in false
positives -- for example, for some cases of the order of `#include` directives.
One can order `clang-tidy` to suppress warnings for a line of code by marking
that line with::
// NOLINT
It may be preferred to diverge from the standard formatting -- for example for
the sake of readability of static definition of arrays following some
structure. One can disable `clang-format` for some lines of code by designating
a range with two special comments as::
// clang-format off
... clang-format is disabled here ...
// clang-format on
Documentation
=============
The RoSA Framework is delivered with two kinds of documentation: `General
Documentation`_ and `API Documentation`_, generation of both of which is
integrated into the CMake project.
References between the two documentations are relative addresses corresponding
to the directory structure of the
:ref:`generated documentation `.
General Documentation
---------------------
General documentation is written as
`reStructuredText `_ compiled with
`Sphinx `_. For build integration, refer to the
CMake variable :ref:`ROSA_ENABLE_SPHINX `.
Documentation files are located in `docs` with extension `.rst`. The main
page of the documentation is `docs/index.rst`. Configuration for building the
documentation is `docs/conf.py`.
The directory `docs/CommandGuide` contains documentation for each separate
tool. Those pages are included in the HTML documentation via
`docs/CommandGuide/index.rst`. Moreover, man pages can be generated from those
tool documentation pages.
API Documentation
-----------------
API documentation is directly generated from sources with
`Doxygen `_. For build integration, refer to the CMake
variable :ref:`ROSA_ENABLE_DOXYGEN `.
The main page used for the API documentation is `docs/doxygen-mainpage.dox`.
Configuration for generating the API documentation is `docs/doxygen.cfg.in`.
.. _CMake Project:
Managing the CMake Project
==========================
This section briefly summarizes when and how to modify CMake files during
the development process. No general discussion on CMake features is provided
here.
When modifying `Documentation`_, no need to update the CMake files.
Software
--------
One needs to modify the CMake files only if source files are to be added or
removed from the project. Here follows some typical scenarios.
Source Files
~~~~~~~~~~~~
Each library and executable target has its own directory and its own definition
as a file called `CMakeLists.txt` in that directory.
When adding or removing a source file -- both headers and `.cpp` files -- to a
library or executable, locate the corresponding `CMakeLists.txt` file. The file
is typically in the same directory where the file to be added or removed is
located. Except for header files of the public API, for which the corresponding
CMake target is defined in a `lib` subdirectory corresponding to the library the
header files belongs to.
Update the source list in the argument of the `add_library` or `add_executable`
command in the `CMakeLists.txt`, for libraries and executables, respectively.
A library and executable may use features provided by another library. Such a
dependency is to be defined in the `CMakeLists.txt` file of the dependent
target by using the `ROSA_add_library_dependencies` command.
CMake Libraries
~~~~~~~~~~~~~~~
When adding or removing a library, add or remove the corresponding directories
-from `include` and `lib`, and also update `lib/CMakeLists.txt` by adding or
-removing a `add_subdirectory` command for the library.
+from `include` and `lib`. If you have already had generated a build project
+with CMake, `touch` [#]_ `lib/CMakeLists.txt` to make CMake rescan subdirectories on next build.
When defining a new library, the new subdirectory under `lib` needs to contain a
`CMakeLists.txt`, which needs to contain at least an `add_library` command
defining the name of the library and the source files belonging to it.
CMake Executables
~~~~~~~~~~~~~~~~~
When adding or removing an executable, add or remove the corresponding
-directory from `examples` or `tools`, and also update `CMakeLists.txt` in the
-containing directory as for libraries.
+directory from `apps`, `examples`, or `tools`. If you have already had
+generated a build project with CMake, `touch` `CMakeLists.txt` in the
+containing directory (like in the case of libraries) to make CMake rescan
+subdirectories on next build.
When defining a new executable, the new subdirectory needs to contain a
`CMakeLists.txt`, which needs to contain at least an `add_executable` command
defining the name of the executable and the source files belonging to it.
.. _Dev Managing Sources:
Managing Sources
================
Consider the followings before committing changes to the repository:
* your code complies with the `Coding Standards`_ as much as possible;
* your code is well documented;
* your code is not bloated with unusued code and/or comments;
* your changes do not break building and executing the framework:
* test all of the supported platforms if possible,
* look into the generated documentation if you have edited
`General Documentation`_;
* you do not pollute the repository with unused and generated files.
When committing changes to the repository, provide a concise log message with
your commit.
Miscellaneous Concerns
======================
Using YCM
---------
If you happen to use `YCM `_, just
make a copy of the provided `ycm_extra_conf.py.template` file as
`.ycm_extra_conf.py` in the RoSA source directory, and set the following two
variables in it:
`compilation_database_folder`
the absolute path of your build directory
`extra_system_include_dirs`
- any system include directory which might not be searched by `libclang` [1]_.
+ any system include directory which might not be searched by `libclang` [#]_.
You probably want compile with Clang if you use YCM, so run CMake with
environment variables `CC=clang` and `CXX=clang++` set.
Also note that header files in the `include` directory are compiled for YCM with
the compiler flags of a corresponding source file in the `lib` directory, if
any. Header files in other locations are supposed to have a corresponding source
file in the same directory.
Notes
~~~~~
* If the project's include directory (`include/rosa`) would ever be changed,
then the YCM configuration file needs to be adjusted accordingly.
.. rubric:: Footnotes
-.. [1] See: https://github.com/Valloric/YouCompleteMe/issues/303; use the
+.. [#] Set the last modified time of the file to the current time.
+
+.. [#] See: https://github.com/Valloric/YouCompleteMe/issues/303; use the
following command to figure out the used system directories:
echo | clang -std=c++11 -v -E -x c++ -
.. _`LLVM Coding Standards`: http://llvm.org/docs/CodingStandards.html
.. _`not to use RTTI and Exceptions`: http://llvm.org/docs/CodingStandards.html#do-not-use-rtti-or-exceptions
.. _`doxygen comments`: http://llvm.org/docs/CodingStandards.html#doxygen-use-in-documentation-comments
diff --git a/docs/Use.rst b/docs/Use.rst
index cfd8f54..d9412cb 100755
--- a/docs/Use.rst
+++ b/docs/Use.rst
@@ -1,112 +1,112 @@
========================
Using the RoSA Framework
========================
.. contents::
:local:
General Recommendations
=======================
Before starting to use the RoSA Framework, consult with the provided
documentation. Especially, consider the followings:
* :ref:`Documentation of the RoSA public API `
* :ref:`The used coding standards `
* :doc:`Issues`
Building your own Project
=========================
There are two main approaches to implement software based on features of the
RoSA Framework, which are described as follows.
Extending the RoSA Framework
----------------------------
Should some features be generally relevant in the context of the RoSA
Framework, it may be reasonable to implement them as part of RoSA itself.
Features may be implemented either as extensions for existing libraries and
-tools, or as new libraries and tools -- consider which way fits best.
+tools, or as new libraries, tools, and apps -- consider which way fits best.
Refer to :doc:`Dev`.
Creating a Standalone Project
-----------------------------
One can easily create standalone projects based on the RoSA Framework. Such
projects can be maintained separately from RoSA, but also can be integrated
into the framework whenever that seems suitable. In the latter case, refer to
the previous section, `Extending the RoSA Framework`_.
For building a standalone project, one needs to define
* the *include directories* with declaration of the RoSA public API for
compiling the project, and
* the *static libraries* with the implementation of RoSA features for linking
the project as in
* adding the directory containing the libraries to the library search path,
and
* defining the libraries the project is dependent on.
Regarding library dependencies: it is safe to list all the RoSA libraries,
but it is enough to list the real dependencies only. Do not forget that there
are some :ref:`dependencies among libraries `, which
requires listing all the libraries on a chain of dependency for successful
linking.
Depending on a Binary Release
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The easy way is to base the project on a binary release of RoSA. Howevever,
note that binary releases are generated with
:ref:`particular settings `, which may not always be
suitable to use.
When relying on a binary release of RoSA -- according to the
:ref:`content of release packages ` --:
* use `include` as additional include directory, and
* use `lib` as additional directory for the library search path.
Depending on a Custom Build
~~~~~~~~~~~~~~~~~~~~~~~~~~~
Whenever it is not suitable to rely on a binary release, RoSA needs to be built
manually first. Refer to :doc:`Build`. Note that only building libraries is
required for building a standalone project depending on a custom build of RoSA.
When relying on a custom build of RoSA -- according to the
:ref:`location of the RoSA public API ` and
:ref:`software results of a build ` --:
* use `include` from both the source and the build directories as additional
include directories, and
* use `lib` from the build directory (or its proper subdirectory in case of a
multi-configuration generator) as additional directory for the library search
path.
Visual Studio 2017 -- an Example
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Having a *Visual C++* project created in Visual Studio 2017, the followings need
to be done in order to make the project dependent on RoSA:
* add the RoSA-specific include directories to
`Project/Properties/Configuration Properties/VC++ Directories/Include
Directories`,
* add the configuration-dependent directory containing the RoSA static libraries
to
`Project/Properties/Configuration Properties/VC++ Directories/Library
Directories`,
* add the RoSA library files to
`Project/Properties/Configuration Properties/Linker/Input/Additional
Dependencies`,
* consult with :ref:`the build description for Visual Studio ` and set
`Project/Properties/Configuration Properties/General/Platform Toolset` to a
suitable value, `LLVM-vs`.
Make sure in `Project/Properties` that `Configuration` and `Platform` of the
project matches those of the RoSA build whose libraries are to be used for
building the project.
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 276f940..813fd09 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -1,8 +1,2 @@
# Add the different subdirectories
-add_subdirectory(basic-system)
-add_subdirectory(type-facilities)
-add_subdirectory(messaging)
-add_subdirectory(messaging-system)
-add_subdirectory(agent-modules)
-add_subdirectory(deluxe-interface)
-
+ADDALLSUBDIRS()
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index 25754a4..813fd09 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -1,6 +1,2 @@
-# Add the different subdirectories.
-add_subdirectory(config)
-add_subdirectory(support)
-add_subdirectory(core)
-add_subdirectory(agent)
-add_subdirectory(deluxe)
+# Add the different subdirectories
+ADDALLSUBDIRS()
diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt
index 615687a..813fd09 100644
--- a/tools/CMakeLists.txt
+++ b/tools/CMakeLists.txt
@@ -1,2 +1,2 @@
# Add the different subdirectories
-
+ADDALLSUBDIRS()