Xmake Repo

https://github.com/xmake-io/xmake-repo
Admin
Xmake-repo is an official package repository for Xmake, designed for managing and submitting...
Tokens:6,274
Snippets:28
Trust Score:7.7
License:Apache-2.0
Update:1 year ago
Show doc for...
Tokens:
Raw
### Installing hiredis-vip Library and Headers with CMake

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/h/hiredis-vip/port/cmakelists.txt

This section details the installation process for hiredis-vip. It installs header files, directories, the library itself (archive, library, runtime), and exports targets for CMake integration.

```cmake
install(DIRECTORY
    adapters
    DESTINATION include/hiredis-vip
)
install(FILES
    hiredis.h async.h read.h sds.h hiutil.h hiarray.h dict.h adlist.h fmacros.h hircluster.h
    DESTINATION include/hiredis-vip
)

install(TARGETS hiredis_vip
    EXPORT hiredis_vipTargets
    ARCHIVE DESTINATION lib
    LIBRARY DESTINATION lib
    RUNTIME DESTINATION bin
)
```

--------------------------------

### Generating and Installing Pkgconfig File with CMake

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/h/hiredis-vip/port/cmakelists.txt

This CMake snippet configures the generation of a hiredis_vip.pc file from a template and installs it into the pkgconfig directory. This allows other projects to easily find and link against hiredis-vip.

```cmake
configure_file(
    ${CMAKE_CURRENT_SOURCE_DIR}/hiredis_vip.pc.in
    ${CMAKE_CURRENT_BINARY_DIR}/hiredis_vip.pc
    @ONLY
)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/hiredis_vip.pc DESTINATION lib/pkgconfig)
```

--------------------------------

### CMake Header Installation

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/m/marisa/port/CMakeLists.txt

Installs the main Marisa header file and all other Marisa header files from the 'include/marisa' directory into the appropriate system include paths.

```cmake
install(FILES "${PROJECT_SOURCE_DIR}/include/marisa.h"
  DESTINATION ${CMAKE_INSTALL_FULL_INCLUDEDIR})

file(GLOB marisa_other_header_files ${PROJECT_SOURCE_DIR}/include/marisa/*.h)
install(FILES ${marisa_other_header_files}
  DESTINATION ${CMAKE_INSTALL_FULL_INCLUDEDIR}/marisa)
```

--------------------------------

### Create Package Template from GitHub using xmake

Source: https://github.com/xmake-io/xmake-repo/blob/dev/README.md

Installs the gh CLI, logs in to GitHub, and creates a package configuration file (xmake.lua) from a GitHub repository. Requires the gh CLI and xmake to be installed.

```console
gh auth login
```

```console
xmake l scripts/new.lua github:glennrp/libpng
```

--------------------------------

### Installing Headers and Package Configuration File (CMake)

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/g/gnu-gsl/cmake/cmakelists.txt

This CMake script handles the installation of public headers, including the generated 'gsl_types.h'. It also configures and installs the 'gsl.pc' file for pkg-config, specifying destinations for runtime, libraries, archives, and headers.

```cmake
file(GLOB_RECURSE PUBLIC_HEADERS gsl*.h)
list(APPEND PUBLIC_HEADERS ${CMAKE_CURRENT_BINARY_DIR}/gsl_types.h)

# The debug libraries have a "d" postfix so that CMake's FindGSL.cmake 
# module can distinguish between Release and Debug libraries
set(CMAKE_DEBUG_POSTFIX "d")



if(INSTALL_HEADERS)
    set_target_properties(gsl PROPERTIES PUBLIC_HEADER "${PUBLIC_HEADERS}")
endif()
# For the build, we need to copy all headers to the gsl directory
file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/gsl)
file(COPY ${PUBLIC_HEADERS} DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/gsl")

set(TARGET_INSTALL_OPTIONS)
if(INSTALL_HEADERS)
    set(TARGET_INSTALL_OPTIONS PUBLIC_HEADER DESTINATION include/gsl)
endif()

configure_file("${CMAKE_CURRENT_SOURCE_DIR}/gsl.pc.in" "${CMAKE_CURRENT_BINARY_DIR}/gsl.pc" @ONLY)
install(FILES "${CMAKE_CURRENT_BINARY_DIR}/gsl.pc" DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")

install(TARGETS gsl gslcblas
    RUNTIME DESTINATION bin
    LIBRARY DESTINATION lib
    ARCHIVE DESTINATION lib
    ${TARGET_INSTALL_OPTIONS}
)
```

