cemu-project/vcpkg
1
0
Fork 0
mirror of https://github.com/cemu-project/vcpkg.git synced 2024-12-03 16:52:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
1658781750
vcpkg/scripts/cmake/vcpkg_fixup_pkgconfig.cmake
nicole mazzuca 1d8f0acc9c
[vcpkg manifest] Manifest Implementation (#11757) 
==== Changes Related to manifests ====

* Add the `manifests` feature flag
  * This only says whether we look for a `vcpkg.json` in the cwd, not
    whether we support parsing manifests (for ports, for example)
* Changes to the manifests RFC
  * `"authors"` -> `"maintainers"`
  * `--x-classic-mode` -> `-manifests` \in `vcpkg_feature_flags`
  * reserve `"core"` in addition to `"default"`, since that's already
    reserved for features
  * Add a small helper note about what identifiers must look like
  * `<license-string>`: SPDX v3.8 -> v3.9
  * `"feature"."description"` is allowed to be an array of strings as well
  * `"version"` -> `"version-string"` for forward-compat with versions
    RFC
* Add the `--feature-flags` option
* Add the ability to turn off feature flags via passing
  `-<feature-flag>` to `VCPKG_FEATURE_FLAGS` or `--feature-flags`
* Add CMake toolchain support for manifests
  * Requires either:
    * a feature flag of `manifests` in either `Env{VCPKG_FEATURE_FLAGS}`
      or `VCPKG_FEATURE_FLAGS`
    * Passing the `VCPKG_ENABLE_MANIFESTS` option
  * The toolchain will install your packages to
    `${VCPKG_MANIFEST_DIR}/vcpkg_installed`.
* Add MSBuild `vcpkg integrate install` support for manifests
  * Requires `VcpkgEnableManifest` to be true
* `vcpkg create` creates a port that has a `vcpkg.json` instead of a
  `CONTROL`
* argparse, abseil, 3fd, and avisynthplus ports switched to manifest
  from CONTROL
* Add support for `--x-manifest-root`, as well as code for finding it if
  not passed
* Add support for parsing manifests!
* Add a filesystem lock!

==== Important Changes which are somewhat unrelated to manifests ====

* Rename `logicexpression.{h,cpp}` to `platform-expression.{h,cpp}`
* Add `PlatformExpression` type which takes the place of the old logic
  expression
  * Split the parsing of platform expressions from checking whether
    they're true or not
  * Eagerly parse PlatformExpressions as opposed to leaving them as
    strings
* Add checking for feature flag consistency
  * i.e., if `-binarycaching` is passed, you shouldn't be passing
    `--binarysource`
* Add the `Json::Reader` type which, with the help of user-defined
  visitors, converts JSON to your internal type
* VcpkgArgParser: place the switch names into a constant as opposed to
  using magic constants
  * In general update the parsing code so that this ^ works
* Add `Port-Version` fields to CONTROL files
  * This replaces the existing practice of
    `Version: <my-version>-<port-version>`

==== Smaller changes ====
* small drive-by cleanups to some CMake
  * `${_VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}` ->
    `${CURRENT_INSTALLED_DIR}`
  * Remove `-analyze` when compiling with clang-cl, since that's not a
    supported flag (vcpkg's build system)
  * Add a message about which compiler is detected by vcpkg's build
    system machinery
* Fix `Expected::then`
* Convert `""` to `{}` for `std::string` and `fs::path`, to avoid a
  `strlen` (additionally, `.empty()` instead of `== ""`, and `.clear()`)
* Add `Strings::strto` which converts strings to numeric types
* Support built-in arrays and `StringView` for `Strings::join`
* Add `operator<` and friends to `StringView`
* Add `substr` to `StringView`
* SourceParagraphParser gets some new errors
2020-06-30 10:40:18 -07:00

284 lines
16 KiB
CMake
Raw Blame History

## # vcpkg_fixup_pkgconfig
##
## Fix common paths in *.pc files and make everything relativ to $(prefix)
##
## ## Usage
## ```cmake
## vcpkg_fixup_pkgconfig(
## [RELEASE_FILES <PATHS>...]
## [DEBUG_FILES <PATHS>...]
## [SYSTEM_LIBRARIES <NAMES>...]
## )
## ```
##
## ## Parameters
## ### RELEASE_FILES
## Specifies a list of files to apply the fixes for release paths.
## Defaults to every *.pc file in the folder ${CURRENT_PACKAGES_DIR} without ${CURRENT_PACKAGES_DIR}/debug/
##
## ### DEBUG_FILES
## Specifies a list of files to apply the fixes for debug paths.
## Defaults to every *.pc file in the folder ${CURRENT_PACKAGES_DIR}/debug/
##
## ### SYSTEM_PACKAGES
## If the *.pc file contains system packages outside vcpkg these need to be listed here.
## Since vcpkg checks the existence of all required packages within vcpkg.
##
## ### SYSTEM_LIBRARIES
## If the *.pc file contains system libraries outside vcpkg these need to be listed here.
## VCPKG checks every -l flag for the existence of the required library within vcpkg.
##
## ### IGNORE_FLAGS
## If the *.pc file contains flags in the lib field which are not libraries. These can be listed here
##
## ## Notes
## Still work in progress. If there are more cases which can be handled here feel free to add them
##
## ## Examples
##
## Just call vcpkg_fixup_pkgconfig() after any install step which installs *.pc files.
function(vcpkg_fixup_pkgconfig_check_libraries _config _contents_var _system_libs _system_packages _ignore_flags)
set(CMAKE_FIND_LIBRARY_SUFFIXES_BACKUP ${CMAKE_FIND_LIBRARY_SUFFIXES})
list(APPEND CMAKE_FIND_LIBRARY_SUFFIXES ".lib;.dll.a;.a")
#message(STATUS "Checking configuration: ${_config}")
if("${_config}" STREQUAL "DEBUG")
set(prefix "${CURRENT_INSTALLED_DIR}/debug/")
set(libprefix "${CURRENT_INSTALLED_DIR}/debug/lib/")
set(installprefix "${CURRENT_PACKAGES_DIR}/debug/")
set(installlibprefix "${CURRENT_PACKAGES_DIR}/debug/lib/")
set(lib_suffixes d _d _debug)
elseif("${_config}" STREQUAL "RELEASE")
set(prefix "${CURRENT_INSTALLED_DIR}")
set(libprefix "${CURRENT_INSTALLED_DIR}/lib/")
set(installprefix "${CURRENT_PACKAGES_DIR}/")
set(installlibprefix "${CURRENT_PACKAGES_DIR}/lib/")
set(lib_suffixes "")
else()
message(FATAL_ERROR "Unknown configuration in vcpkg_fixup_pkgconfig_check_libraries!")
endif()
debug_message("Default library search paths: ${libprefix} --- ${installlibprefix} --- ${PKG_LIB_SEARCH_PATH}")
set(_contents "${${_contents_var}}")
#message(STATUS "Contents: ${_contents}")
set(_system_lib_normalized)
foreach(_system_lib ${_system_libs})
string(REPLACE "-l" "" _system_lib "${_system_lib}")
list(APPEND _system_lib_normalized "${_system_lib}")
endforeach()
## Extra libraries:
string(REGEX MATCH "Libs:[^\n#]+" _libs "${_contents}")
#message(STATUS "LIB LINE: ${_libs}")
# The path to the library is either quoted and can not contain a quote or it is unqouted and cannot contain a single unescaped space
string(REGEX REPLACE "Libs:" "" _libs_list_tmp "${_libs}")
string(REGEX REPLACE [[[\t ]+(-(l|L)?("[^"]+"|(\\ |[^ ]+)+))]] ";\\1" _libs_list_tmp "${_libs_list_tmp}")
string(REGEX MATCH "Libs.private:[^\n#]+" _libs_private "${_contents}")
string(REGEX REPLACE "Libs.private:" "" _libs_private_list_tmp "${_libs_private}")
string(REGEX REPLACE [[[\t ]+(-(l|L)?("[^"]+"|(\\ |[^ ]+)+))]] ";\\1" _libs_private_list_tmp "${_libs_private_list_tmp}")
#message(STATUS "Found libraries: ${_libs_list_tmp}")
#message(STATUS "Found private libraries: ${_libs_private_list_tmp}")
list(APPEND _all_libs "${_libs_list_tmp}" "${_libs_private_list_tmp}")
list(REMOVE_DUPLICATES _all_libs)
foreach(_lib ${_all_libs})
string(REGEX REPLACE "(^[\t ]+|[\t ]+$)" "" _lib "${_lib}") # Remove whitespaces at begin & end
if( "x${_lib}x" STREQUAL "xx") #Empty String
continue()
endif()
unset(CHECK_LIB CACHE)
unset(NO_CHECK_LIB)
#message(STATUS "CHECKING: x${_lib}z")
if("${_lib}" MATCHES "^-L((\\ |[^ ]+)+)$")
debug_message("Search path for libraries (unused): ${CMAKE_MATCH_1}") # not used yet we assume everything can be found in libprefix
continue()
elseif("${_lib}" MATCHES [[^-l("[^"]+"|(\\ |[^ ]+)+)$]] )
set(_libname ${CMAKE_MATCH_1})
debug_message("Searching for library: ${_libname}")
#debug_message("System libraries: ${_system_libs}")
foreach(_system_lib ${_system_libs})
string(REPLACE "^[\t ]*-l" "" _libname_norm "${_libname}")
string(REGEX REPLACE "[\t ]+$" "" _libname_norm "${_libname_norm}")
#debug_message("${_libname_norm} vs ${_system_lib}")
if("${_libname_norm}" MATCHES "${_system_lib}" OR "-l${_libname_norm}" MATCHES "${_system_lib}")
set(NO_CHECK_LIB ON)
debug_message("${_libname} is SYSTEM_LIBRARY")
break()
endif()
endforeach()
if(NO_CHECK_LIB)
break()
endif()
#debug_message("Searching for library ${_libname} in ${libprefix}")
if(EXISTS "${_libname}") #full path
set(CHECK_LIB_${_libname} "${_libname}" CACHE INTERNAL FORCE)
endif()
find_library(CHECK_LIB_${_libname} NAMES "${_libname}" PATHS "${libprefix}" "${installlibprefix}" "${PKG_LIB_SEARCH_PATH}" NO_DEFAULT_PATH)
if(NOT CHECK_LIB_${_libname} AND "${_config}" STREQUAL "DEBUG")
#message(STATUS "Unable to locate ${_libname}. Trying with debug suffix")
foreach(_lib_suffix ${lib_suffixes})
string(REPLACE ".dll.a|.a|.lib|.so" "" _name_without_extension "${_libname}")
find_library(CHECK_LIB_${_libname} NAMES ${_name_without_extension}${_lib_suffix} PATHS "${libprefix}" "${installlibprefix}" "${PKG_LIB_SEARCH_PATH}")
if(CHECK_LIB_${_libname})
message(FATAL_ERROR "Found ${CHECK_LIB_${_libname}} with additional debug suffix! Please correct the *.pc file!")
string(REGEX REPLACE "(-l${_name_without_extension})(\.dll\.a|\.a|\.lib|\.so)" "\\1${_lib_suffix}\\2" _contents ${_contents})
endif()
endforeach()
if(NOT CHECK_LIB_${_libname})
message(FATAL_ERROR "Library ${_libname} was not found! If it is a system library use the SYSTEM_LIBRARIES parameter for the vcpkg_fixup_pkgconfig call! Otherwise, corret the *.pc file")
endif()
elseif(NOT CHECK_LIB_${_libname})
message(FATAL_ERROR "Library ${_libname} was not found! If it is a system library use the SYSTEM_LIBRARIES parameter for the vcpkg_fixup_pkgconfig call! Otherwise, corret the *.pc file")
else()
debug_message("Found ${_libname} at ${CHECK_LIB_${_libname}}")
endif()
else()
#handle special cases
if(_lib STREQUAL "-pthread" OR _lib STREQUAL "-pthreads")
# Replace with VCPKG version?
#VCPKG should probably rename one of the pthread versions to avoid linking against system pthread?
# set(PTHREAD_SUFFIX )
# if("${_config}" STREQUAL "DEBUG")
# file(GLOB PTHREAD_LIB "${CURRENT_INSTALLED_DIR}/debug/lib/${VCPKG_TARGET_STATIC_LIBRARY_PREFIX}pthread*C3d.*")
# elseif("${_config}" STREQUAL "RELEASE")
# file(GLOB PTHREAD_LIB "${CURRENT_INSTALLED_DIR}/lib/${VCPKG_TARGET_STATIC_LIBRARY_PREFIX}pthread*C3.*")
# endif()
# get_filename_component(PTHREAD_LIB "${PTHREAD_LIB}" NAME_WE)
# string(REPLACE "Libs: -pthread" "Libs: -L\${libdir} -l${PTHREAD_LIB}" _contents ${_contents})
elseif(_lib STREQUAL _ignore_flags)
message(STATUS "${_lib} found in *.pc file and ignored!")
else()
message(FATAL_ERROR "Found ${_lib} and no rule to analyse the flag! Please check the *.pc file")
endif()
endif()
unset(CHECK_LIB_${_libname} CACHE)
unset(NO_CHECK_LIB)
endforeach()
## Packages:
string(REGEX MATCH "Requires:[^\n#]+" _pkg_list_tmp "${_contents}")
string(REGEX REPLACE "Requires:[\t ]" "" _pkg_list_tmp "${_pkg_list_tmp}")
string(REGEX REPLACE "[\t ]*,[\t ]*" ";" _pkg_list_tmp "${_pkg_list_tmp}")
string(REGEX REPLACE "[\t ]*(>|=)+[\t ]*([0-9]+|\\.)+" "" _pkg_list_tmp "${_pkg_list_tmp}")
string(REGEX REPLACE " " ";" _pkg_list_tmp "${_pkg_list_tmp}")
string(REGEX MATCH "Requires.private:[^\n#]+" _pkg_private_list_tmp "${_contents}")
string(REGEX REPLACE "Requires.private:[\t ]" "" _pkg_private_list_tmp "${_pkg_private_list_tmp}")
string(REGEX REPLACE "[\t ]*,[\t ]*" ";" _pkg_private_list_tmp "${_pkg_private_list_tmp}")
string(REGEX REPLACE "[\t ]*(>|=)+[\t ]*([0-9]+|\\.)+" " " _pkg_private_list_tmp "${_pkg_private_list_tmp}")
string(REGEX REPLACE "[\t ]+" ";" _pkg_private_list_tmp "${_pkg_private_list_tmp}")
debug_message("Required packages: ${_pkg_list_tmp}")
debug_message("Required private packages: ${_pkg_private_list_tmp}")
#message(STATUS "System packages: ${_system_packages}")
foreach(_package ${_pkg_list_tmp} ${_pkg_private_list_tmp})
debug_message("Searching for package: ${_package}")
set(PKG_CHECK ON)
if(NOT "${_system_packages}" STREQUAL "")
#message(STATUS "Checking ${_package} for SYSTEM PACKAGE: ${_system_packages}")
if("${_system_packages}" MATCHES "${_package}" )
debug_message("Package ${_package} is SYSTEM PACKAGE!")
set(PKG_CHECK OFF)
endif()
endif()
if(PKG_CHECK AND NOT (EXISTS "${libprefix}/pkgconfig/${_package}.pc" OR EXISTS "${installlibprefix}/pkgconfig/${_package}.pc" OR EXISTS "${PKG_LIB_SEARCH_PATH}/pkgconfig/${_package}.pc"))
message(FATAL_ERROR "Package ${_package} not found! If it is a system package add it to the SYSTEM_PACKAGES parameter for the vcpkg_fixup_pkgconfig call! Otherwise, corret the *.pc file")
else()
debug_message("Found package ${_package}!")
endif()
endforeach()
## Push modifications up in scope
set(${_contents_var} "${_contents}" PARENT_SCOPE)
set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_BACKUP})
endfunction()
function(vcpkg_fixup_pkgconfig)
cmake_parse_arguments(_vfpkg "" "" "RELEASE_FILES;DEBUG_FILES;SYSTEM_LIBRARIES;SYSTEM_PACKAGES;IGNORE_FLAGS" ${ARGN})
if(VCPKG_SYSTEM_LIBRARIES)
list(APPEND _vfpkg_SYSTEM_LIBRARIES ${VCPKG_SYSTEM_LIBRARIES})
endif()
message(STATUS "Fixing pkgconfig")
if(_vfpkg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "vcpkg_fixup_pkgconfig was passed extra arguments: ${_vfct_UNPARSED_ARGUMENTS}")
endif()
if(NOT _vfpkg_RELEASE_FILES)
file(GLOB_RECURSE _vfpkg_RELEASE_FILES "${CURRENT_PACKAGES_DIR}/**/*.pc")
list(FILTER _vfpkg_RELEASE_FILES EXCLUDE REGEX "${CURRENT_PACKAGES_DIR}/debug/")
endif()
if(NOT _vfpkg_DEBUG_FILES)
file(GLOB_RECURSE _vfpkg_DEBUG_FILES "${CURRENT_PACKAGES_DIR}/debug/**/*.pc")
list(FILTER _vfpkg_DEBUG_FILES INCLUDE REGEX "${CURRENT_PACKAGES_DIR}/debug/")
endif()
#Absolute Unix like paths
string(REGEX REPLACE "([a-zA-Z]):/" "/\\1/" _VCPKG_PACKAGES_DIR "${CURRENT_PACKAGES_DIR}")
string(REGEX REPLACE "([a-zA-Z]):/" "/\\1/" _VCPKG_INSTALLED_DIR "${CURRENT_INSTALLED_DIR}")
message(STATUS "Fixing pkgconfig - release")
debug_message("Files: ${_vfpkg_RELEASE_FILES}")
foreach(_file ${_vfpkg_RELEASE_FILES})
message(STATUS "Checking file: ${_file}")
get_filename_component(PKG_LIB_SEARCH_PATH "${_file}" DIRECTORY)
file(RELATIVE_PATH RELATIVE_PC_PATH "${PKG_LIB_SEARCH_PATH}" "${CURRENT_PACKAGES_DIR}")
string(REGEX REPLACE "/$" "" RELATIVE_PC_PATH "${RELATIVE_PC_PATH}")
string(REGEX REPLACE "/pkgconfig/?" "" PKG_LIB_SEARCH_PATH "${PKG_LIB_SEARCH_PATH}")
file(READ "${_file}" _contents)
string(REPLACE "${CURRENT_PACKAGES_DIR}" "\${prefix}" _contents "${_contents}")
string(REPLACE "${CURRENT_INSTALLED_DIR}" "\${prefix}" _contents "${_contents}")
string(REPLACE "${_VCPKG_PACKAGES_DIR}" "\${prefix}" _contents "${_contents}")
string(REPLACE "${_VCPKG_INSTALLED_DIR}" "\${prefix}" _contents "${_contents}")
string(REGEX REPLACE "^prefix=(\\\\)?\\\${prefix}" "prefix=\${pcfiledir}/${RELATIVE_PC_PATH}" _contents "${_contents}") # make pc file relocatable
vcpkg_fixup_pkgconfig_check_libraries("RELEASE" _contents "${_vfpkg_SYSTEM_LIBRARIES}" "${_vfpkg_SYSTEM_PACKAGES}" "${_vfpkg_IGNORE_FLAGS}")
file(WRITE "${_file}" "${_contents}")
unset(PKG_LIB_SEARCH_PATH)
endforeach()
message(STATUS "Fixing pkgconfig - debug")
debug_message("Files: ${_vfpkg_DEBUG_FILES}")
foreach(_file ${_vfpkg_DEBUG_FILES})
message(STATUS "Checking file: ${_file}")
get_filename_component(PKG_LIB_SEARCH_PATH "${_file}" DIRECTORY)
file(RELATIVE_PATH RELATIVE_PC_PATH "${PKG_LIB_SEARCH_PATH}" "${CURRENT_PACKAGES_DIR}/debug/")
string(REGEX REPLACE "/$" "" RELATIVE_PC_PATH "${RELATIVE_PC_PATH}")
string(REGEX REPLACE "/pkgconfig/?" "" PKG_LIB_SEARCH_PATH "${PKG_LIB_SEARCH_PATH}")
file(READ "${_file}" _contents)
string(REPLACE "${CURRENT_PACKAGES_DIR}" "\${prefix}" _contents "${_contents}")
string(REPLACE "${CURRENT_INSTALLED_DIR}" "\${prefix}" _contents "${_contents}")
string(REPLACE "${_VCPKG_PACKAGES_DIR}" "\${prefix}" _contents "${_contents}")
string(REPLACE "${_VCPKG_INSTALLED_DIR}" "\${prefix}" _contents "${_contents}")
string(REPLACE "debug/include" "../include" _contents "${_contents}")
string(REPLACE "\${prefix}/include" "\${prefix}/../include" _contents "${_contents}")
string(REPLACE "debug/share" "../share" _contents "${_contents}")
string(REPLACE "\${prefix}/share" "\${prefix}/../share" _contents "${_contents}")
string(REPLACE "debug/lib" "lib" _contents "${_contents}") # the prefix will contain the debug keyword
string(REGEX REPLACE "^prefix=(\\\\)?\\\${prefix}(/debug)?" "prefix=\${pcfiledir}/${RELATIVE_PC_PATH}" _contents "${_contents}") # make pc file relocatable
string(REPLACE "\${prefix}/debug" "\${prefix}" _contents "${_contents}") # replace remaining debug paths if they exist.
vcpkg_fixup_pkgconfig_check_libraries("DEBUG" _contents "${_vfpkg_SYSTEM_LIBRARIES}" "${_vfpkg_SYSTEM_PACKAGES}" "${_vfpkg_IGNORE_FLAGS}")
file(WRITE "${_file}" "${_contents}")
unset(PKG_LIB_SEARCH_PATH)
endforeach()
message(STATUS "Fixing pkgconfig --- finished")
set(VCPKG_FIXUP_PKGCONFIG_CALLED TRUE CACHE INTERNAL "See below" FORCE)
# Variable to check if this function has been called!
# Theoreotically vcpkg could look for *.pc files and automatically call this function
# or check if this function has been called if *.pc files are detected.
# The same is true for vcpkg_fixup_cmake_targets
endfunction()
# script to test the function locally without running vcpkg. Uncomment fix filepaths and use cmake -P vcpkg_fixup_pkgconfig
# set(_file "G:\\xlinux\\packages\\xlib_x64-windows\\lib\\pkgconfig\\x11.pc")
# include(${CMAKE_CURRENT_LIST_DIR}/vcpkg_common_definitions.cmake)
# file(READ "${_file}" _contents)
# set(CURRENT_INSTALLED_DIR "G:/xlinux/installed/x64-windows")
# set(CURRENT_PACKAGES_DIR "G:/xlinux/packages/xlib_x64-windows")
# set(_vfpkg_SYSTEM_LIBRARIES "blu\\ ub")
# set(_vfpkg_SYSTEM_PACKAGES "szip")
# vcpkg_fixup_pkgconfig_check_libraries("RELEASE" _contents "${_vfpkg_SYSTEM_LIBRARIES}" "${_vfpkg_SYSTEM_PACKAGES}")
Reference in New Issue View Git Blame Copy Permalink