diff --git a/cmake/modules/HandleROSAOptions.cmake b/cmake/modules/HandleROSAOptions.cmake index 6571163..98102e8 100644 --- a/cmake/modules/HandleROSAOptions.cmake +++ b/cmake/modules/HandleROSAOptions.cmake @@ -1,102 +1,171 @@ # 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( "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" ) - 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++14" CXX_SUPPORTS_CXX14) if ( CXX_SUPPORTS_CXX14 ) append("-std=c++14" CMAKE_CXX_FLAGS) else() message(FATAL_ERROR "RoSA requires C++14 support but the '-std=c++14' 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() -else ( ROSA_COMPILER_IS_GCC_COMPATIBLE ) - # FIXME: set the same things as for GCC-compatible compilers -endif( ROSA_COMPILER_IS_GCC_COMPATIBLE ) +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". + append("/Wall /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 -fno-exceptions". + append("/GR- /EHs-c-" 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 ) + # Clang is surely a new version, must know about these flags. + append("-Xclang -std=c++14" CMAKE_CXX_FLAGS) + append("-Xclang -std=c11" CMAKE_C_FLAGS) + endif() + # No need to select C/C++ standard otherwise? + +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 ) - diff --git a/docs/Build.rst b/docs/Build.rst index 1110d85..3174ca5 100755 --- a/docs/Build.rst +++ b/docs/Build.rst @@ -1,348 +1,348 @@ =========================== Building the RoSA Framework =========================== .. contents:: :local: 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); * Build system of your choice that can be targeted by CMake -- including a compiler supporting *C++14*. - * LLVM -- minimum version 3.9.0 (due to :ref:`this issue - `) + * Clang/LLVM -- minimum version 3.9.0 + [#f-clang_template_argument_deduction_DeluxeAgent]_ 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. .. _cmake-variables: CMake Variables =============== Beyond the usual CMake variables, the following project-related options are available: `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`. The option defaults to `ON`. + 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. The -framework compiles with *Clang 3.8.0*. +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. You need to have RoSA sources on -your computer and Clang executables available via `PATH`.:: +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=clang CXX=clang++ cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Debug -DROSA_LOG_LEVEL=4 ../rosa-src/ + 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 -------------------------------------- Unfortunately, the native MSVC compiler cannot compile the framework. One needs -to use Clang with Visual Studio in order to build the framework. There are two -alternatives to do that: +to use Clang with Visual Studio in order to build the framework. -* using the *Clang/C2* module for *Visual Studio 2017*, -* using *LLVM for Windows* as an external toolset for Visual Studio - (necessary for older versions of Visual Studio). - -For using Visual Studio 2017 -- which would be the preferred way -- one needs to -select *Clang/C2 (experimental)* on the *Individual components* tab in *Visual -Studio Installer*. +Microsoft recently started to bundle a special version of Clang to Visual Studio +as the *Clang/C2* module. That compiler is, however, several versions behind the +official LLVM releases as of Visual Studio 2017. Therefore, it is necessary to +use *LLVM for Windows* as an external toolset for Visual Studio. For using *LLVM for Windows*, one downloads the official binary release from http://llvm.org and consults with its documentation. The release provides -integration for Visual Studio versions between 2010 and 2014 (as of LLVM 4.0.0). +integration for Visual Studio starting from Visual Studio 2010. + +Prepare your toolchain like this: + +#. Install Visual Studio. + + * If installing Visual Studio 2017, make sure the component + *VC++ 2015.3 v140 toolset (x86,x64)* on the *Individual components* tab is + selected in *Visual Studio Installer*. Installing the older *v140 toolset* + is necessary because the LLVM integration (as of version 4.0.1) does not + support the *v141 toolset*, which is default for Visual Studio 2017. + * Otherwise, default installation of Visual Studio should go. + +#. Install *LLVM for Windows*. +#. Install the integration by executing as *Administrator*:: + + > \tools\msbuild\install.bat Having your build system prepared 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. - #. Define your optional toolset (argument for `-T`): + #. Define your optional toolset (argument for `-T`) as `LLVM-vs`. - * Clang/C2 with VS2017: `v141_clang_c2`. - * LLVM for Windows with older VS: `LLVM-vs`. + * Note that `` refers to the version of Visual Studio: `2010`, + `2012`, `2013`, and `2014`. Visual Studio 2017 with the *v140 toolset* + uses `2014`. #. 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*. - .. _CMake-VS2017-Clang-fix: - -#. Fix the generated Visual Studio projects (*applies for Clang/C2*): - - * The generated projects define `ExceptionHandling` as `Sync`, which is an - invalid value for Clang/C2 and needs to be changed to `Enabled` in all - Visual Studio project files: - - * using GNU command line tools:: - - rosa-build$ find . -name "*.vcxproj" -print|xargs sed -i -e 's/Sync/Enabled/g' - - * using PowerShell:: - - rosa-build> ls -path . -include *.vcxproj -recurse | %{ $f=$_; (gc $f.PSPath) | %{ $_ -replace "Sync", "Enabled" } | sc $f.PSPath } - - * Note that the project files need to be fixed every time CMake regenerates - them, which may happen when building the project in Visual Studio in case - you have the CMake project changed in the source directory. - #. 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. Should you use Clang/C2, do not forget to -:ref:`fix the generated Visual Studio projects `. +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. .. _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 API documentation can be found in `docs/doxygen/html`. + +.. rubric:: Footnotes + +.. [#f-clang_template_argument_deduction_DeluxeAgent] + Clang breaks on template argument deduction when instantiating the class + `rosa::deluxe::DeluxeAgent`, the issue is gone with clang version 3.9.0 and + newer. Check the documentation on the relevant constructor for more details. diff --git a/docs/Dev.rst b/docs/Dev.rst index dbe5980..50b9c77 100755 --- a/docs/Dev.rst +++ b/docs/Dev.rst @@ -1,353 +1,355 @@ ============================= 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`_. `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. 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. Tools ~~~~~ Tools, programs based on the RoSA libraries, are implemented in `tools`. .. _Coding_Standards: Coding Standards ---------------- RoSA is implemented in standard *C++14* code. All the software sources are to be written in accordance to the `LLVM Coding Standards`_. 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. 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. 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. 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]_. 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 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/Issues.rst b/docs/Issues.rst index c8c8f16..f575d46 100755 --- a/docs/Issues.rst +++ b/docs/Issues.rst @@ -1,37 +1,38 @@ ================================================================== Known Issues with the Current Implementation of the RoSA Framework ================================================================== .. contents:: :local: TODO ==== * Project logo - `docs/_themes/rosa-theme/static/logo.png` * License? * Packaging with `CPack `_. * What about design documentation on the basics of RoSA? * What about testing the framework? Known Issues ============ * CMake * VS2017 generates intermediate files for the `ZERO_CHECK` project out of the build directory, see `CMake issue #16458`_. - * VS2017 with `v141_clang_c2` toolset requires - :ref:`fix of the generated Visual Studio projects `. -* clang +* C++ - .. _Issues_clang_template_argument_deduction_DeluxeAgent: + * Mangled names of function pointers with non-throwing exception specification + in function signature will change in C++17. That renders binaries generated + with C++14 and C++17 incompatible (for linking). - * Clang breaks on template argument deduction when instantiating the class - `rosa::deluxe::DeluxeAgent`, the issue is gone with clang version 3.9.0 and - newer. Check the documentation on the relevant constructor for more - details. + * Since version 4.0.0, Clang warns about this compatibility issue as part + of `-Wc++1z-compat`. That warning is turned off in the build scripts. + * The langauge standard for building RoSA libraries and applications needs + to be lockstepped: now use C++14 only and step to C++17 later when it is + properly supported by all major compilers. .. _CMake issue #16458: https://gitlab.kitware.com/cmake/cmake/issues/16458 diff --git a/docs/Use.rst b/docs/Use.rst index fda1ccf..cfd8f54 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. 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, for example `v141_clang_c2`. + 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.