--------------------------------

### Base64 Library Target and Installation

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/t/turbobase64/port/CMakeLists.txt

Defines the main `base64` library target (either static or shared) and links the previously created object libraries to it. It also handles potential compatibility issues with Xcode and installs the library and header files.

```cmake
if(BUILD_SHARED_LIBS)
    add_library(base64 SHARED)
else()
    add_library(base64 STATIC)
endif()

foreach(_obj ${_b64_objs})
    set_target_properties(${_obj} PROPERTIES POSITION_INDEPENDENT_CODE ${BUILD_SHARED_LIBS})
    target_sources(base64 PRIVATE $<TARGET_OBJECTS:${_obj}>)
endforeach()

# The XCODE fix is from https://github.com/ClickHouse/ClickHouse/blob/cf7d354a693f15fc5941edbf39e295d0bf8de21c/contrib%2Fbase64-cmake%2FCMakeLists.txt#L46-L54
if(XCODE OR XCODE_VERSION)
    # https://gitlab.kitware.com/cmake/cmake/issues/17457
    # Some native build systems may not like targets that have only object files, so consider adding at least one real source file
    # This applies to Xcode.
    if(NOT EXISTS "${CMAKE_CURRENT_BINARY_DIR}/dummy.c")
        file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/dummy.c" "")
    endif()
    target_sources(base64 PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/dummy.c")
endif()

if(BUILD_APP)
    add_executable(tb64app tb64app.c)
    target_link_libraries(tb64app base64)
endif()

# Set package information.
set(PACKAGE_NAME ${PROJECT_NAME})
set(PACKAGE_NAMESPACE "turbo::")

# For CMAKE_INSTALL_ležitDIR etc.
include(GNUInstallDirs)
set(CONFIG_INSTALL_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PACKAGE_NAME}")

# Please refer "Modern CMake" on how to install a library.
# https://cliutils.gitlab.io/modern-cmake/chapters/install/installing.html
# Also refer to cmake documentation
# https://cmake.org/cmake/help/latest/guide/importing-exporting/index.html

# Set PUBLIC_HEADER property for install(TARGETS) to install header file.
set_target_properties(base64 PROPERTIES PUBLIC_HEADER "${CMAKE_SOURCE_DIR}/turbob64.h")
# Set includes destination for install(TARGETS), which will be added
# to INTERFACE_INCLUDE_DIRECTORIES target property.
# So user only need to call "target_link_libraries(turbo::base64)", without
# needing to set include directories.
target_include_directories(
    base64 SYSTEM PUBLIC
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}> # For being used from add_subdirectory.
    $<INSTALL_INTERFACE:include> # When being used from an installation.
)

# Installs library along with header files.
# Also associates the installed target files with an export.
install(
    TARGETS base64
    EXPORT ${PACKAGE_NAME}-targets
    PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${PACKAGE_NAME}"
)

# Generates and installs cmake config files containing exported targets.
install(
    EXPORT ${PACKAGE_NAME}-targets
    DESTINATION "${CONFIG_INSTALL_DIR}"
    NAMESPACE ${PACKAGE_NAMESPACE}
)
```

--------------------------------

### CMake Tool Executable Builds

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/m/marisa/port/CMakeLists.txt

Conditionally builds command-line tools if BUILD_TOOLS is ON. It defines a list of tool names, creates an object library for 'cmdopt', and then compiles each tool executable, linking them against 'marisa' and 'cmdopt', and installs them.

```cmake
if(BUILD_TOOLS)
  add_library(cmdopt OBJECT "${PROJECT_SOURCE_DIR}/tools/cmdopt.cc")
  set(TOOLS
      marisa-benchmark
      marisa-build
      marisa-common-prefix-search
      marisa-dump
      marisa-lookup
      marisa-predictive-search
      marisa-reverse-lookup
  )
  foreach(TOOL ${TOOLS})
    add_executable(${TOOL} "${PROJECT_SOURCE_DIR}/tools/${TOOL}.cc")
    target_link_libraries(${TOOL} PRIVATE marisa cmdopt)
    install(TARGETS ${TOOL}
      RUNTIME DESTINATION ${CMAKE_INSTALL_FULL_BINDIR})
  endforeach(TOOL)
endif()
```

