Use cmake-format to format CMake files

Signed-off-by: Steffen Jaeckel <s@jaeckel.eu>

CMakeLists.txt

@@ -5,20 +5,23 @@
 
 cmake_minimum_required(VERSION 3.10)
 
-project(libtomcrypt
+project(
+    libtomcrypt
     VERSION 1.18.2
     DESCRIPTION "A modular cryptographic library."
     HOMEPAGE_URL "https://www.libtom.net/LibTomCrypt"
-    LANGUAGES C)
+    LANGUAGES C
+)
 
 # package release version
-# bump if re-releasing the same VERSION + patches
+#
-# set to 1 if releasing a new VERSION
+# * bump if re-releasing the same VERSION + patches
+# * set to 1 if releasing a new VERSION
 set(PACKAGE_RELEASE_VERSION 1)
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Include CMake modules
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 include(GNUInstallDirs)
 include(CheckIPOSupported)
 include(CMakePackageConfigHelpers)
@@ -32,19 +35,24 @@ option(BUILD_TESTING "" OFF)
 include(CTest)
 include(sources.cmake)
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Options
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 option(WITH_LTM "Build with support for libtommath" TRUE)
 option(WITH_TFM "Build with support for tomsfastmath" FALSE)
 option(WITH_GMP "Build with support for GNU Multi Precision Arithmetic Library" FALSE)
-set(MPI_PROVIDER "LTM" CACHE STRING "Build tests and demos against 'LTM', 'TFM' or 'GMP', default is LTM")
+set(MPI_PROVIDER
-option(BUILD_SHARED_LIBS "Build shared library and only the shared library if \"ON\", default is static" OFF)
+    "LTM"
+    CACHE STRING "Build tests and demos against 'LTM', 'TFM' or 'GMP', default is LTM"
+)
+option(BUILD_SHARED_LIBS
+       "Build shared library and only the shared library if \"ON\", default is static" OFF
+)
 option(WITH_PTHREAD "Build with pthread support" FALSE)
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Add support for ccache if desired
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 find_program(CCACHE ccache)
 
 if(CCACHE)
@@ -56,9 +64,9 @@ if(CCACHE AND ENABLE_CCACHE)
     set(CMAKE_C_COMPILER_LAUNCHER ${CCACHE})
 endif()
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Compose CFLAGS
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 # Some information ported from makefile_include.mk
 
@@ -73,9 +81,18 @@ if(MSVC)
 elseif(WATCOM)
     set(LTC_C_FLAGS -fo=.obj -oaxt -3r -w3)
 else()
-    set(LTC_C_FLAGS -Wall -Wsign-compare -Wextra -Wshadow
+    set(LTC_C_FLAGS
-                    -Wdeclaration-after-statement -Wbad-function-cast -Wcast-align
+        -Wall
-                    -Wstrict-prototypes -Wpointer-arith -Wsystem-headers)
+        -Wsign-compare
+        -Wextra
+        -Wshadow
+        -Wdeclaration-after-statement
+        -Wbad-function-cast
+        -Wcast-align
+        -Wstrict-prototypes
+        -Wpointer-arith
+        -Wsystem-headers
+    )
     set(CMAKE_C_FLAGS_DEBUG "-g3")
     set(CMAKE_C_FLAGS_RELEASE "-O3 -funroll-loops -fomit-frame-pointer")
     set(CMAKE_C_FLAGS_RELWITHDEBINFO "-g3 -O2")
@@ -84,12 +101,16 @@ endif()
 
 # What compiler do we have and what are their...uhm... peculiarities
 if(CMAKE_C_COMPILER_ID MATCHES "(C|c?)lang")
-    list(APPEND LTC_C_FLAGS -Wno-typedef-redefinition -Wno-tautological-compare -Wno-builtin-requires-header)
+    list(APPEND LTC_C_FLAGS -Wno-typedef-redefinition -Wno-tautological-compare
+         -Wno-builtin-requires-header
+    )
     # Clang requires at least '-O1' for dead code eliminiation
     set(CMAKE_C_FLAGS_DEBUG "-O1 ${CMAKE_C_FLAGS_DEBUG}")
 endif()
 if(CMAKE_C_COMPILER MATCHES "mingw")
