[lapack-reference|fortran] trying out fortran (just testing)

ports/clapack/portfile.cmake

@@ -11,7 +11,7 @@ vcpkg_extract_source_archive_ex(
   ARCHIVE ${ARCHIVE}
   PATCHES
       remove_internal_blas.patch
-	  fix-ConfigFile.patch
+      fix-ConfigFile.patch
       fix-install.patch
       support-uwp.patch
 )
@@ -37,10 +37,6 @@ vcpkg_copy_pdbs()
 #TODO: fix the official exported targets, since they are broken (luckily it seems that no-one uses them for now)
 vcpkg_fixup_cmake_targets(CONFIG_PATH share/clapack)
 
-#we install a cmake wrapper since the official FindLAPACK module in cmake does find clapack easily, unfortunately...
-file(INSTALL ${CMAKE_CURRENT_LIST_DIR}/vcpkg-cmake-wrapper.cmake DESTINATION ${CURRENT_PACKAGES_DIR}/share/lapack)
-file(INSTALL ${CMAKE_CURRENT_LIST_DIR}/FindLAPACK.cmake DESTINATION ${CURRENT_PACKAGES_DIR}/share/lapack)
-
 file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/debug/include)
 
 # Handle copyright

ports/lapack-reference/CONTROL

@@ -0,0 +1,12 @@
+Source: lapack-reference
+Version: 3.8.0
+Description: LAPACK — Linear Algebra PACKage http://www.netlib.org/lapack/
+Default-Features: noblas
+Build-Depends: vcpkg-gfortran (windows)
+
+Feature: cblas
+Description: Builds CBLAS
+
+Feature: noblas
+Build-Depends: openblas (!osx)
+Description: Use external optimized BLAS

ports/lapack-reference/portfile.cmake

@@ -0,0 +1,67 @@
+#TODO: Features to add:
+# USE_XBLAS??? extended precision blas. needs xblas
+# LAPACKE should be its own PORT
+# USE_OPTIMIZED_LAPACK (Probably not what we want. Does a find_package(LAPACK): probably for LAPACKE only builds _> own port?)
+# LAPACKE Builds LAPACKE
+# LAPACKE_WITH_TMG Build LAPACKE with tmglib routines
+
+SET(VCPKG_POLICY_EMPTY_INCLUDE_FOLDER enabled)
+
+if(CMAKE_HOST_WIN32 AND NOT VCPKG_USE_EXTERNAL_Fortran)
+    # Since we use MinGW Fortran here and would require ld otherwise for all dependent ports
+    set(VCPKG_CRT_LINKAGE dynamic) # Will always be dynamic no way to overwrite internal CRT linkage here
+    vcpkg_check_linkage(ONLY_DYNAMIC_LIBRARY)
+    #set(VCPKG_CRT_LINKAGE dynamic)
+endif()
+
+set(lapack_ver 3.8.0)
+
+vcpkg_from_github(
+    OUT_SOURCE_PATH SOURCE_PATH
+    REPO  "Reference-LAPACK/lapack"
+    REF "v${lapack_ver}"
+    SHA512 17786cb7306fccdc9b4a242de7f64fc261ebe6a10b6ec55f519deb4cb673cb137e8742aa5698fd2dc52f1cd56d3bd116af3f593a01dcf6770c4dcc86c50b2a7f
+    HEAD_REF master
+)
+
+set(USE_OPTIMIZED_BLAS OFF)
+if("noblas" IN_LIST FEATURES)
+    set(USE_OPTIMIZED_BLAS ON)
+endif()
+
+set(CBLAS OFF)
+if("cblas" IN_LIST FEATURES)
+    set(CBLAS ON)
+endif()
+vcpkg_find_fortran(FORTRAN_CMAKE)
+vcpkg_configure_cmake(
+        PREFER_NINJA
+        SOURCE_PATH ${SOURCE_PATH}
+        OPTIONS
+            "-DUSE_OPTIMIZED_BLAS=${USE_OPTIMIZED_BLAS}"
+            "-DCBLAS=${CBLAS}"
+            "${FORTRAN_CMAKE}"
+        )
+
+vcpkg_install_cmake()
+vcpkg_fixup_cmake_targets(CONFIG_PATH lib/cmake/lapack-${lapack_ver}) #Should the target path be lapack and not lapack-reference?
+vcpkg_fixup_pkgconfig()
+vcpkg_copy_pdbs()
+
+# Handle copyright
+file(INSTALL "${SOURCE_PATH}/LICENSE" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}" RENAME copyright)
+
+# remove debug includs
+file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/debug/include)
+
+if(VCPKG_TARGET_IS_WINDOWS)
+    if(EXISTS "${CURRENT_PACKAGES_DIR}/lib/liblapack.lib")
+        file(RENAME "${CURRENT_PACKAGES_DIR}/lib/liblapack.lib" "${CURRENT_PACKAGES_DIR}/lib/lapack.lib")
+    endif()
+    if(EXISTS "${CURRENT_PACKAGES_DIR}/debug/lib/liblapack.lib")
+        file(RENAME "${CURRENT_PACKAGES_DIR}/debug/lib/liblapack.lib" "${CURRENT_PACKAGES_DIR}/debug/lib/lapack.lib")
+    endif()
+endif()
+
+#SET(VCPKG_POLICY_DLLS_WITHOUT_LIBS enabled)
+set(VCPKG_POLICY_SKIP_DUMPBIN_CHECKS enabled)