--------------------------------

### CMake Project Setup and Options

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/t/turbobase64/port/CMakeLists.txt

Initializes the CMake project, sets the build type, and defines various build options such as shared libraries, error checking levels, AVX512 support, and application building. These options control various aspects of the build process and can be toggled via CMake command-line arguments.

```cmake
cmake_minimum_required(VERSION 3.15)

project(turbobase64 C)

if(NOT CMAKE_BUILD_TYPE)
    set(CMAKE_BUILD_TYPE Release)
endif()

# Run cmake -D<OPTION>=ON|OFF to turn on/off options.
# Usage example:
#     cmake -B build -S . -DNCHECK=ON
#     cmake --build build
option(BUILD_SHARED_LIBS "Build shared libraries" OFF)
option(NCHECK "Dinsable for checking for more fast decoding" OFF)
# default=partial checking, detect allmost all errors
option(FULLCHECK "Enable full base64 checking" OFF)
option(USE_AVX512 "Enable AVX512" OFF)
option(BUILD_APP "Build executables" OFF)
```

--------------------------------

### CMake Package Configuration File Generation

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/m/marisa/port/CMakeLists.txt

Generates a 'marisa.pc' file from a template ('marisa.pc.in') for pkg-config support, which is then installed in the pkg-config directory.

```cmake
configure_file(
    ${PROJECT_SOURCE_DIR}/marisa.pc.in
    ${PROJECT_BINARY_DIR}/marisa.pc
    @ONLY)
install(FILES ${PROJECT_BINARY_DIR}/marisa.pc
  DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR}/pkgconfig)
```

--------------------------------

### Create Package Template from GitHub (xmake.lua)

Source: https://github.com/xmake-io/xmake-repo/blob/dev/README_zh.md

This snippet demonstrates how to generate a package configuration file (xmake.lua) for a library hosted on GitHub using the xmake CLI. It requires the 'gh' CLI tool to be installed and authenticated. The generated file includes package metadata, download URLs, version information, dependencies, installation logic, and testing functions.

```bash
gh auth login

```

```bash
xmake l scripts/new.lua github:glennrp/libpng

```

```lua
package("libpng")
    set_homepage("http://libpng.sf.net")
    set_description("LIBPNG: Portable Network Graphics support, official libpng repository")

    add_urls("https://github.com/glennrp/libpng/archive/refs/tags/$(version).tar.gz",
             "https://github.com/glennrp/libpng.git")
    add_versions("v1.6.35", "6d59d6a154ccbb772ec11772cb8f8beb0d382b61e7ccc62435bf7311c9f4b210")

    add_deps("cmake")

    on_install(function (package)
        local configs = {}
        table.insert(configs, "-DCMAKE_BUILD_TYPE=" .. (package:debug() and "Debug" or "Release"))
        table.insert(configs, "-DBUILD_SHARED_LIBS=" .. (package:config("shared") and "ON" or "OFF"))
        import("package.tools.cmake").install(package, configs)
    end)

    on_test(function (package)
        assert(package:has_cfuncs("foo", {includes = "foo.h"}))
    end)

```

--------------------------------

### CMake Library Definitions and Linking

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/m/marisa/port/CMakeLists.txt

Defines several object libraries ('io', 'trie', 'vector') from specific source files and a main 'marisa' library. It links these object libraries to the 'marisa' target and sets up installation rules for the 'marisa' library.

```cmake
add_library(io OBJECT
  "${PROJECT_SOURCE_DIR}/lib/marisa/grimoire/io/mapper.cc"
  "${PROJECT_SOURCE_DIR}/lib/marisa/grimoire/io/reader.cc"
  "${PROJECT_SOURCE_DIR}/lib/marisa/grimoire/io/writer.cc")

add_library(trie OBJECT
  "${PROJECT_SOURCE_DIR}/lib/marisa/grimoire/trie/tail.cc"
  "${PROJECT_SOURCE_DIR}/lib/marisa/grimoire/trie/louds-trie.cc")

add_library(vector OBJECT
  "${PROJECT_SOURCE_DIR}/lib/marisa/grimoire/vector/bit-vector.cc")

add_library(marisa ${MARISA_LIBRARY_TYPE}
  "${PROJECT_SOURCE_DIR}/lib/marisa/keyset.cc"
  "${PROJECT_SOURCE_DIR}/lib/marisa/trie.cc"
  "${PROJECT_SOURCE_DIR}/lib/marisa/agent.cc")
target_link_libraries(marisa PRIVATE io trie vector)
install(TARGETS marisa
  RUNTIME DESTINATION ${CMAKE_INSTALL_FULL_BINDIR}
  LIBRARY DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR}
  ARCHIVE DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR})
```