-    list(APPEND LTC_C_FLAGS -Wno-shadow -Wno-expansion-to-defined -Wno-declaration-after-statement -Wno-bad-function-cast)
+    list(APPEND LTC_C_FLAGS -Wno-shadow -Wno-expansion-to-defined -Wno-declaration-after-statement
+         -Wno-bad-function-cast
+    )
 endif()
 if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
     list(APPEND LTC_C_FLAGS -Wno-nullability-completeness)
@@ -102,42 +123,37 @@ if(MSVC)
     cmake_push_check_state()
     check_symbol_exists(BCryptGenRandom bcrypt.h BCRYPT_AVAILABLE)
     cmake_pop_check_state()
-    if (BCRYPT_AVAILABLE)
+    if(BCRYPT_AVAILABLE)
         target_link_libraries(${PROJECT_NAME} PRIVATE Bcrypt)
         list(APPEND LTC_C_FLAGS -DLTC_WIN32_BCRYPT)
     endif()
 endif()
 
-# If the user set the environment variables at generate-time, append them
+# If the user set the environment variables at generate-time, append them in order to allow
-# in order to allow overriding our defaults.
+# overriding our defaults.
+# ~~~
 # ${LTC_CFLAGS} means the user passed it via sth like:
 # $ cmake -DLTC_CFLAGS="foo"
+# ~~~
 list(APPEND LTC_C_FLAGS ${LTC_CFLAGS})
 list(APPEND LTC_LD_FLAGS ${LTC_LDFLAGS})
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Library targets
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
-add_library(${PROJECT_NAME}
+add_library(${PROJECT_NAME} ${SOURCES} ${PUBLIC_HEADERS} ${PRIVATE_HEADERS})
-    ${SOURCES}
-    ${PUBLIC_HEADERS}
-    ${PRIVATE_HEADERS}
-)
 
-target_include_directories(${PROJECT_NAME} PUBLIC
+target_include_directories(
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/headers>
+    ${PROJECT_NAME} PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/headers>
                            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}>
 )
 
-target_compile_options(${PROJECT_NAME} BEFORE PRIVATE
+target_compile_options(${PROJECT_NAME} BEFORE PRIVATE ${LTC_C_FLAGS})
-    ${LTC_C_FLAGS}
+target_link_options(${PROJECT_NAME} BEFORE PRIVATE ${LTC_LD_FLAGS})
-)
-target_link_options(${PROJECT_NAME} BEFORE PRIVATE
-    ${LTC_LD_FLAGS}
-)
 
