Memory

.github/workflows/cmake.yml

@@ -0,0 +1,151 @@
+name: CMake
+
+on: [push, pull_request]
+
+jobs:
+  ubuntu-address-undefined-coverage:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y lcov
+
+      - name: Configure CMake
+        run: cmake -B build -DCMAKE_BUILD_TYPE=Debug -DENABLE_ASAN=ON -DENABLE_UBSAN=ON -DENABLE_COV=ON
+
+      - name: Build
+        run: cmake --build build --config Debug
+
+      - name: Test with address sanitizer, undefined behavior sanitizer and coverage
+        working-directory: build
+        run: ctest -C Debug --rerun-failed --output-on-failure -T Test -T Coverage
+
+      - name: Make coverage report
+        run: |
+          lcov --capture --directory build --output-file coverage.info
+          lcov --remove coverage.info '/usr/*' --output-file coverage.info
+          lcov --list coverage.info
+
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v4.0.1
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+
+  ubuntu-memcheck:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y valgrind
+
+      - name: Configure CMake
+        run: cmake -B build -DCMAKE_BUILD_TYPE=Debug
+
+      - name: Build
+        run: cmake --build build --config Debug
+
+      - name: Test with memory checker
+        working-directory: build
+        run: ctest -C Debug --rerun-failed --output-on-failure -T Test -T MemCheck
+
+  windows-debug:
+    runs-on: windows-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Configure CMake
+        run: cmake -B build -DCMAKE_BUILD_TYPE=Debug
+
+      - name: Build
+        run: cmake --build build --config Debug
+
+      - name: Test
+        working-directory: build
+        run: ctest -C Debug --rerun-failed --output-on-failure -T Test
+
+  macos-address-undefined:
+    runs-on: macos-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Configure CMake
+        run: cmake -B build -DCMAKE_BUILD_TYPE=Debug -DENABLE_ASAN=ON -DENABLE_UBSAN=ON
+
+      - name: Build
+        run: cmake --build build --config Debug
+
+      - name: Test with address sanitizer and undefined behavior sanitizer
+        working-directory: build
+        run: ctest -C Debug --rerun-failed --output-on-failure -T Test
+
+  ubuntu-release:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Configure CMake
+        run: cmake -B build -DCMAKE_BUILD_TYPE=Release
+
+      - name: Build
+        run: cmake --build build --config Release
+
+      - name: Test
+        working-directory: build
+        run: ctest -C Release --rerun-failed --output-on-failure -T Test
+
+  windows-release:
+    runs-on: windows-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Configure CMake
+        run: cmake -B build -DCMAKE_BUILD_TYPE=Release
+
+      - name: Build
+        run: cmake --build build --config Release
+
+      - name: Test
+        working-directory: build
+        run: ctest -C Release --rerun-failed --output-on-failure -T Test
+
+  macos-release:
+    runs-on: macos-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Configure CMake
+        run: cmake -B build -DCMAKE_BUILD_TYPE=Release
+
+      - name: Build
+        run: cmake --build build --config Release
+
+      - name: Test
+        working-directory: build
+        run: ctest -C Release --rerun-failed --output-on-failure -T Test

CMakeLists.txt

@@ -1,83 +1,65 @@
-cmake_minimum_required(VERSION 3.0.0)
-project(utils VERSION 0.1.0)
+cmake_minimum_required(VERSION 3.21)
+project(utils VERSION 0.2.0 LANGUAGES CXX)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=undefined")
-
-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
-
-include(GenerateExportHeader)
-include(GNUInstallDirs)
-include(CMakePackageConfigHelpers)
+list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/Modules")
+include(Sanitizers)
 
 include(CTest)
 enable_testing()
 
-set(INTEGER_TYPES "int" "long" "long long")
-set(INTEGER_TYPE "long" CACHE STRING "Integer type")
-set_property(CACHE INTEGER_TYPE PROPERTY STRINGS ${INTEGER_TYPES})
-
-option(VERBOSE_LOG "Makes log more verbose" OFF)
-option(ADD_COVERAGE "Add coverage" OFF)
+set(INT_TYPES "int" "long" "long long")
+set(INT_TYPE "long" CACHE STRING "Integer type")
+set_property(CACHE INT_TYPE PROPERTY STRINGS ${INT_TYPES})
+list(FIND INT_TYPES ${INT_TYPE} INT_TYPE_INDEX)
+if(${INT_TYPE_INDEX} EQUAL -1)
+    message(FATAL_ERROR "Invalid integer type: ${INT_TYPE}")
+endif()
 