--------------------------------

### Defining and Configuring the hiredis_vip Library in CMake

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/h/hiredis-vip/port/cmakelists.txt

This code defines the hiredis_vip library using a list of source files. It sets include directories for build and installation, specifies C99 compilation features, and applies compiler options for warnings.

```cmake
set(SOURCES
    net.c
    hiredis.c
    sds.c
    async.c
    read.c
    hiarray.c
    hiutil.c
    command.c
    crc16.c
    adlist.c
    hircluster.c
    dict.c
)

add_library(hiredis_vip ${SOURCES})
target_include_directories(hiredis_vip
    PUBLIC
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
        $<INSTALL_INTERFACE:include/hiredis-vip>
)
target_compile_features(hiredis_vip PRIVATE c_std_99)
target_compile_options(hiredis_vip PRIVATE -Wall -Wstrict-prototypes -Wwrite-strings)
```

--------------------------------

### Submit Package to xmake Repository (xmake.lua)

Source: https://github.com/xmake-io/xmake-repo/blob/dev/README.md

Example of how to define a package for the xmake repository using a xmake.lua file. This file specifies build configurations and dependencies for a C/C++ library.

```lua
local p = "zlib"

rule "binary"

    set_kind "binary"

    add_defines "ZLIB_DLL"

    if is_os("windows") then
        add_defines "_CRT_SECURE_NO_WARNINGS"
    end

actions "compile"

    buildvariants {"release", "debug"}

    add_files("*.c")
    add_files("*.h")

    add_includedirs "include"

    add_links("zlib")

    on_install(function(package)
        local prefix = package:install();
        os.cp("include", prefix.includedir)
        os.cp("zlib.lib", prefix.libdir)
        os.cp("zlib.dll", prefix.bindir)
        os.cp("zlib.pdb", prefix.bindir)
    end)
```

--------------------------------

### Generate CMake Package Config File

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/t/turbobase64/port/CMakeLists.txt

This snippet generates a CMake package configuration file from a template using `configure_package_config_file`. It defines the input template, output config file name, installation destination, and references path variables like include and library directories. The generated file is then installed.

```cmake
include(CMakePackageConfigHelpers)
configure_package_config_file(
    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/${PACKAGE_NAME}-config.cmake.in"
    ${PACKAGE_NAME}-config.cmake
    INSTALL_DESTINATION "${CONFIG_INSTALL_DIR}"
    #NO_CHECK_REQUIRED_COMPONENTS_MACRO
    # PATH_VARS can be referenced in config template file with PACKAGE_<var>.
    PATH_VARS CMAKE_INSTALL_INCLUDEDIR CMAKE_INSTALL_LIBDIR
    )
install(
    FILES
    "${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE_NAME}-config.cmake"
    DESTINATION "${CONFIG_INSTALL_DIR}"
)
```

--------------------------------

### Setting Target Properties for hiredis_vip in CMake

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/h/hiredis-vip/port/cmakelists.txt

This snippet configures properties for the hiredis_vip target, including output name, version, and SOVERSION. It includes conditional logic for macOS to set RPATH and install name directory.

```cmake
if(APPLE AND BUILD_SHARED_LIBS)
    set_target_properties(hiredis_vip PROPERTIES
        MACOSX_RPATH ON
        INSTALL_NAME_DIR "@rpath"
        OUTPUT_NAME "hiredis_vip"
        VERSION "${HIREDIS_VIP_MAJOR}.${HIREDIS_VIP_MINOR}.${HIREDIS_VIP_PATCH}"
        SOVERSION "${HIREDIS_VIP_MAJOR}"
    )
else()
    set_target_properties(hiredis_vip PROPERTIES
        OUTPUT_NAME "hiredis_vip"
        VERSION "${HIREDIS_VIP_MAJOR}.${HIREDIS_VIP_MINOR}.${HIREDIS_VIP_PATCH}"
        SOVERSION "${HIREDIS_VIP_MAJOR}"
    )
endif()
```