-set_target_properties(${PROJECT_NAME} PROPERTIES
+set_target_properties(
-    OUTPUT_NAME tomcrypt
+    ${PROJECT_NAME}
+    PROPERTIES OUTPUT_NAME tomcrypt
                VERSION ${PROJECT_VERSION}
                SOVERSION ${PROJECT_VERSION_MAJOR}
                PUBLIC_HEADER "${PUBLIC_HEADERS}"
@@ -149,13 +165,16 @@ if(COMPILE_LTO)
     if(COMPILER_SUPPORTS_LTO)
         set_property(TARGET ${PROJECT_NAME} PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
     else()
-        message(SEND_ERROR "This compiler does not support LTO. Reconfigure ${PROJECT_NAME} with -DCOMPILE_LTO=OFF.")
+        message(
+            SEND_ERROR
+                "This compiler does not support LTO. Reconfigure ${PROJECT_NAME} with -DCOMPILE_LTO=OFF."
+        )
     endif()
 endif()
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # MPI provider
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # libtommath
 if(WITH_LTM)
     find_package(libtommath 1.2.0 REQUIRED)
@@ -196,10 +215,9 @@ if(WITH_GMP)
     list(APPEND LTC_DEBIAN_MPI_PROVIDER_DEPENDS libgmp-dev)
 endif()
 
-
+# -----------------------------------------------------------------------------
-#-----------------------------------------------------------------------------
 # other options
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 if(WITH_PTHREAD)
     set(THREADS_PREFER_PTHREAD_FLAG ON)
@@ -209,7 +227,10 @@ if(WITH_PTHREAD)
         target_link_libraries(${PROJECT_NAME} PRIVATE Threads::Threads)
         list(APPEND LTC_PKG_CONFIG_CFLAGS -DLTC_PTHREAD)
     else()
-        message(SEND_ERROR "pthreads not supported. Reconfigure ${PROJECT_NAME} with -DWITH_PTHREAD=OFF.")
+        message(
+            SEND_ERROR
+                "pthreads not supported. Reconfigure ${PROJECT_NAME} with -DWITH_PTHREAD=OFF."
+        )
     endif()
 endif()
 
@@ -217,9 +238,9 @@ list(JOIN LTC_PKG_CONFIG_CFLAGS " " PKG_CONFIG_CFLAGS)
 list(JOIN LTC_PKG_CONFIG_LIBS " " PKG_CONFIG_LIBS)
 list(JOIN LTC_DEBIAN_MPI_PROVIDER_DEPENDS " " DEBIAN_MPI_PROVIDER_DEPENDS)
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # demos&test targets
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 add_subdirectory(demos)
 if(BUILD_TESTING)
@@ -227,16 +248,17 @@ if(BUILD_TESTING)
     add_subdirectory(tests)
 endif()
 
-#---------------------------------------------------------------------------------------
+# ---------------------------------------------------------------------------------------
 # Install/export targets and files
-#---------------------------------------------------------------------------------------
+# ---------------------------------------------------------------------------------------
 set(CONFIG_INSTALL_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
 set(PROJECT_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake")
 set(PROJECT_CONFIG_FILE "${PROJECT_NAME}-config.cmake")
 set(TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets")
 
 # install targets
-install(TARGETS ${PROJECT_NAME}
+install(
+    TARGETS ${PROJECT_NAME}
     EXPORT ${TARGETS_EXPORT_NAME}
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT Libraries
@@ -246,13 +268,16 @@ install(TARGETS ${PROJECT_NAME}
 
 # Install libtomcrypt.pc for pkg-config if we build a shared library
 if(BUILD_SHARED_LIBS)
-    # Let the user override the default directory of the pkg-config file (usually this shouldn't be required to be changed)
+    # Let the user override the default directory of the pkg-config file (usually this shouldn't be
-    set(CMAKE_INSTALL_PKGCONFIGDIR "${CMAKE_INSTALL_LIBDIR}/pkgconfig" CACHE PATH "Folder where to install .pc files")
+    # required to be changed)
+    set(CMAKE_INSTALL_PKGCONFIGDIR
+        "${CMAKE_INSTALL_LIBDIR}/pkgconfig"
+        CACHE PATH "Folder where to install .pc files"
+    )
 
     configure_file(
         ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}.pc.in
-        ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc
+        ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc @ONLY
-        @ONLY
     )
 
     install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc
@@ -268,17 +293,14 @@ write_basic_package_version_file(
 )
 
 # install version file
-install(FILES ${PROJECT_VERSION_FILE}
+install(FILES ${PROJECT_VERSION_FILE} DESTINATION ${CONFIG_INSTALL_DIR})
-        DESTINATION ${CONFIG_INSTALL_DIR}
-)
 
 # build directory package config
-export(EXPORT ${TARGETS_EXPORT_NAME}
+export(EXPORT ${TARGETS_EXPORT_NAME} FILE ${PROJECT_CONFIG_FILE})
-       FILE ${PROJECT_CONFIG_FILE}
-)
 
 # installed package config
-install(EXPORT ${TARGETS_EXPORT_NAME}
+install(
+    EXPORT ${TARGETS_EXPORT_NAME}
     DESTINATION ${CONFIG_INSTALL_DIR}
     FILE ${PROJECT_CONFIG_FILE}
 )
@@ -286,9 +308,9 @@ install(EXPORT ${TARGETS_EXPORT_NAME}
 # add to CMake registry
 export(PACKAGE ${PROJECT_NAME})
 
-#---------------------------------------------------------------------------------------
+# ---------------------------------------------------------------------------------------
 # Create release packages
-#---------------------------------------------------------------------------------------
+# ---------------------------------------------------------------------------------------
 
 # determine distribution and architecture
 find_program(LSB_RELEASE lsb_release)
@@ -296,17 +318,37 @@ find_program(SYSCTL sysctl)
 find_program(UNAME uname)
 
 if(UNAME)
-    execute_process(COMMAND uname -m OUTPUT_VARIABLE MACHINE_ARCH OUTPUT_STRIP_TRAILING_WHITESPACE)
+    execute_process(
+        COMMAND uname -m
+        OUTPUT_VARIABLE MACHINE_ARCH
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
 elseif(SYSCTL)
-    execute_process(COMMAND sysctl -b hw.machine_arch OUTPUT_VARIABLE MACHINE_ARCH OUTPUT_STRIP_TRAILING_WHITESPACE)
+    execute_process(
+        COMMAND sysctl -b hw.machine_arch
+        OUTPUT_VARIABLE MACHINE_ARCH
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
 else()
     string(TOLOWER ${CMAKE_SYSTEM_NAME} MACHINE_ARCH)
 endif()
 
 if(LSB_RELEASE)
-    execute_process(COMMAND lsb_release -si OUTPUT_VARIABLE LINUX_DISTRO OUTPUT_STRIP_TRAILING_WHITESPACE)
+    execute_process(
-    execute_process(COMMAND lsb_release -sc OUTPUT_VARIABLE LINUX_DISTRO_CODENAME OUTPUT_STRIP_TRAILING_WHITESPACE)
+        COMMAND lsb_release -si
-    execute_process(COMMAND lsb_release -sr OUTPUT_VARIABLE LINUX_DISTRO_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE)
+        OUTPUT_VARIABLE LINUX_DISTRO
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    execute_process(
+        COMMAND lsb_release -sc
+        OUTPUT_VARIABLE LINUX_DISTRO_CODENAME
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    execute_process(
+        COMMAND lsb_release -sr
+        OUTPUT_VARIABLE LINUX_DISTRO_VERSION
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
 
     string(TOLOWER ${LINUX_DISTRO} LINUX_DISTRO)
     if(LINUX_DISTRO_CODENAME STREQUAL "n/a")
@@ -319,7 +361,11 @@ else()
 endif()
 
 # make sure untagged versions get a different package name
-execute_process(COMMAND git describe --exact-match --tags ERROR_QUIET RESULT_VARIABLE REPO_HAS_TAG)
+execute_process(
+    COMMAND git describe --exact-match --tags
+    ERROR_QUIET
+    RESULT_VARIABLE REPO_HAS_TAG
+)
 if(REPO_HAS_TAG EQUAL 0)
     set(PACKAGE_NAME_SUFFIX "")
 else()
@@ -331,9 +377,16 @@ endif()
 set(CPACK_GENERATOR TGZ STGZ)
 
 # extra CPack generators
-if(LINUX_DISTRO STREQUAL "debian" OR LINUX_DISTRO STREQUAL "ubuntu" OR LINUX_DISTRO STREQUAL "linuxmint")
+if(LINUX_DISTRO STREQUAL "debian"
+   OR LINUX_DISTRO STREQUAL "ubuntu"
+   OR LINUX_DISTRO STREQUAL "linuxmint"
+)
     list(APPEND CPACK_GENERATOR DEB)
-elseif(LINUX_DISTRO STREQUAL "fedora" OR LINUX_DISTRO STREQUAL "opensuse" OR LINUX_DISTRO STREQUAL "centos")
+elseif(
+    LINUX_DISTRO STREQUAL "fedora"
+    OR LINUX_DISTRO STREQUAL "opensuse"
+    OR LINUX_DISTRO STREQUAL "centos"
+)
     list(APPEND CPACK_GENERATOR RPM)
 elseif(CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
     list(APPEND CPACK_GENERATOR FREEBSD)
@@ -376,7 +429,6 @@ else()
     set(CPACK_COMPONENTS_ALL Libraries)
 endif()
 
-
 # rpm specific CPack config
 set(CPACK_RPM_PACKAGE_RELEASE ${PACKAGE_RELEASE_VERSION})
 set(CPACK_RPM_PACKAGE_ARCHITECTURE ${MACHINE_ARCH})

cmake-format.py

@@ -0,0 +1,241 @@
+# ----------------------------------
+# Options affecting listfile parsing
+# ----------------------------------
+with section("parse"):
+
+  # Specify structure for custom cmake functions
+  additional_commands = { 'foo': { 'flags': ['BAR', 'BAZ'],
+             'kwargs': {'DEPENDS': '*', 'HEADERS': '*', 'SOURCES': '*'}}}
+
+  # Override configurations per-command where available
+  override_spec = {}
+
+  # Specify variable tags.
+  vartags = []
+
+  # Specify property tags.
+  proptags = []
+
+# -----------------------------
+# Options affecting formatting.
+# -----------------------------
+with section("format"):
+
+  # Disable formatting entirely, making cmake-format a no-op
+  disable = False
+
+  # How wide to allow formatted cmake files
+  line_width = 100
+
+  # How many spaces to tab for indent
+  tab_size = 4
+
+  # If true, lines are indented using tab characters (utf-8 0x09) instead of
+  # <tab_size> space characters (utf-8 0x20). In cases where the layout would
+  # require a fractional tab character, the behavior of the  fractional
+  # indentation is governed by <fractional_tab_policy>
+  use_tabchars = False
+
+  # If <use_tabchars> is True, then the value of this variable indicates how
+  # fractional indentions are handled during whitespace replacement. If set to
+  # 'use-space', fractional indentation is left as spaces (utf-8 0x20). If set
+  # to `round-up` fractional indentation is replaced with a single tab character
+  # (utf-8 0x09) effectively shifting the column to the next tabstop
+  fractional_tab_policy = 'use-space'
+
+  # If an argument group contains more than this many sub-groups (parg or kwarg
+  # groups) then force it to a vertical layout.
+  max_subgroups_hwrap = 2
+
+  # If a positional argument group contains more than this many arguments, then
+  # force it to a vertical layout.
+  max_pargs_hwrap = 6
+
+  # If a cmdline positional group consumes more than this many lines without
+  # nesting, then invalidate the layout (and nest)
+  max_rows_cmdline = 2
+
+  # If true, separate flow control names from their parentheses with a space
+  separate_ctrl_name_with_space = False
+
+  # If true, separate function names from parentheses with a space
+  separate_fn_name_with_space = False
+
+  # If a statement is wrapped to more than one line, than dangle the closing
+  # parenthesis on its own line.
+  dangle_parens = True
+
+  # If the trailing parenthesis must be 'dangled' on its on line, then align it
+  # to this reference: `prefix`: the start of the statement,  `prefix-indent`:
+  # the start of the statement, plus one indentation  level, `child`: align to
+  # the column of the arguments
+  dangle_align = 'prefix'
+
+  # If the statement spelling length (including space and parenthesis) is
+  # smaller than this amount, then force reject nested layouts.
+  min_prefix_chars = 4
+
+  # If the statement spelling length (including space and parenthesis) is larger
+  # than the tab width by more than this amount, then force reject un-nested
+  # layouts.
+  max_prefix_chars = 10
+
+  # If a candidate layout is wrapped horizontally but it exceeds this many
+  # lines, then reject the layout.
+  max_lines_hwrap = 2
+
+  # What style line endings to use in the output.
+  line_ending = 'unix'
+
+  # Format command names consistently as 'lower' or 'upper' case
+  command_case = 'lower'
+
+  # Format keywords consistently as 'lower' or 'upper' case
+  keyword_case = 'upper'
+
+  # A list of command names which should always be wrapped
+  always_wrap = []
+
+  # If true, the argument lists which are known to be sortable will be sorted
+  # lexicographicall
+  enable_sort = True
+
+  # If true, the parsers may infer whether or not an argument list is sortable
+  # (without annotation).
+  autosort = False
+
+  # By default, if cmake-format cannot successfully fit everything into the
+  # desired linewidth it will apply the last, most agressive attempt that it
+  # made. If this flag is True, however, cmake-format will print error, exit
+  # with non-zero status code, and write-out nothing
+  require_valid_layout = False
+
+  # A dictionary mapping layout nodes to a list of wrap decisions. See the
+  # documentation for more information.
+  layout_passes = {}
+
+# ------------------------------------------------
+# Options affecting comment reflow and formatting.
+# ------------------------------------------------
+with section("markup"):
+
+  # What character to use for bulleted lists
+  bullet_char = '*'
+
+  # What character to use as punctuation after numerals in an enumerated list
+  enum_char = '.'
+
+  # If comment markup is enabled, don't reflow the first comment block in each
+  # listfile. Use this to preserve formatting of your copyright/license
+  # statements.
+  first_comment_is_literal = False
+
+  # If comment markup is enabled, don't reflow any comment block which matches
+  # this (regex) pattern. Default is `None` (disabled).
+  literal_comment_pattern = None
+
+  # Regular expression to match preformat fences in comments default=
+  # ``r'^\s*([`~]{3}[`~]*)(.*)$'``
+  fence_pattern = '^\\s*([`~]{3}[`~]*)(.*)$'
+
+  # Regular expression to match rulers in comments default=
+  # ``r'^\s*[^\w\s]{3}.*[^\w\s]{3}$'``
+  ruler_pattern = '^\\s*[^\\w\\s]{3}.*[^\\w\\s]{3}$'
+
+  # If a comment line matches starts with this pattern then it is explicitly a
+  # trailing comment for the preceeding argument. Default is '#<'
+  explicit_trailing_pattern = '#<'
+
+  # If a comment line starts with at least this many consecutive hash
+  # characters, then don't lstrip() them off. This allows for lazy hash rulers
+  # where the first hash char is not separated by space
+  hashruler_min_length = 10
+
+  # If true, then insert a space between the first hash char and remaining hash
+  # chars in a hash ruler, and normalize its length to fill the column
+  canonicalize_hashrulers = True
+
+  # enable comment markup parsing and reflow
+  enable_markup = True
+
+# ----------------------------
+# Options affecting the linter
+# ----------------------------
+with section("lint"):
+
+  # a list of lint codes to disable
+  disabled_codes = []
+
+  # regular expression pattern describing valid function names
+  function_pattern = '[0-9a-z_]+'
+
+  # regular expression pattern describing valid macro names
+  macro_pattern = '[0-9A-Z_]+'
+
+  # regular expression pattern describing valid names for variables with global
+  # (cache) scope
+  global_var_pattern = '[A-Z][0-9A-Z_]+'
+
+  # regular expression pattern describing valid names for variables with global
+  # scope (but internal semantic)
+  internal_var_pattern = '_[A-Z][0-9A-Z_]+'
+
+  # regular expression pattern describing valid names for variables with local
+  # scope
+  local_var_pattern = '[a-z][a-z0-9_]+'
+
+  # regular expression pattern describing valid names for privatedirectory
+  # variables
+  private_var_pattern = '_[0-9a-z_]+'
+
+  # regular expression pattern describing valid names for public directory
+  # variables
+  public_var_pattern = '[A-Z][0-9A-Z_]+'
+
+  # regular expression pattern describing valid names for function/macro
+  # arguments and loop variables.
+  argument_var_pattern = '[a-z][a-z0-9_]+'
+
+  # regular expression pattern describing valid names for keywords used in
+  # functions or macros
+  keyword_pattern = '[A-Z][0-9A-Z_]+'
+
+  # In the heuristic for C0201, how many conditionals to match within a loop in
+  # before considering the loop a parser.
+  max_conditionals_custom_parser = 2
+
+  # Require at least this many newlines between statements
+  min_statement_spacing = 1
+
+  # Require no more than this many newlines between statements
+  max_statement_spacing = 2
+  max_returns = 6
+  max_branches = 12
+  max_arguments = 5
+  max_localvars = 15
+  max_statements = 50
+
+# -------------------------------
+# Options affecting file encoding
+# -------------------------------
+with section("encode"):
+
+  # If true, emit the unicode byte-order mark (BOM) at the start of the file
+  emit_byteorder_mark = False
+
+  # Specify the encoding of the input file. Defaults to utf-8
+  input_encoding = 'utf-8'
+
+  # Specify the encoding of the output file. Defaults to utf-8. Note that cmake
+  # only claims to support utf-8 so be careful when using anything else
+  output_encoding = 'utf-8'
+
+# -------------------------------------
+# Miscellaneous configurations options.
+# -------------------------------------
+with section("misc"):
+
+  # A dictionary containing any per-command configuration overrides. Currently
+  # only `command_case` is supported.
+  per_command = {}
+

demos/CMakeLists.txt

@@ -1,107 +1,80 @@
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Options
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 option(BUILD_USEFUL_DEMOS "Build useful demos (hashsum)" FALSE)
 option(BUILD_USABLE_DEMOS "Build usable demos (crypt sizes constants pem-info)" FALSE)
 option(BUILD_TEST_DEMOS "Build test demos (small tv_gen)" FALSE)
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Useful demos
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 if(BUILD_USEFUL_DEMOS)
 
     list(APPEND ALL_DEMOS_TARGETS hashsum)
 
     # hashsum
-    add_executable(hashsum
+    add_executable(hashsum ${CMAKE_CURRENT_SOURCE_DIR}/hashsum.c)
-        ${CMAKE_CURRENT_SOURCE_DIR}/hashsum.c
-    )
 
-    target_link_libraries(hashsum PRIVATE
+    target_link_libraries(hashsum PRIVATE ${PROJECT_NAME})
-        ${PROJECT_NAME}
-    )
 
 endif()
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Usable demos
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 if(BUILD_USABLE_DEMOS)
 
     list(APPEND ALL_DEMOS_TARGETS crypt sizes constants pem-info)
 
     # ltcrypt
-    add_executable(crypt
+    add_executable(crypt ${CMAKE_CURRENT_SOURCE_DIR}/crypt.c)
-        ${CMAKE_CURRENT_SOURCE_DIR}/crypt.c
-    )
 
-    target_link_libraries(crypt PRIVATE
+    target_link_libraries(crypt PRIVATE ${PROJECT_NAME})
-        ${PROJECT_NAME}
-    )
 
     # sizes
-    add_executable(sizes
+    add_executable(sizes ${CMAKE_CURRENT_SOURCE_DIR}/sizes.c)
-        ${CMAKE_CURRENT_SOURCE_DIR}/sizes.c
-    )
 
-    target_link_libraries(sizes PRIVATE
+    target_link_libraries(sizes PRIVATE ${PROJECT_NAME})
-        ${PROJECT_NAME}
-    )
 
     # constants
-    add_executable(constants
+    add_executable(constants ${CMAKE_CURRENT_SOURCE_DIR}/constants.c)
-        ${CMAKE_CURRENT_SOURCE_DIR}/constants.c
-    )
 
-    target_link_libraries(constants PRIVATE
+    target_link_libraries(constants PRIVATE ${PROJECT_NAME})
-        ${PROJECT_NAME}
-    )
 
     # pem-info
-    add_executable(pem-info
+    add_executable(pem-info ${CMAKE_CURRENT_SOURCE_DIR}/pem-info.c)
-        ${CMAKE_CURRENT_SOURCE_DIR}/pem-info.c
-    )
 
-    target_link_libraries(pem-info PRIVATE
+    target_link_libraries(pem-info PRIVATE ${PROJECT_NAME})
-        ${PROJECT_NAME}
-    )
 
 endif()
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Test demos
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 if(BUILD_TEST_DEMOS)
 
     list(APPEND ALL_DEMOS_TARGETS tv_gen)
 
     # small
-    add_executable(small
+    add_executable(small ${CMAKE_CURRENT_SOURCE_DIR}/small.c)
-        ${CMAKE_CURRENT_SOURCE_DIR}/small.c
-    )
 
-    target_link_libraries(small PRIVATE
+    target_link_libraries(small PRIVATE ${PROJECT_NAME})
-        ${PROJECT_NAME}
-    )
 
     # tv_gen
-    add_executable(tv_gen
+    add_executable(tv_gen ${CMAKE_CURRENT_SOURCE_DIR}/tv_gen.c)
-        ${CMAKE_CURRENT_SOURCE_DIR}/tv_gen.c
-    )
 
-    target_link_libraries(tv_gen PRIVATE
+    target_link_libraries(tv_gen PRIVATE ${PROJECT_NAME})
-        ${PROJECT_NAME}
-    )
 
 endif()
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Install targets
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
-install(TARGETS ${ALL_DEMOS_TARGETS}
+install(
+    TARGETS ${ALL_DEMOS_TARGETS}
     COMPONENT "runtime"
     EXPORT ${TARGETS_EXPORT_NAME}
     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}

tests/CMakeLists.txt

@@ -12,8 +12,7 @@ if(PROJECT_NAME)
     set(LIBRARY_NAME ${PROJECT_NAME})
 else()
     # Define an independent project and all the necessary stuff around
-    project(${LTC_TEST}
+    project(${LTC_TEST} LANGUAGES C)
-        LANGUAGES C)
     set(LIBRARY_NAME libtomcrypt)
     find_package(${LIBRARY_NAME})
     include(CTest)
@@ -22,49 +21,39 @@ else()
     endif()
 endif()
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # Compose CFLAGS etc.
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 
 if(NOT MSVC)
     set(CMAKE_C_FLAGS_DEBUG "-g3 -O1")
 endif()
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # demo target
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 include(sources.cmake)
-set(PRIVATE_HEADERS
+set(PRIVATE_HEADERS common.h tomcrypt_test.h)
-    common.h
-    tomcrypt_test.h
-)
 
-add_executable(${LTC_TEST}
+add_executable(${LTC_TEST} ${SOURCES} ${PRIVATE_HEADERS})
-    ${SOURCES}
-    ${PRIVATE_HEADERS}
-)
 
-target_include_directories(${LTC_TEST} PRIVATE
+target_include_directories(
-    ${CMAKE_CURRENT_SOURCE_DIR}
+    ${LTC_TEST} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
                         $<$<STREQUAL:${PROJECT_NAME},${LTC_TEST}>:${CMAKE_CURRENT_SOURCE_DIR}/..>
 )
 
-target_link_libraries(${LTC_TEST} PRIVATE
+target_link_libraries(${LTC_TEST} PRIVATE ${LIBRARY_NAME})
-    ${LIBRARY_NAME}
-)
 
-target_compile_options(${LTC_TEST} PRIVATE
+target_compile_options(
-    $<$<STREQUAL:$<TARGET_PROPERTY:${LIBRARY_NAME},TYPE>,SHARED_LIBRARY>:-DLTC_TEST_DYNAMIC>
+    ${LTC_TEST}
-    -DCMAKE_SOURCE_DIR=\"${CMAKE_SOURCE_DIR}\"
+    PRIVATE $<$<STREQUAL:$<TARGET_PROPERTY:${LIBRARY_NAME},TYPE>,SHARED_LIBRARY>:-DLTC_TEST_DYNAMIC>
-    ${LTC_C_FLAGS}
+            -DCMAKE_SOURCE_DIR=\"${CMAKE_SOURCE_DIR}\" ${LTC_C_FLAGS}
-)
-target_link_options(${LTC_TEST} BEFORE PUBLIC
-    ${LTC_LD_FLAGS}
 )
+target_link_options(${LTC_TEST} BEFORE PUBLIC ${LTC_LD_FLAGS})
 
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 # CTest
-#-----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
 add_test(NAME ${LTC_TEST} COMMAND ${LTC_TEST})
 
 find_program(MEMORYCHECK_COMMAND valgrind)