From 7bc6de2083e9f817901cd394d66a7c716a76a21e Mon Sep 17 00:00:00 2001 From: Aregtech Date: Sun, 1 Dec 2024 01:16:58 +0100 Subject: [PATCH] Optimized scripts, enabled arm build with clang compiler. --- conf/cmake/common.cmake | 27 ++--- conf/cmake/functions.cmake | 147 ++++++++++++++++++---------- conf/cmake/user.cmake | 29 +++++- framework/areglogger/CMakeLists.txt | 2 +- thirdparty/sqlite3/CMakeLists.txt | 53 +++++----- 5 files changed, 161 insertions(+), 97 deletions(-) diff --git a/conf/cmake/common.cmake b/conf/cmake/common.cmake index db67a035..8926cfbe 100644 --- a/conf/cmake/common.cmake +++ b/conf/cmake/common.cmake @@ -17,12 +17,13 @@ endif() # Identify compiler short name if ("${AREG_COMPILER_FAMILY}" STREQUAL "") - macro_setup_compilers_data("${CMAKE_CXX_COMPILER}" AREG_COMPILER_FAMILY AREG_COMPILER_SHORT AREG_CXX_COMPILER AREG_C_COMPILER AREG_PROCESSOR AREG_BITNESS _compiler_found) + macro_setup_compilers_data("${CMAKE_CXX_COMPILER}" AREG_COMPILER_FAMILY AREG_COMPILER_SHORT AREG_CXX_COMPILER AREG_C_COMPILER AREG_TARGET AREG_PROCESSOR AREG_BITNESS _compiler_found) if (_compiler_found) message(STATUS "AREG: >>> Use system default settings:") - message(STATUS "AREG: ... Compiler family = \'${AREG_COMPILER_FAMILY}\'") - message(STATUS "AREG: ... CXX compiler = \'${AREG_CXX_COMPILER}\'") - message(STATUS "AREG: ... CC compiler = \'${AREG_C_COMPILER}\'") + message(STATUS "AREG: ... Compiler family = '${AREG_COMPILER_FAMILY}'") + message(STATUS "AREG: ... CXX compiler = '${AREG_CXX_COMPILER}'") + message(STATUS "AREG: ... CC compiler = '${AREG_C_COMPILER}'") + message(STATUS "AREG: ... Compiler Target = '${AREG_TARGET}'") else() message(WARNING "AREG: >>> The compiler \'${${CMAKE_CXX_COMPILER}}\' is unknown, the compilation result is unpredictable") endif() @@ -41,15 +42,19 @@ if ("${AREG_BITNESS}" STREQUAL "" OR AREG_BITNESS EQUAL 0) endif() # Setup for find_xxx() calls +if ("${AREG_TARGET}" STREQUAL "") + macro_default_target(${AREG_PROCESSOR} ${AREG_BITNESS} AREG_TARGET) +endif() + set(CMAKE_FIND_PACKAGE_RESOLVE_SYMLINKS TRUE) -if (NOT MSVC AND "${CMAKE_CXX_COMPILER_TARGET}" STREQUAL "") - macro_find_compiler_target(${AREG_PROCESSOR} ${AREG_BITNESS} _compiler_target) - if (_compiler_target) - set(CMAKE_CXX_COMPILER_TARGET ${_compiler_target}) - set(CMAKE_C_COMPILER_TARGET ${_compiler_target}) - set(CMAKE_LIBRARY_ARCHITECTURE ${_compiler_target}) +if ("${CMAKE_CXX_COMPILER_TARGET}" STREQUAL "") + set(CMAKE_CXX_COMPILER_TARGET ${AREG_TARGET}) + set(CMAKE_C_COMPILER_TARGET ${AREG_TARGET}) + if (NOT MSVC) + set(CMAKE_LIBRARY_ARCHITECTURE ${AREG_TARGET}) endif() - unset(_compiler_target) +else() + set(AREG_TARGET ${CMAKE_CXX_COMPILER_TARGET}) endif() # ----------------------------------------------------- diff --git a/conf/cmake/functions.cmake b/conf/cmake/functions.cmake index 8c5f5b33..9d65195c 100644 --- a/conf/cmake/functions.cmake +++ b/conf/cmake/functions.cmake @@ -294,33 +294,6 @@ macro(macro_check_module_architect path_module target_arch var_compatible) endif() endmacro(macro_check_module_architect) -# --------------------------------------------------------------------------- -# Macro ......: macro_find_compiler_target -# Purpose ....: Based on the processor architecture and the target bitness, sets the -# compiler target, which can be used to set 'CMAKE_CXX_COMPILER_TARGET' -# and 'CMAKE_C_COMPILER_TARGET' variables. -# Parameters .: ${target_arch} [in] -- Target processor architecture. -# ${target_bitness} [in] -- Target bitness. -# ${var_name_target}[in] -- Name of variable to set the compiler target. -# Usage ......: macro_find_compiler_target( ) -# Example ....: macro_find_compiler_target(ARM 32 CMAKE_CXX_COMPILER_TARGET) -# --------------------------------------------------------------------------- -macro(macro_find_compiler_target target_arch target_bitness var_name_target) - if ("${target_arch}" STREQUAL "${_proc_arm64}") - set(${var_name_target} aarch64-linux-gnu) - elseif("${target_arch}" STREQUAL "${_proc_arm32}") - set(${var_name_target} arm-linux-gnueabihf) - elseif("${target_arch}" STREQUAL "${_proc_x86}") - set(${var_name_target} i386-linux-gnu) - elseif("${target_arch}" STREQUAL "${_proc_x64}") - set(${var_name_target} x86_64-linux-gnu) - elseif(${target_bitness} EQUAL 64) - set(${var_name_target} x64) - elseif(${target_bitness} EQUAL 32) - set(${var_name_target} x86) - endif() -endmacro(macro_find_compiler_target) - # --------------------------------------------------------------------------- # Macro ......: macro_create_option # Purpose ....: Creates a boolean cache variable with a default value. @@ -458,28 +431,67 @@ macro(macro_system_bitness var_bitness) endif() endmacro(macro_system_bitness) +macro(macro_default_target target_processor target_bitness var_name_target) + if (UNIX) + if (${target_processor} MATCHES "${_proc_x64}") + set(${var_name_target} x86_64-linux-gnu) + elseif (${target_processor} MATCHES "${_proc_x86}") + set(${var_name_target} i386-linux-gnu) + elseif (${target_processor} MATCHES "${_proc_arm64}") + set(${var_name_target} aarch64-linux-gnu) + elseif (${target_processor} MATCHES "${_proc_arm32}") + set(${var_name_target} arm-linux-gnueabihf) + endif() + elseif (MSVC) + if (${target_processor} MATCHES "${_proc_x64}") + set(${var_name_target} x64) + elseif (${target_processor} MATCHES "${_proc_x86}") + set(${var_name_target} "win32") + endif() + elseif(CYGWIN) + if (${target_processor} MATCHES "${_proc_x64}") + set(${var_name_target} x86_64-pc-cygwin) + elseif (${target_processor} MATCHES "${_proc_x86}") + set(${var_name_target} i386-pc-cygwin) + endif() + endif() +endmacro(macro_default_target) + # --------------------------------------------------------------------------- # Macro ......: macro_setup_compilers_data # Purpose ....: Identifies and configures compiler family, short names, and paths. # Note .......: Beside "gnu", "llvm", "msvc", the GNU compilers for CYGWIN are included as a "cygwin" family. -# Parameters .: - ${compiler_path} -- Input: Path to the C++ compiler. -# - ${var_name_family} -- Output: Name of variable to hold compiler family (e.g., "gnu", "msvc", "llvm", "cygwin"). -# - ${var_name_short} -- Output: Name of variable to hold short name of the compiler (e.g., "gcc", "clang", "cl"). -# - ${var_name_cxx} -- Output: Name of variable to hold the C++ compiler path (usually same as ${compiler_path}). -# - ${var_name_c} -- Output: Name of variable to hold the corresponding C compiler name or path. -# - ${var_name_found} -- Output: Name of variable to hold Boolean indicating successful identification. -# Usage ......: macro_setup_compilers_data( ) +# Parameters .: - ${compiler_path} [in] -- Path to the C++ compiler. +# - ${var_name_family} [out] -- Name of variable to hold compiler family (e.g., "gnu", "msvc", "llvm", "cygwin"). +# - ${var_name_short} [out] -- Name of variable to hold short name of the compiler (e.g., "gcc", "clang", "cl"). +# - ${var_name_cxx} [out] -- Name of variable to hold the C++ compiler path (usually same as ${compiler_path}). +# - ${var_name_c} [out] -- Name of variable to hold the corresponding C compiler name or path. +# - ${var_name_target} [out] -- Nave of variable to hold compiler target value. +# - ${var_name_arch} [in, out] -- Name of variable that contains the processor architecture value. +# - ${var_name_bitness}[out] -- Name of variable to hold the application bitness value. +# - ${var_name_found} [out] -- Name of variable to hold Boolean indicating successful identification. +# Usage ......: macro_setup_compilers_data( ) # Example ....: macro_setup_compilers_data("${CMAKE_CXX_COMPILER}" # AREG_COMPILER_FAMILY # AREG_COMPILER_SHORT # AREG_CXX_COMPILER # AREG_C_COMPILER +# AREG_TARGET_NAME # AREG_PROCESSOR # AREG_BITNESS # _compiler_supports # ) # --------------------------------------------------------------------------- -macro(macro_setup_compilers_data compiler_path var_name_family var_name_short var_name_cxx var_name_c var_name_arch var_name_bitness var_name_found) +macro(macro_setup_compilers_data + compiler_path + var_name_family + var_name_short + var_name_cxx + var_name_c + var_name_target + var_name_arch + var_name_bitness + var_name_found) set(${var_name_found} FALSE) if(NOT "${${var_name_arch}}" STREQUAL "") @@ -491,21 +503,38 @@ macro(macro_setup_compilers_data compiler_path var_name_family var_name_short va # Iterate over known compilers to identify the compiler type foreach(_entry "clang-cl;llvm;clang-cl" "clang++;llvm;clang" "clang;llvm;clang" "g++;gnu;gcc" "gcc;gnu;gcc" "c++;gnu;cc" "cc;gnu;cc" "cl;msvc;cl") list(GET _entry 0 _cxx_comp) - list(GET _entry 1 _family) - list(GET _entry 2 _cc_comp) # Check if the provided compiler matches the known C++ compiler string(TOLOWER "${compiler_path}" _comp_path) string(FIND "${_comp_path}" "${_cxx_comp}" _found_pos REVERSE) if (_found_pos GREATER -1) + list(GET _entry 1 _family) + list(GET _entry 2 _cc_comp) # Handle special case for CYGWIN and GNU family compilers - if (CYGWIN AND ("${_family}" STREQUAL "gnu")) - set(${var_name_family} "cygwin") - elseif("${_family}" STREQUAL "gnu") - macro_guess_processor_architecture("${_comp_path}" ${var_name_arch} ${var_name_bitness}) - set(${var_name_family} "${_family}") + if (${_family} STREQUAL gnu) + if (CYGWIN) + set(${var_name_family} "cygwin") + macro_default_target(${var_name_arch} ${var_name_bitness} ${var_name_target}) + else() + set(${var_name_family} "gnu") + macro_guess_processor_architecture("${_comp_path}" ${var_name_arch} ${var_name_bitness}) + string(FIND "${_comp_path}" "-${_cxx_comp}" _found_pos REVERSE) + if (_found_pos GREATER -1) + cmake_path(GET _comp_path FILENAME _file_name) + string(REPLACE "-${_cxx_comp}" "" ${var_name_target} "${_file_name}") + else() + macro_default_target(${var_name_arch} ${var_name_bitness} ${var_name_target}) + endif() + endif() + elseif (${_family} STREQUAL llvm) + set(${var_name_family} "llvm") + macro_default_target(${var_name_arch} ${var_name_bitness} ${var_name_target}) + elseif (${_family} STREQUAL msvc) + set(${var_name_family} "msvc") + macro_default_target(${var_name_arch} ${var_name_bitness} ${var_name_target}) else() set(${var_name_family} "${_family}") + macro_default_target(${var_name_arch} ${var_name_bitness} ${var_name_target}) endif() set(${var_name_short} "${_cxx_comp}") @@ -551,7 +580,7 @@ endmacro(macro_setup_compilers_data) # _compiler_supports # ) # --------------------------------------------------------------------------- -macro(macro_setup_compilers_data_by_family compiler_family var_name_short var_name_cxx var_name_c var_name_found) +macro(macro_setup_compilers_data_by_family compiler_family var_name_short var_name_cxx var_name_c var_name_target var_name_found) set(${var_name_found} FALSE) @@ -563,22 +592,32 @@ macro(macro_setup_compilers_data_by_family compiler_family var_name_short var_na if ("${_family}" STREQUAL "${compiler_family}") # Special case for Windows - if (WIN32 AND "${_family}" STREQUAL "llvm") - set(${var_name_short} "clang-cl") - set(${var_name_cxx} "clang-cl") - set(${var_name_c} "clang-cl") + if ("${_family}" STREQUAL "llvm") + if (MSVC) + set(${var_name_short} "clang-cl") + set(${var_name_cxx} "clang-cl") + set(${var_name_c} "clang-cl") + else() + set(${var_name_short} "${_cxx_comp}") + set(${var_name_cxx} "${_cxx_comp}") + set(${var_name_c} "${_cc_comp}") + endif() + macro_default_target(${AREG_PROCESSOR} ${AREG_BITNESS} ${var_name_target}) elseif ("${AREG_PROCESSOR}" STREQUAL "${_proc_arm32}" AND "${_family}" STREQUAL "gnu") - set(${var_name_short} "g++") - set(${var_name_cxx} "arm-linux-gnueabihf-g++") - set(${var_name_c} "arm-linux-gnueabihf-gcc") + set(${var_name_short} g++) + set(${var_name_cxx} arm-linux-gnueabihf-g++) + set(${var_name_c} arm-linux-gnueabihf-gcc) + set(${var_name_target} arm-linux-gnueabihf) elseif ("${AREG_PROCESSOR}" STREQUAL "${_proc_arm64}" AND "${_family}" STREQUAL "gnu") - set(${var_name_short} "g++") - set(${var_name_cxx} "aarch64-linux-gnu-g++") - set(${var_name_c} "aarch64-linux-gnu-gcc") + set(${var_name_short} g++) + set(${var_name_cxx} aarch64-linux-gnu-g++) + set(${var_name_c} aarch64-linux-gnu-gcc) + set(${var_name_target} aarch64-linux-gnu) else() set(${var_name_short} "${_cxx_comp}") set(${var_name_cxx} "${_cxx_comp}") set(${var_name_c} "${_cc_comp}") + macro_default_target(${AREG_PROCESSOR} ${AREG_BITNESS} ${var_name_target}) endif() # Mark compiler as found @@ -1146,7 +1185,7 @@ function(printAregConfigStatus var_make_print var_prefix var_header var_footer) message(STATUS "${var_prefix}: >>> Build Environment ..: System '${CMAKE_SYSTEM_NAME}', ${AREG_BITNESS}-bit '${AREG_PROCESSOR}' platform, Env '${AREG_DEVELOP_ENV}'") message(STATUS "${var_prefix}: >>> Used CXX-Compiler ..: '${CMAKE_CXX_COMPILER}'") message(STATUS "${var_prefix}: >>> Used C-Compiler ....: '${CMAKE_C_COMPILER}'") - message(STATUS "${var_prefix}: >>> Compiler Version ...: C++ standard 'c++${CMAKE_CXX_STANDARD}', compiler family '${AREG_COMPILER_FAMILY}'") + message(STATUS "${var_prefix}: >>> Compiler Version ...: C++ standard 'c++${CMAKE_CXX_STANDARD}', compiler family '${AREG_COMPILER_FAMILY}', target '${CMAKE_CXX_COMPILER_TARGET}'") message(STATUS "${var_prefix}: >>> AREG SDK Root ......: '${AREG_SDK_ROOT}'") message(STATUS "${var_prefix}: >>> CMake Build Dir ....: '${CMAKE_BINARY_DIR}'") message(STATUS "${var_prefix}: >>> Binary Output Dir ..: '${CMAKE_RUNTIME_OUTPUT_DIRECTORY}'") diff --git a/conf/cmake/user.cmake b/conf/cmake/user.cmake index 1238f6be..25e12f46 100644 --- a/conf/cmake/user.cmake +++ b/conf/cmake/user.cmake @@ -10,6 +10,7 @@ # Available Options: # 1. AREG_COMPILER_FAMILY -- A quick way to set the C++ and C compilers (CMAKE_CXX_COMPILER and CMAKE_C_COMPILER). # 2. AREG_COMPILER -- Sets a specific compiler for both C++ and C projects. +# 3. AREG_TARGET -- Sets a specific compiler and the library architecture target. Default is compiler and system defined. # 3. AREG_PROCESSOR -- The processor architect. Ignore if need to use system default. # 4. AREG_BINARY -- Specifies the library type for the AREG Framework ('shared' or 'static'). Defaults to 'shared'. # 5. AREG_LOGGER_BINARY -- Specifies the type of the Log Observer API library ('shared' or 'static'). Defaults to 'shared'. @@ -33,7 +34,8 @@ # Default Values: # 1. AREG_COMPILER_FAMILY = (possible values: gnu, cygwin, llvm, msvc) # 2. AREG_COMPILER = (possible values: g++, gcc, c++, cc, clang++, clang, clang-cl, cl) -# 3. AREG_PROCESSOR = System (possible values: x86, x64 (x86_64, amd64), arm (arm32), aarch64 (arm64)) +# 3. AREG_TARGET = (possible values: 'i386-linux-gnu', 'x86_64-linux-gnu', 'arm-linux-gnueabihf', 'aarch64-linux-gnu') +# 3. AREG_PROCESSOR = System (possible values: x86 (i386, i486), x64 (x86_64, x86-64, amd64, ia64), arm (arm32, armv7), aarch64 (arm64)) # 4. AREG_BINARY = shared (possible values: shared, static) # 5. AREG_LOGGER_BINARY = shared (possible values: shared, static) # 6. AREG_BUILD_TYPE = Release (possible values: Release, Debug) @@ -106,7 +108,7 @@ if ((DEFINED CMAKE_CXX_COMPILER OR DEFINED CMAKE_C_COMPILER) AND (NOT "${CMAKE_C endif() # Setup compiler details based on the identified system compiler - macro_setup_compilers_data("${_sys_compiler}" _compiler_family _compiler_short _cxx_compiler _c_compiler _sys_process _sys_bitness _compiler_found) + macro_setup_compilers_data("${_sys_compiler}" _compiler_family _compiler_short _cxx_compiler _c_compiler _sys_target _sys_process _sys_bitness _compiler_found) if (_compiler_found) # Check for existing compiler family or specific compiler and issue warnings if necessary @@ -128,6 +130,9 @@ if ((DEFINED CMAKE_CXX_COMPILER OR DEFINED CMAKE_C_COMPILER) AND (NOT "${CMAKE_C set(AREG_COMPILER_SHORT "${_compiler_short}") set(AREG_CXX_COMPILER "${_sys_compiler}") set(AREG_C_COMPILER "${_c_compiler}") + if("${AREG_TARGET}" STREQUAL "") + set(AREG_TARGET "${_sys_target}") + endif() if (NOT "${_sys_process}" STREQUAL "") set(AREG_PROCESSOR ${_sys_process}) set(AREG_BITNESS ${_sys_bitness}) @@ -140,12 +145,14 @@ if ((DEFINED CMAKE_CXX_COMPILER OR DEFINED CMAKE_C_COMPILER) AND (NOT "${CMAKE_C unset(_sys_compiler) unset(_sys_process) unset(_sys_bitness) + unset(_sys_target) + unset(_compiler_found) # If a specific compiler family is set, use that to determine compilers elseif (DEFINED AREG_COMPILER_FAMILY AND NOT "${AREG_COMPILER_FAMILY}" STREQUAL "") message(STATUS "AREG: >>> Using user-specified C/C++ compiler family '${AREG_COMPILER_FAMILY}'") - macro_setup_compilers_data_by_family("${AREG_COMPILER_FAMILY}" _compiler_short _cxx_compiler _c_compiler _compiler_found) + macro_setup_compilers_data_by_family("${AREG_COMPILER_FAMILY}" _compiler_short _cxx_compiler _c_compiler _compiler_target _compiler_found) if (_compiler_found) # Set the relevant variables for the chosen compiler family @@ -153,16 +160,25 @@ elseif (DEFINED AREG_COMPILER_FAMILY AND NOT "${AREG_COMPILER_FAMILY}" STREQUAL set(AREG_COMPILER_SHORT "${_compiler_short}") set(AREG_CXX_COMPILER "${_cxx_compiler}") set(AREG_C_COMPILER "${_c_compiler}") + if("${AREG_TARGET}" STREQUAL "") + set(AREG_TARGET "${_compiler_target}") + endif() else() message(WARNING "AREG: >>> Unknown compiler family '${AREG_COMPILER_FAMILY}'; results may be unpredictable") endif() + unset(_compiler_short) + unset(_cxx_compiler) + unset(_c_compiler) + unset(_compiler_target) + unset(_compiler_found) + # If a specific compiler is set, use that to determine compilers elseif (DEFINED AREG_COMPILER AND NOT "${AREG_COMPILER}" STREQUAL "") message(STATUS "AREG: >>> Using user-specified C/C++ compiler '${AREG_COMPILER}'") # Set both C and C++ compilers based on AREG_COMPILER - macro_setup_compilers_data("${AREG_COMPILER}" _compiler_family _compiler_short _cxx_compiler _c_compiler _sys_process _sys_bitness _compiler_found) + macro_setup_compilers_data("${AREG_COMPILER}" _compiler_family _compiler_short _cxx_compiler _c_compiler _sys_target _sys_process _sys_bitness _compiler_found) if (_compiler_found) # Set the relevant variables for the chosen compiler @@ -170,6 +186,9 @@ elseif (DEFINED AREG_COMPILER AND NOT "${AREG_COMPILER}" STREQUAL "") set(AREG_COMPILER_SHORT "${_compiler_short}") set(AREG_CXX_COMPILER "${_cxx_compiler}") set(AREG_C_COMPILER "${_c_compiler}") + if("${AREG_TARGET}" STREQUAL "") + set(AREG_TARGET "${_sys_target}") + endif() if (NOT "${_sys_process}" STREQUAL "") set(AREG_PROCESSOR ${_sys_process}) set(AREG_BITNESS ${_sys_bitness}) @@ -182,6 +201,8 @@ elseif (DEFINED AREG_COMPILER AND NOT "${AREG_COMPILER}" STREQUAL "") unset(_sys_compiler) unset(_sys_process) unset(_sys_bitness) + unset(_sys_target) + unset(_compiler_found) # If no specific compiler or family is set, use the system default else() diff --git a/framework/areglogger/CMakeLists.txt b/framework/areglogger/CMakeLists.txt index f44d0c17..f009993e 100644 --- a/framework/areglogger/CMakeLists.txt +++ b/framework/areglogger/CMakeLists.txt @@ -19,7 +19,7 @@ if (AREG_LOGGER_BINARY MATCHES "shared") endif() # build log observer API shared library - addSharedLibEx(areglogger ${AREG_PACKAGE_NAME} "${areglogger_SRC}" ${AREG_SQLITE_LIB_REF}) + addSharedLibEx(areglogger ${AREG_PACKAGE_NAME} "${areglogger_SRC}" "${AREG_SQLITE_LIB_REF}") target_compile_options(areglogger PRIVATE "${AREG_OPT_DISABLE_WARN_TOOLS}") # log observer API shared library target_compile_definitions(areglogger PRIVATE EXP_LOGGER_DLL) diff --git a/thirdparty/sqlite3/CMakeLists.txt b/thirdparty/sqlite3/CMakeLists.txt index 35d2d34a..73695aa0 100644 --- a/thirdparty/sqlite3/CMakeLists.txt +++ b/thirdparty/sqlite3/CMakeLists.txt @@ -5,43 +5,42 @@ set(AREG_SQLITE_INCLUDES) set(AREG_SQLITE_LIBRARY) set(USE_SQLITE_PACKAGE 0) +option(AREG_SQLITE_FOUND "SQLite3 package found flag" FALSE) if (AREG_SQLITE_PACKAGE) # search installed SQLite3 package in the system. macro_find_sqlite_package(AREG_SQLITE_INCLUDES AREG_SQLITE_LIBRARY AREG_SQLITE_FOUND) +endif() - if (AREG_SQLITE_FOUND) +if (AREG_SQLITE_FOUND) - message(STATUS "AREG: >>> Found SQLile library '${AREG_SQLITE_LIBRARY}', include '${AREG_SQLITE_INCLUDES}'") - # If SQLite3 package found set appropriate preprocessor option to include right header. - set(AREG_SQLITE_LIB_REF SQLite::SQLite3) - set(AREG_SQLITE_LIB sqlite3) - set(USE_SQLITE_PACKAGE 1) - add_definitions(-DUSE_SQLITE_PACKAGE=1) + message(STATUS "AREG: >>> Found SQLile library '${AREG_SQLITE_LIBRARY}', include '${AREG_SQLITE_INCLUDES}'") + # If SQLite3 package found set appropriate preprocessor option to include right header. + set(AREG_SQLITE_LIB_REF SQLite::SQLite3) + set(AREG_SQLITE_LIB sqlite3) + set(USE_SQLITE_PACKAGE 1) + add_definitions(-DUSE_SQLITE_PACKAGE=1) - if (NOT "${AREG_SQLITE_INCLUDES}" STREQUAL "") - include_directories(AFTER "${AREG_SQLITE_INCLUDES}") - endif() + if (NOT "${AREG_SQLITE_INCLUDES}" STREQUAL "") + include_directories(AFTER "${AREG_SQLITE_INCLUDES}") + endif() - else(AREG_SQLITE_FOUND) +else(AREG_SQLITE_FOUND) - message(STATUS "AREG: >>> Could not find SQLile library Builds 'aregsqlite3' library from sources.") - # The SQLite3 package did not find, compile from available sources. - set(AREG_SQLITE_PACKAGE OFF CACHE INTERNAL "Use SQLite3 installed package") - set(sqlite_BASE "${AREG_THIRDPARTY}/sqlite3") - list(APPEND sqlite_SRC - ${sqlite_BASE}/amalgamation/sqlite3.c - ) + message(STATUS "AREG: >>> Could not find SQLile library Builds 'aregsqlite3' library from sources.") + # The SQLite3 package did not find, compile from available sources. + set(AREG_SQLITE_PACKAGE OFF CACHE INTERNAL "Use SQLite3 installed package") + set(sqlite_BASE "${AREG_THIRDPARTY}/sqlite3") + list(APPEND sqlite_SRC + ${sqlite_BASE}/amalgamation/sqlite3.c + ) - include_directories(${sqlite_BASE}) + include_directories(${sqlite_BASE}) - set(AREG_SQLITE_LIB_REF ${AREG_PACKAGE_NAME}::aregsqlite3) - set(AREG_SQLITE_LIB aregsqlite3) - addStaticLibEx_C(${AREG_SQLITE_LIB} ${AREG_PACKAGE_NAME} "${sqlite_SRC}" "") - target_compile_options(${AREG_SQLITE_LIB} PRIVATE -DUSE_SQLITE_PACKAGE=0 "${AREG_OPT_DISABLE_WARN_THIRDPARTY}") + set(AREG_SQLITE_LIB_REF ${AREG_PACKAGE_NAME}::aregsqlite3) + set(AREG_SQLITE_LIB aregsqlite3) + addStaticLibEx_C(${AREG_SQLITE_LIB} ${AREG_PACKAGE_NAME} "${sqlite_SRC}" "") + target_compile_options(${AREG_SQLITE_LIB} PRIVATE -DUSE_SQLITE_PACKAGE=0 "${AREG_OPT_DISABLE_WARN_THIRDPARTY}") - endif(AREG_SQLITE_FOUND) +endif(AREG_SQLITE_FOUND) -else() - set(AREG_SQLITE_FOUND FALSE) -endif()