ports/lapack/CONTROL

@@ -1,4 +1,4 @@
 Source: lapack
-Version: 0
+Version: 1
 Description: Metapackage for packages which provide LAPACK
-Build-Depends: clapack (!osx)
+Build-Depends: clapack (arm|uwp), lapack-reference(!uwp&!arm)

ports/lapack/portfile.cmake

@@ -1,3 +1,10 @@
 SET(VCPKG_POLICY_EMPTY_PACKAGE enabled)
 # Make sure LAPACK can be found
-vcpkg_configure_cmake(SOURCE_PATH ${CURRENT_PORT_DIR})
+
+if(VCPKG_TARGET_IS_UWP OR VCPKG_TARGET_IS_WINDOWS AND VCPKG_TARGET_ARCHITECTURE MATCHES "arm")
+    # Install clapack wrappers. 
+    file(INSTALL ${CMAKE_CURRENT_LIST_DIR}/clapack/vcpkg-cmake-wrapper.cmake DESTINATION ${CURRENT_PACKAGES_DIR}/share/lapack)
+    file(INSTALL ${CMAKE_CURRENT_LIST_DIR}/clapack/FindLAPACK.cmake DESTINATION ${CURRENT_PACKAGES_DIR}/share/lapack)
+endif()
+vcpkg_configure_cmake(SOURCE_PATH ${CURRENT_PORT_DIR}
+                      OPTIONS -DCMAKE_PREFIX_PATH="${CURRENT_PACKAGES_DIR}")

ports/openblas/CONTROL

@@ -1,5 +1,6 @@
 Source: openblas
-Version: 0.3.9-1
+Version: 0.3.9
+Port-Version: 2
 Homepage: https://github.com/xianyi/OpenBLAS
 Build-Depends: pthread (linux)
 Description: OpenBLAS is an optimized BLAS library based on GotoBLAS2 1.13 BSD version.

ports/openblas/portfile.cmake