--------------------------------

### Extracting C Sources from Makefile (CMake)

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/g/gnu-gsl/cmake/cmakelists.txt

This CMake function, 'extract_sources', utilizes 'extract_from_makefile' to get source files listed in a Makefile.am. It prepends the SUBFOLDER path to each extracted source file and appends them to a cumulative list.

```cmake
function(extract_sources SUBFOLDER ALLSOURCES)
    extract_from_makefile("lib[a-zA-Z1-9_]*_la_SOURCES[ \t]*=[ \t]*(((\\\\n)?[^\n])*)" SOURCEFILES "${SUBFOLDER}/Makefile.am")
    # Add the folder in front of the file names 
    string(REGEX REPLACE "([^;]+)" "${SUBFOLDER}/\1" SOURCEFILES "${SOURCEFILES}")
    # Return 
    set(${ALLSOURCES} ${${ALLSOURCES}} ${SOURCEFILES} PARENT_SCOPE)
endfunction(extract_sources)
```

--------------------------------

### CMake Build Configuration

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/m/marisa/port/CMakeLists.txt

Sets up the minimum CMake version, project name, and includes standard directories. It also defines build options for shared libraries, tools, and tests, which influence subsequent build configurations.

```cmake
cmake_minimum_required(VERSION 3.1)
project(marisa CXX)

include(GNUInstallDirs)

option(BUILD_SHARED_LIBS "Build as shared library" OFF)
option(BUILD_TOOLS "Build tools" ON)
option(ENABLE_TESTS "Build and run tests" ON)

if(BUILD_SHARED_LIBS)
  set(MARISA_LIBRARY_TYPE SHARED)
else()
  set(MARISA_LIBRARY_TYPE STATIC)
endif(BUILD_SHARED_LIBS)

set(CMAKE_CXX_STANDARD 11)

if(NOT CMAKE_BUILD_TYPE)
  set(CMAKE_BUILD_TYPE Debug)
endif()

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
if(NOT MSVC)
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Weffc++ -Wextra -Wconversion")
endif()

if(BUILD_SHARED_LIBS AND MSVC)
  set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
endif()

include_directories("${PROJECT_SOURCE_DIR}/include")
include_directories("${PROJECT_SOURCE_DIR}/lib")
```

--------------------------------

### xmake.lua Package Configuration for libpng

Source: https://github.com/xmake-io/xmake-repo/blob/dev/README.md

Defines the package metadata, dependencies, build configurations, and installation/test logic for the libpng package using xmake.lua.

```lua
package("libpng")
    set_homepage("http://libpng.sf.net")
    set_description("LIBPNG: Portable Network Graphics support, official libpng repository")

    add_urls("https://github.com/glennrp/libpng/archive/refs/tags/$(version).tar.gz",
             "https://github.com/glennrp/libpng.git")
    add_versions("v1.6.35", "6d59d6a154ccbb772ec11772cb8f8beb0d382b61e7ccc62435bf7311c9f4b210")

    add_deps("cmake")

    on_install(function (package)
        local configs = {}
        table.insert(configs, "-DCMAKE_BUILD_TYPE=" .. (package:debug() and "Debug" or "Release"))
        table.insert(configs, "-DBUILD_SHARED_LIBS=" .. (package:config("shared") and "ON" or "OFF"))
        import("package.tools.cmake").install(package, configs)
    end)

    on_test(function (package)
        assert(package:has_cfuncs("foo", {includes = "foo.h"}))
    end)
```

--------------------------------

### CMake Test Executable Builds

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/m/marisa/port/CMakeLists.txt

Conditionally enables testing and builds test executables if ENABLE_TESTS is ON. It defines a list of test names, compiles each test executable, links them against the 'marisa' library, and registers them as CTest tests.

```cmake
if(ENABLE_TESTS)
  enable_testing()
  set(TESTS
      base-test
      io-test
      trie-test
      vector-test
      marisa-test
  )
  foreach(TEST ${TESTS})
    add_executable(${TEST} "${PROJECT_SOURCE_DIR}/tests/${TEST}.cc")
    target_link_libraries(${TEST} PRIVATE marisa)
    add_test(${TEST} ${TEST})
  endforeach(TEST)
endif()
```