-file(GLOB UTILS_SOURCES src/*.cpp)
-file(GLOB UTILS_HEADERS include/*.h)
+set(LOGGING_LEVELS "TRACE" "DEBUG" "INFO" "WARN" "ERROR" "FATAL")
+set(LOGGING_LEVEL "INFO" CACHE STRING "Logging level")
+set_property(CACHE LOGGING_LEVEL PROPERTY STRINGS ${LOGGING_LEVELS})
+list(FIND LOGGING_LEVELS ${LOGGING_LEVEL} LOGGING_LEVEL_INDEX)
+if(${LOGGING_LEVEL_INDEX} EQUAL -1)
+    message(FATAL_ERROR "Invalid logging level: ${LOGGING_LEVEL}")
+endif()
 
-add_library(${PROJECT_NAME} SHARED ${UTILS_SOURCES})
-GENERATE_EXPORT_HEADER(${PROJECT_NAME})
-target_include_directories(${PROJECT_NAME} PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>/include $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>)
+option(BUILD_CRYPTO "Build crypto" OFF)
 
-message(STATUS "Integer type:           ${INTEGER_TYPE}")
-if(INTEGER_TYPE STREQUAL "int")
-    target_compile_definitions(${PROJECT_NAME} PUBLIC INTEGER_TYPE_INT)
-elseif(INTEGER_TYPE STREQUAL "long")
-    target_compile_definitions(${PROJECT_NAME} PUBLIC INTEGER_TYPE_LONG)
-elseif(INTEGER_TYPE STREQUAL "long long")
-    target_compile_definitions(${PROJECT_NAME} PUBLIC INTEGER_TYPE_LONG_LONG)
-else()
-    message(FATAL_ERROR "INTEGER_TYPE must be one of ${INTEGER_TYPES}")
+if(LOGGING_LEVEL STREQUAL "TRACE")
+    set(LOG_LEVEL 6)
+elseif(LOGGING_LEVEL STREQUAL "DEBUG")
+    set(LOG_LEVEL 5)
+elseif(LOGGING_LEVEL STREQUAL "INFO")
+    set(LOG_LEVEL 4)
+elseif(LOGGING_LEVEL STREQUAL "WARN")
+    set(LOG_LEVEL 3)
+elseif(LOGGING_LEVEL STREQUAL "ERROR")
+    set(LOG_LEVEL 2)
+elseif(LOGGING_LEVEL STREQUAL "FATAL")
+    set(LOG_LEVEL 1)
 endif()
 
-if(BUILD_TESTING)
-    add_subdirectory(tests)
-endif()
+message(STATUS "Integer type: ${INT_TYPE}")
+message(STATUS "Logging level: ${LOGGING_LEVEL}")
 
-message(STATUS "Verbose log:            ${VERBOSE_LOG}")
-if(VERBOSE_LOG)
-    target_compile_definitions(${PROJECT_NAME} PUBLIC VERBOSE_LOG)
-endif()
+add_library(utils src/integer.cpp src/rational.cpp src/inf_rational.cpp src/lin.cpp src/tableau.cpp src/timer.cpp)
+target_compile_features(utils PUBLIC cxx_std_17)
+target_include_directories(utils PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
+target_compile_definitions(utils PUBLIC INT_TYPE=${INT_TYPE} LOGGING_LEVEL=${LOG_LEVEL})
+setup_sanitizers(utils)
+
+message(STATUS "Build crypto: ${BUILD_CRYPTO}")
+if(BUILD_CRYPTO)
+    find_package(OpenSSL REQUIRED)
 
-if(MSVC)
-    target_compile_options(${PROJECT_NAME} PRIVATE /W4)
-else()
-    target_compile_options(${PROJECT_NAME} PRIVATE -Wall -Wextra -Wpedantic)
-    if (ADD_COVERAGE)
-        if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-            target_compile_options(${PROJECT_NAME} PRIVATE --coverage)
-            target_link_libraries(${PROJECT_NAME} PUBLIC gcov)
-        endif()
-    endif()
+    target_sources(utils PRIVATE src/crypto.cpp)
+    target_link_libraries(utils PUBLIC OpenSSL::Crypto)
 endif()
 
-install(
-    TARGETS ${PROJECT_NAME}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-)
-install(
-    FILES ${UTILS_HEADERS} ${CMAKE_CURRENT_BINARY_DIR}/utils_export.h
-    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}
-)
-configure_package_config_file(src/${PROJECT_NAME}Config.cmake.in ${PROJECT_NAME}Config.cmake INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME} PATH_VARS CMAKE_INSTALL_INCLUDEDIR)
-write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake VERSION 1.0.0 COMPATIBILITY SameMajorVersion)
-install(
-    FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
-    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
-)
+if(BUILD_TESTING)
+    add_subdirectory(tests)
+endif()
 
-set(CPACK_PROJECT_NAME ${PROJECT_NAME})
+set(CPACK_PROJECT_NAME utils)
 set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
 include(CPack)

README.md

@@ -1,10 +1,15 @@
 # Utils
 
+![Build Status](https://github.com/ratioSolver/Utils/actions/workflows/cmake.yml/badge.svg)
+[![codecov](https://codecov.io/gh/ratioSolver/Utils/branch/master/graph/badge.svg)](https://codecov.io/gh/ratioSolver/Utils)
+
 This repository contains the source code for a library of utility functions for the C++ programming language.
 Currently implemented utilities are:
  - Logging macros, including logging capabilities for some containers
  - Cartesian product of containers
  - Combinations of given size from a container
+ - Propositional literals
  - Rationals
  - Infinitesimal rationals
- - Memory management utilities (e.g. `c_ptr`, `u_ptr`, etc.)
+ - Base64 encoding and decoding
+ - SHA1 hashing

cmake/Modules/Sanitizers.cmake

@@ -0,0 +1,89 @@
+# Sanitizers.cmake
+# A CMake module to simplify sanitizer setup.
+
+function(setup_sanitizers target)
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        target_compile_options(${target} PRIVATE -Wall -Wextra -Wpedantic)
+
+        if (ENABLE_MSAN)
+            message(FATAL_ERROR "Memory sanitizer is not supported with GCC")
+        endif()
+
+        set(SANITIZERS "")
+
+        if (ENABLE_ASAN)
+            list(APPEND SANITIZERS "address")
+        endif()
+
+        if (ENABLE_UBSAN)
+            list(APPEND SANITIZERS "undefined")
+        endif()
+
+        list(JOIN SANITIZERS "," LIST_OF_SANITIZERS)
+
+        if ("${LIST_OF_SANITIZERS}" STREQUAL "")
+            message(STATUS "No sanitizers for ${target}")
+        else()
+            message(STATUS "Sanitizers enabled for ${target}: ${LIST_OF_SANITIZERS}")
+            target_compile_options(${target} PRIVATE -fsanitize=${LIST_OF_SANITIZERS})
+            target_link_options(${target} PRIVATE -fsanitize=${LIST_OF_SANITIZERS})
+        endif()
+
+        if (ENABLE_COV)
+            message(STATUS "Code coverage enabled for ${target}")
+            target_compile_options(${target} PRIVATE --coverage)
+            target_link_libraries(${target} PRIVATE --coverage)
+        endif()
+    elseif(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
+        target_compile_options(${target} PRIVATE -Wall -Wextra -Wpedantic)
+
+        set(SANITIZERS "")
+
+        if (ENABLE_ASAN)
+            list(APPEND SANITIZERS "address")
+        endif()
+
+        if (ENABLE_MSAN)
+            list(APPEND SANITIZERS "memory")
+        endif()
+
+        if (ENABLE_UBSAN)
+            list(APPEND SANITIZERS "undefined")
+        endif()
+
+        list(JOIN SANITIZERS "," LIST_OF_SANITIZERS)
+
+        if ("${LIST_OF_SANITIZERS}" STREQUAL "")
+            message(STATUS "No sanitizers for ${target}")
+        else()
+            message(STATUS "Sanitizers enabled for ${target}: ${LIST_OF_SANITIZERS}")
+            target_compile_options(${target} PRIVATE -fsanitize=${LIST_OF_SANITIZERS})
+            target_link_options(${target} PRIVATE -fsanitize=${LIST_OF_SANITIZERS})
+        endif()
+    elseif(MSVC)
+        target_compile_options(${target} PRIVATE /W4 /Zi /INCREMENTAL:NO)
+
+        if (ENABLE_MSAN)
+            message(FATAL_ERROR "Memory sanitizer is not supported with MSVC")
+        endif()
+
+        if (ENABLE_UBSAN)
+            message(FATAL_ERROR "Undefined behavior sanitizer is not supported with MSVC")
+        endif()
+
+        if (NOT ENABLE_ASAN)
+            message(STATUS "No sanitizers for ${target}")
+        else()
+            message(STATUS "Address sanitizer enabled for ${target}")
+            string(FIND "$ENV{PATH}" "$ENV{VSINSTALLDIR}" index_of_vs_install_dir)
+            if("${index_of_vs_install_dir}" STREQUAL "-1")
+                message(FATAL_ERROR "Visual Studio environment not found")
+            endif()
+            target_compile_options(${target} PRIVATE /fsanitize=address)
+            target_compile_definitions(${target} PRIVATE _DISABLE_VECTOR_ANNOTATION _DISABLE_STRING_ANNOTATION)
+            target_link_options(${target} PRIVATE /INCREMENTAL:NO)
+        endif()
+    else()
+        message(FATAL_ERROR "Unsupported compiler")
+    endif()
+endfunction()