@@ -1,5 +1,3 @@
-include(vcpkg_common_functions)
-
 vcpkg_from_github(
     OUT_SOURCE_PATH SOURCE_PATH
     REPO xianyi/OpenBLAS
@@ -22,7 +20,9 @@ set(SED_EXE_PATH "${GIT_EXE_PATH}/../usr/bin")
 # openblas require perl to generate .def for exports
 vcpkg_find_acquire_program(PERL)
 get_filename_component(PERL_EXE_PATH ${PERL} DIRECTORY)
-set(ENV{PATH} "$ENV{PATH};${PERL_EXE_PATH};${SED_EXE_PATH}")
+set(PATH_BACKUP "$ENV{PATH}")
+vcpkg_add_to_path("${PERL_EXE_PATH}")
+vcpkg_add_to_path("${SED_EXE_PATH}")
 
 set(COMMON_OPTIONS -DBUILD_WITHOUT_LAPACK=ON)
 
@@ -46,7 +46,7 @@ if(VCPKG_CMAKE_SYSTEM_NAME  STREQUAL "WindowsStore")
 
     # add just built path to environment for gen_config_h.exe,
     # getarch.exe and getarch_2nd.exe
-    set(ENV{PATH} "$ENV{PATH};${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
+    vcpkg_add_to_path("${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
 
     # restore target build information
     set(VCPKG_CMAKE_SYSTEM_NAME "${TEMP_CMAKE_SYSTEM_NAME}")
@@ -85,6 +85,23 @@ endif()
 
 vcpkg_install_cmake()
 vcpkg_fixup_cmake_targets(CONFIG_PATH share/cmake/OpenBLAS TARGET_PATH share/openblas)
+set(ENV{PATH} "${PATH_BACKUP}")
+
+set(pcfile "${CURRENT_PACKAGES_DIR}/lib/pkgconfig/openblas.pc")
+if(EXISTS "${pcfile}")
+    file(READ "${pcfile}" _contents)
+    set(_contents "prefix=${CURRENT_INSTALLED_DIR}\n${_contents}")
+    file(WRITE "${pcfile}" "${_contents}")
+    file(CREATE_LINK "${pcfile}" "${CURRENT_PACKAGES_DIR}/lib/pkgconfig/blas.pc" COPY_ON_ERROR)
+endif()
+set(pcfile "${CURRENT_PACKAGES_DIR}/debug/lib/pkgconfig/openblas.pc")
+if(EXISTS "${pcfile}")
+    file(READ "${pcfile}" _contents)
+    set(_contents "prefix=${CURRENT_INSTALLED_DIR}/debug\n${_contents}")
+    file(WRITE "${pcfile}" "${_contents}")
+    file(CREATE_LINK "${pcfile}" "${CURRENT_PACKAGES_DIR}/debug/lib/pkgconfig/blas.pc" COPY_ON_ERROR)
+endif()
+vcpkg_fixup_pkgconfig()
 #maybe we need also to write a wrapper inside share/blas to search implicitly for openblas, whenever we feel it's ready for its own -config.cmake file
 
 # openblas do not make the config file , so I manually made this

ports/vcpkg-gfortran/CONTROL

@@ -0,0 +1,4 @@
+Source: vcpkg-gfortran
+Version: 1
+Description: Metaport to install gfortran dependencies from msys if VCPKG_USE_EXTERNAL_Fortran is false
+Supports: windows & !arm

ports/vcpkg-gfortran/portfile.cmake

@@ -0,0 +1,52 @@
+
+vcpkg_find_fortran(FORTRAN_CMAKE)
+if(VCPKG_USE_INTERNAL_Fortran)
+    set(VCPKG_CRT_LINKAGE dynamic) # Will always be dynamic no way to overwrite internal CRT linkage here
+    vcpkg_check_linkage(ONLY_DYNAMIC_LIBRARY)
+    if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
+        set(HOST_ARCH $ENV{PROCESSOR_ARCHITEW6432})
+    else()
+        set(HOST_ARCH $ENV{PROCESSOR_ARCHITECTURE})
+    endif()
+
+    if(HOST_ARCH MATCHES "(amd|AMD)64")
+        set(MINGW_W w64)
+        set(MSYS_HOST x86_64)
+    elseif(HOST_ARCH MATCHES "(x|X)86")
+        set(MINGW_W w32)
+        set(MSYS_HOST i686)
+    else()
+        message(FATAL_ERROR "Unsupported host architecture ${HOST_ARCH}!" )
+    endif()
+
+    if(VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)64")
+        set(MSYS_TARGET x86_64)
+        set(MINGW_W_TARGET 64)
+        set(GCC_LIB_SUFFIX s_seh-1)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)86")
+        set(MSYS_TARGET i686)
+        set(MINGW_W_TARGET 32)
+        set(GCC_LIB_SUFFIX s_dw2-1)
+    else()
+        message(FATAL_ERROR "Unsupported target architecture ${VCPKG_TARGET_ARCHITECTURE}!" )
+    endif()
+
+
+    vcpkg_acquire_msys(MSYS_ROOT PACKAGES "mingw-w64-${MSYS_TARGET}-gcc-fortran") # TODO: make x86 work
+
+    set(MINGW_BIN "${MSYS_ROOT}/mingw${MINGW_W_TARGET}/bin/")
+    set(MINGW_Fortran_DLLS "${MINGW_BIN}/libgfortran-5.dll"
+                           "${MINGW_BIN}/libquadmath-0.dll"
+                           "${MINGW_BIN}/libwinpthread-1.dll"
+                           "${MINGW_BIN}/libgcc_${GCC_LIB_SUFFIX}.dll")
+    file(INSTALL ${MINGW_Fortran_DLLS} DESTINATION "${CURRENT_PACKAGES_DIR}/bin")
+    file(INSTALL ${MINGW_Fortran_DLLS} DESTINATION "${CURRENT_PACKAGES_DIR}/debug/bin")
+    set(VCPKG_POLICY_SKIP_DUMPBIN_CHECKS enabled) # due to outdated msvcrt
+    set(VCPKG_POLICY_DLLS_WITHOUT_LIBS enabled)
+    set(VCPKG_POLICY_EMPTY_INCLUDE_FOLDER enabled)
+    file(INSTALL "${MSYS_ROOT}/mingw${MINGW_W_TARGET}/share/licenses/winpthreads" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}/license")
+    file(INSTALL "${MSYS_ROOT}/mingw${MINGW_W_TARGET}/share/licenses/gcc-libs" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}/license")
+    file(INSTALL "${MSYS_ROOT}/mingw${MINGW_W_TARGET}/share/licenses/crt/COPYING.MinGW-w64-runtime.txt" DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}" RENAME copyright)
+else()
+    set(VCPKG_POLICY_EMPTY_PACKAGE enabled)
+endif()

scripts/cmake/vcpkg_common_functions.cmake

@@ -45,6 +45,7 @@ include(vcpkg_copy_tools)
 include(vcpkg_get_program_files_platform_bitness)
 include(vcpkg_get_windows_sdk)
 include(vcpkg_replace_string)
+include(vcpkg_find_fortran)
 include(vcpkg_from_git)
 include(vcpkg_test_cmake)
 include(vcpkg_prettify_command)

scripts/cmake/vcpkg_find_fortran.cmake

@@ -0,0 +1,56 @@
+## # vcpkg_find_fortran
+##
+## Checks if a Fortran compiler can be found.
+## Windows(x86/x64) Only: If not it will switch/enable MinGW gfortran 
+##                        and return required cmake args for building. 
+##
+## ## Usage
+## ```cmake
+## vcpkg_find_fortran(<additional_cmake_args_out>
+## )
+## ```
+
+function(vcpkg_find_fortran additional_cmake_args_out)
+    set(ARGS_OUT)
+    include(CMakeDetermineFortranCompiler)
+    if(NOT CMAKE_Fortran_COMPILER AND NOT VCPKG_CHAINLOAD_TOOLCHAIN_FILE)
+    # This intentionally breaks users with a custom toolchain which do not have a Fortran compiler setup
+    # because they either need to use a port-overlay (for e.g. lapack), remove the toolchain for the port using fortran
+    # or setup fortran in their VCPKG_CHAINLOAD_TOOLCHAIN_FILE themselfs!
+        if(WIN32)
+            message(STATUS "No Fortran compiler found on the PATH. Using MinGW gfortran!")
+            # If no Fortran compiler is on the path we switch to use gfortan from MinGW within vcpkg
+            set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/mingw.cmake") # Switching to mingw toolchain
+            if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
+                set(MINGW_PATH mingw32)
+                set(MSYS_TARGET i686)
+                set(MACHINE_FLAG -m32)
+            elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
+                set(MINGW_PATH mingw64)
+                set(MSYS_TARGET x86_64)
+                set(MACHINE_FLAG -m64)
+            else()
+                message(FATAL_ERROR "Unknown architecture '${VCPKG_TARGET_ARCHITECTURE}' for MinGW Fortran build!")
+            endif()
+            vcpkg_acquire_msys(MSYS_ROOT "mingw-w64-${MSYS_TARGET}-gcc-fortran")
+            set(MINGW_BIN "${MSYS_ROOT}/${MINGW_PATH}/bin")
+            vcpkg_add_to_path("${MINGW_BIN}")
+            set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/mingw.cmake") # Switching to MinGW toolchain for Fortran
+            list(APPEND ARGS_OUT -DCMAKE_GNUtoMS=ON
+                                 "-DCMAKE_Fortran_COMPILER=${MINGW_BIN}/gfortran.exe"
+                                 "-DCMAKE_Fortran_FLAGS_INIT:STRING= -mabi=ms ${MACHINE_FLAG} ${VCPKG_Fortran_FLAGS}")
+            set(VCPKG_USE_INTERNAL_Fortran TRUE PARENT_SCOPE)
+            if(VCPKG_CRT_LINKAGE STREQUAL "static")
+                set(VCPKG_CRT_LINKAGE dynamic)
+                message(STATUS "VCPKG_CRT_LINKAGE linkage for ${PORT} using vcpkg's internal gfortran cannot be static due to linking against MinGW libraries. Forcing dynamic CRT linkage")
+            endif()
+            if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
+                set(VCPKG_LIBRARY_LINKAGE dynamic)
+                message(STATUS "VCPKG_LIBRARY_LINKAGE linkage for ${PORT} using vcpkg's internal gfortran cannot be static due to linking against MinGW libraries. Forcing dynamic library linkage")
+            endif()
+        else()
+            message(FATAL_ERROR "Unable to find a Fortran compiler using 'CMakeDetermineFortranCompiler'. Please install one (e.g. gfortran) and make it available on the PATH!")
+        endif()
+    endif()
+    set(${additional_cmake_args_out} ${ARGS_OUT} PARENT_SCOPE)
+endfunction()