--------------------------------

### Exporting CMake Targets for hiredis_vip

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/h/hiredis-vip/port/cmakelists.txt

This code exports the hiredis_vip targets, creating a CMake configuration file (`hiredis_vipTargets.cmake`). This facilitates the use of hiredis-vip in other CMake projects.

```cmake
install(EXPORT hiredis_vipTargets
    FILE hiredis_vipTargets.cmake
    NAMESPACE hiredis_vip::
    DESTINATION lib/cmake/hiredis_vip
)
```

--------------------------------

### Test Local Package with xmake

Source: https://github.com/xmake-io/xmake-repo/blob/dev/README.md

Tests a local package using xmake with various command-line options for shallow cloning, verbose output, debug mode, target platforms, build kinds, and runtimes.

```console
xmake l scripts/test.lua --shallow -vD zlib
```

```console
xmake l scripts/test.lua --shallow -vD -p iphoneos zlib
```

```console
xmake l scripts/test.lua --shallow -vD -k shared -m debug zlib
```

```console
xmake l scripts/test.lua --shallow -vD --runtimes=MD zlib
```

--------------------------------

### Object Library Creation and Optimization

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/t/turbobase64/port/CMakeLists.txt

Creates object libraries for different parts of the base64 implementation, including scalar operations and vector instructions (SSE, AVX, NEON, Power9). It applies architecture-specific compile options to these object libraries.

```cmake
# Object library is just a bunch of object files.
add_library(_b64_scalar OBJECT turbob64c.c turbob64d.c)
target_compile_options(_b64_scalar PRIVATE ${MARCH} -falign-loops)

# turbob64v128.c contains code for SSE, AVX, NEON, Power9.
# It's compiled twice with different flags.
add_library(_b64_v128 OBJECT turbob64v128.c)
target_compile_options(_b64_v128 PRIVATE ${MSSE} -falign-loops)

# Use a list to collect all object libraries.
set(_b64_objs _b64_scalar _b64_v128)

if(ARCH_AMD64)
    # Compile turbob64v128.c for the second time.
    add_library(_b64_avx OBJECT turbob64v128.c)
    target_compile_options(_b64_avx PRIVATE -march=corei7-avx -mtune=corei7-avx -mno-aes -fstrict-aliasing)
    list(APPEND _b64_objs _b64_avx)

    add_library(_b64_v256 OBJECT turbob64v256.c)
    target_compile_options(_b64_v256 PRIVATE -march=haswell -fstrict-aliasing -falign-loops)
    list(APPEND _b64_objs _b64_v256)
endif()
```

--------------------------------

### Configuring gsl_types.h for Windows (CMake)

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/g/gnu-gsl/cmake/cmakelists.txt

This code snippet reads the 'gsl_types.h' file, performs conditional replacements for Windows compatibility ('WIN32' to '_WIN32') and shared library builds ('GSL_DLL'), and writes the modified content back to a new file in the binary directory.

```cmake
file(READ gsl_types.h GSLTYPES_H)
string(REPLACE "#ifdef WIN32" "#ifdef _WIN32" GSLTYPES_H "${GSLTYPES_H}")
if(BUILD_SHARED_LIBS)
    string(REPLACE "#  ifdef GSL_DLL" "#  if 1 /*GSL_DLL*/" GSLTYPES_H "${GSLTYPES_H}")
endif()
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/gsl_types.h "${GSLTYPES_H}")
```

--------------------------------

### Defining and Configuring the gslcblas Library (CMake)

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/g/gnu-gsl/cmake/cmakelists.txt

This section defines the 'gslcblas' static library using sources extracted from Makefiles. It sets the 'WINDOWS_EXPORT_ALL_SYMBOLS' property to ON, which is relevant for Windows builds.

```cmake
add_library(gslcblas ${CBLAS_SOURCES})
set_target_properties(gslcblas PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
```

--------------------------------

### Defining and Configuring the gsl Library (CMake)

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/g/gnu-gsl/cmake/cmakelists.txt

This code defines the main 'gsl' library using extracted sources. It configures properties for symbol export on Windows and links it with the 'gslcblas' library. Header directories are also set for private inclusion.

```cmake
add_library(gsl ${SOURCES})
set_target_properties(gsl PROPERTIES DEFINE_SYMBOL DLL_EXPORT WINDOWS_EXPORT_ALL_SYMBOLS ON)
target_link_libraries(gsl PUBLIC gslcblas)



target_include_directories(gslcblas PRIVATE ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
target_include_directories(gsl PRIVATE ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
```

--------------------------------

### Extracting Version Information with Regex in CMake

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/h/hiredis-vip/port/cmakelists.txt

This snippet demonstrates how to read a header file and extract version components (major, minor, patch) using regular expressions in CMake. It relies on the 'string(REGEX MATCH ...)' command.

```cmake
file(READ "${CMAKE_CURRENT_SOURCE_DIR}/hircluster.h" HIRCLUSTER_H)
string(REGEX MATCH "HIREDIS_VIP_MAJOR[ \t]+([0-9]+)" _ ${HIRCLUSTER_H})
set(HIREDIS_VIP_MAJOR "${CMAKE_MATCH_1}")
string(REGEX MATCH "HIREDIS_VIP_MINOR[ \t]+([0-9]+)" _ ${HIRCLUSTER_H})
set(HIREDIS_VIP_MINOR "${CMAKE_MATCH_1}")
string(REGEX MATCH "HIREDIS_VIP_PATCH[ \t]+([0-9]+)" _ ${HIRCLUSTER_H})
set(HIREDIS_VIP_PATCH "${CMAKE_MATCH_1}")
```

--------------------------------

### Architecture Detection and Compilation Flags

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/t/turbobase64/port/CMakeLists.txt

Detects the system's processor architecture (x86_64, aarch64, ppc64le) and sets corresponding compilation flags (`MARCH`, `MSSE`). It also sets general release and debug optimization flags for the C compiler.

```cmake
message(STATUS "Configuring with CMAKE_SYSTEM_PROCESSOR ${CMAKE_SYSTEM_PROCESSOR}")
if(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64")
    set(ARCH_AMD64 ON)
elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "aarch64")
    set(ARCH_AARCH64 ON)
elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "ppc64le")
    set(ARCH_PPC64LE ON)
endif()

set(CMAKE_C_FLAGS_RELEASE "-O3")
set(CMAKE_C_FLAGS_DEBUG "-O0 -ggdb")

# Set compiler options.
if(NCHECK)
    add_compile_definitions(NB64CHECK)
endif()
if(FULLCHECK)
    add_compile_definitions(DB64CHECK)
endif()
if(USE_AVX512)
    add_compile_definitions(USE_AVX512)
endif()

if(ARCH_PPC64LE)
    set(MARCH "-march=power9 -mtune=power9")
    set(MSSE "-D__SSSE3__")
elseif(ARCH_AARCH64)
    set(MARCH "-march=armv8-a")
else()
    set(MARCH "-march=native")
    set(MSSE "-mssse3")
endif()
```

--------------------------------

### Extracting Data from Makefile with Regex (CMake)

Source: https://github.com/xmake-io/xmake-repo/blob/dev/packages/g/gnu-gsl/cmake/cmakelists.txt

This CMake function, 'extract_from_makefile', reads a specified Makefile, extracts content matching a given PATTERN using regular expressions, and processes it into a space-separated list. It handles escaped newlines for multi-line entries.

```cmake
function(extract_from_makefile PATTERN RETURN FILEPATH)
    file(READ ${FILEPATH} MAKEFILE_CONTENT)
    string(REGEX MATCH "${PATTERN}" CONTENTS "${MAKEFILE_CONTENT}")
    set(CONTENTS ${CMAKE_MATCH_1})
    # Split string into list
    string(REGEX REPLACE "([\t ]+(\\\\n)?)+" ";" CONTENTS "${CONTENTS}")
    string(REGEX REPLACE "[\t ]*\\\\n[\t ]* দূ" "" CONTENTS "${CONTENTS}")
    if("${CONTENTS}" STREQUAL "")
        message(AUTHOR_WARNING "No match for \"${PATTERN}\" found in file ${FILEPATH}")
    endif()
    # Return 
    set(${RETURN} ${CONTENTS} PARENT_SCOPE)
endfunction(extract_from_makefile)
```
Tokens:
Raw