DISTRHO
/
PawPaw
mirror of https://github.com/DISTRHO/PawPaw
1
0
Fork 0
Code Issues 0 Releases 2 Wiki Activity
Cross-Platform build scripts for audio plugins
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
755 Commits
3 Branches
4.3MB
Tree: 66336ddebc
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '66336ddebc'
${ noResults }
PawPaw/setup/functions.sh

938 lines
29KB
Raw Blame History 

  1. #!/bin/bash

  2. 

  3. # NOTE `setup/check_target.sh` and `setup/env.sh` must be imported before this one, in that order

  4. 

  5. # ---------------------------------------------------------------------------------------------------------------------

  6. 

  7. function download() {

  8.     local pkgname="${1}"

  9.     local version="${2}"

  10.     local dlbaseurl="${3}"

  11.     local dlext="${4}"

  12.     local dlmethod="${5}"

  13.     local dlname="${6}"

  14. 

  15.     if [ -z "${dlext}" ]; then

  16.         dlext="tar.gz"

  17.     fi

  18.     if [ -z "${dlname}" ]; then

  19.         dlname="${pkgname}"

  20.     fi

  21. 

  22.     local dlfile="${PAWPAW_DOWNLOADDIR}/${dlname}-${version}.${dlext}"

  23.     local dlfolder="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  24. 

  25.     if [ ! -f "${dlfile}" ]; then

  26.         if [ -n "${dlmethod}" ] && [ "${dlmethod}" = "git" ]; then

  27.             local tmprepodir="${PAWPAW_TMPDIR}/${dlname}-${version}"

  28.             rm -rf "${tmprepodir}"

  29.             git clone --recursive "${dlbaseurl}" "${tmprepodir}"

  30.             git -C "${tmprepodir}" checkout "${version}"

  31.             git -C "${tmprepodir}" submodule update --recursive --init

  32.             tar --exclude=".git" -czf "${dlfile}" -C "${PAWPAW_TMPDIR}" "${dlname}-${version}"

  33.             rm -rf "${tmprepodir}"

  34.         else

  35.             local dlurl1

  36.             local dlurl2

  37.             if echo ${dlbaseurl} | grep -q github.com | grep -q -v releases; then

  38.                 if [ x"${dlmethod}" = x"nv" ]; then

  39.                     dlurl1="${dlbaseurl}/${version}.${dlext}"

  40.                     dlurl2="${KXSTUDIO_FILES_URL}/${version}.${dlext}"

  41.                 else

  42.                     dlurl1="${dlbaseurl}/v${version}.${dlext}"

  43.                     dlurl2="${KXSTUDIO_FILES_URL}/v${version}.${dlext}"

  44.                 fi

  45.             elif [ "${dlext}" = "orig.tar.gz" ]; then

  46.                 dlurl1="${dlbaseurl}/${dlname}_${version}.${dlext}"

  47.                 dlurl2="${KXSTUDIO_FILES_URL}/${dlname}_${version}.${dlext}"

  48.             else

  49.                 dlurl1="${dlbaseurl}/${dlname}-${version}.${dlext}"

  50.                 dlurl2="${KXSTUDIO_FILES_URL}/${dlname}-${version}.${dlext}"

  51.             fi

  52.             curl -L "${dlurl1}" -o "${dlfile}" --fail || curl -L "${dlurl2}" -o "${dlfile}" --fail

  53.         fi

  54.     fi

  55. 

  56.     if [ ! -d "${dlfolder}" ]; then

  57.         mkdir "${dlfolder}"

  58.         tar -xf "${dlfile}" -C "${dlfolder}" --strip-components=1

  59.     fi

  60. }

  61. 

  62. function copy_download() {

  63.     local pkgname1="${1}"

  64.     local pkgname2="${2}"

  65.     local version="${3}"

  66.     local dlext="${4}"

  67. 

  68.     if [ -z "${dlext}" ]; then

  69.         dlext="tar.gz"

  70.     fi

  71. 

  72.     local dlfile1="${PAWPAW_DOWNLOADDIR}/${pkgname1}-${version}.${dlext}"

  73.     local dlfolder2="${PAWPAW_BUILDDIR}/${pkgname2}-${version}"

  74. 

  75.     if [ ! -d "${dlfolder2}" ]; then

  76.         mkdir "${dlfolder2}"

  77.         tar -xf "${dlfile1}" -C "${dlfolder2}" --strip-components=1

  78.     fi

  79. }

  80. 

  81. function git_clone() {

  82.     local pkgname="${1}"

  83.     local hash="${2}"

  84.     local repourl="${3}"

  85.     local dlname="${4}"

  86. 

  87.     if [ -z "${dlname}" ]; then

  88.         dlname="${pkgname}"

  89.     fi

  90. 

  91.     local dlfile="${PAWPAW_DOWNLOADDIR}/${dlname}-${hash}.tar.gz"

  92.     local dlfolder="${PAWPAW_BUILDDIR}/${pkgname}-${hash}"

  93. 

  94.     if [ ! -f "${dlfile}" ]; then

  95.         local tmprepodir="${PAWPAW_TMPDIR}/${dlname}-${hash}"

  96.         rm -rf "${tmprepodir}"

  97.         git clone --recursive "${repourl}" "${tmprepodir}"

  98.         git -C "${tmprepodir}" checkout "${hash}"

  99.         git -C "${tmprepodir}" submodule update --recursive --init

  100.         tar --exclude=".git" -czf "${dlfile}" -C "${PAWPAW_TMPDIR}" "${dlname}-${hash}"

  101.         rm -rf "${tmprepodir}"

  102.     fi

  103. 

  104.     if [ ! -d "${dlfolder}" ]; then

  105.         mkdir "${dlfolder}"

  106.         tar -xf "${dlfile}" -C "${dlfolder}" --strip-components=1

  107.     fi

  108. }

  109. 

  110. # ---------------------------------------------------------------------------------------------------------------------

  111. 

  112. function _prebuild() {

  113.     local pkgname="${1}"

  114.     local pkgdir="${2}"

  115. 

  116.     export AR="${TARGET_AR}"

  117.     export CC="${TARGET_CC}"

  118.     export CXX="${TARGET_CXX}"

  119.     export DLLWRAP="${TARGET_DLLWRAP}"

  120.     export LD="${TARGET_LD}"

  121.     export NM="${TARGET_NM}"

  122.     export RANLIB="${TARGET_RANLIB}"

  123.     export STRIP="${TARGET_STRIP}"

  124.     export WINDRES="${TARGET_WINDRES}"

  125. 

  126.     export CFLAGS="${TARGET_CFLAGS} ${EXTRA_CFLAGS}"

  127.     export CXXFLAGS="${TARGET_CXXFLAGS} ${EXTRA_CXXFLAGS}"

  128.     export LDFLAGS="${TARGET_LDFLAGS} ${EXTRA_LDFLAGS}"

  129.     export PKG_CONFIG_PATH="${TARGET_PKG_CONFIG_PATH}"

  130. 

  131.     if [ -n "${EXTRA_CPPFLAGS}" ]; then

  132.         export CPPFLAGS="${EXTRA_CPPFLAGS}"

  133.     else

  134.         unset CPPFLAGS

  135.     fi

  136. 

  137.     export OLD_PATH="${PATH}"

  138.     export PATH="${TARGET_PATH}"

  139. 

  140.     if [ -e "${PAWPAW_ROOT}/patches/${pkgname}" ] && [ ! -f "${pkgdir}/.stamp_cleanup" ] && [ ! -f "${pkgdir}/.stamp_configured" ]; then

  141.         local patchtargets="${PAWPAW_TARGET}"

  142.         if [[ "${PAWPAW_TARGET}" = "linux-"* ]]; then

  143.             patchtargets+=" linux"

  144.         elif [ "${PAWPAW_TARGET}" = "macos-universal-10.15" ]; then

  145.             patchtargets+=" macos-10.15 macos-universal"

  146.         elif [ "${PAWPAW_TARGET}" = "win64" ]; then

  147.             patchtargets+=" win32"

  148.         fi

  149. 

  150.         for target in ${patchtargets[@]}; do

  151.             if [ -e "${PAWPAW_ROOT}/patches/${pkgname}/${target}" ]; then

  152.                 for p in $(ls "${PAWPAW_ROOT}/patches/${pkgname}/${target}/" | grep "\.patch$" | sort); do

  153.                     if [ ! -f "${pkgdir}/.stamp_applied_${p}" ]; then

  154.                         patch -p1 -d "${pkgdir}" -i "${PAWPAW_ROOT}/patches/${pkgname}/${target}/${p}"

  155.                         touch "${pkgdir}/.stamp_applied_${p}"

  156.                     fi

  157.                 done

  158.             fi

  159.         done

  160. 

  161.         for p in $(ls "${PAWPAW_ROOT}/patches/${pkgname}/" | grep "\.patch$" | sort); do

  162.             if [ ! -f "${pkgdir}/.stamp_applied_${p}" ]; then

  163.                 patch -p1 -d "${pkgdir}" -i "${PAWPAW_ROOT}/patches/${pkgname}/${p}"

  164.                 touch "${pkgdir}/.stamp_applied_${p}"

  165.             fi

  166.         done

  167.     fi

  168. 

  169.     if [ ! -f "${pkgdir}/.stamp_configured" ]; then

  170.         rm -f "${pkgdir}/.stamp_built"

  171.         rm -f "${pkgdir}/.stamp_installed"

  172.         rm -f "${pkgdir}/.stamp_verified"

  173.         rm -f "${pkgdir}/CMakeCache.txt"

  174. 

  175.     elif [ ! -f "${pkgdir}/.stamp_built" ]; then

  176.         rm -f "${pkgdir}/.stamp_installed"

  177.         rm -f "${pkgdir}/.stamp_verified"

  178. 

  179.     elif [ ! -f "${pkgdir}/.stamp_installed" ]; then

  180.         rm -f "${pkgdir}/.stamp_verified"

  181. 

  182.     fi

  183. }

  184. 

  185. function _postbuild() {

  186.     unset AR

  187.     unset CC

  188.     unset CXX

  189.     unset DLLWRAP

  190.     unset LD

  191.     unset NM

  192.     unset RANLIB

  193.     unset STRIP

  194.     unset WINDRES

  195. 

  196.     unset CFLAGS

  197.     unset CPPFLAGS

  198.     unset CXXFLAGS

  199.     unset LDFLAGS

  200.     unset PKG_CONFIG_PATH

  201. 

  202.     unset EXTRA_CFLAGS

  203.     unset EXTRA_CPPFLAGS

  204.     unset EXTRA_CXXFLAGS

  205.     unset EXTRA_LDFLAGS

  206.     unset EXTRA_MAKE_ARGS

  207. 

  208.     export PATH="${OLD_PATH}"

  209. }

  210. 

  211. # ---------------------------------------------------------------------------------------------------------------------

  212. 

  213. function build_autoconf() {

  214.     local pkgname="${1}"

  215.     local version="${2}"

  216.     local extraconfrules="${3}"

  217. 

  218.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  219. 

  220.     if [ "${WASM}" -eq 1 ]; then

  221.         extraconfrules+=" --host=$(uname -m)-linux-gnu"

  222.     elif [ -n "${TOOLCHAIN_PREFIX}" ]; then

  223.         extraconfrules+=" --host=${TOOLCHAIN_PREFIX} ac_cv_build=$(uname -m)-linux-gnu ac_cv_host=${TOOLCHAIN_PREFIX}"

  224.     fi

  225. 

  226.     if [ -n "${PAWPAW_DEBUG}" ] && [ "${PAWPAW_DEBUG}" -eq 1 ]; then

  227.         extraconfrules+=" --enable-debug"

  228.     else

  229.         extraconfrules+=" --disable-debug"

  230.     fi

  231. 

  232.     _prebuild "${pkgname}" "${pkgdir}"

  233. 

  234.     if [ ! -f "${pkgdir}/.stamp_configured" ]; then

  235.         pushd "${pkgdir}"

  236.         ./configure --enable-static --disable-shared --disable-doc --disable-docs --disable-maintainer-mode --prefix="${PAWPAW_PREFIX}" ${extraconfrules}

  237.         touch .stamp_configured

  238.         popd

  239.     fi

  240. 

  241.     if [ ! -f "${pkgdir}/.stamp_built" ]; then

  242.         pushd "${pkgdir}"

  243.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  244.         touch .stamp_built

  245.         popd

  246.     fi

  247. 

  248.     if [ ! -f "${pkgdir}/.stamp_installed" ]; then

  249.         pushd "${pkgdir}"

  250.         make ${MAKE_ARGS} install -j 1

  251.         touch .stamp_installed

  252.         popd

  253.     fi

  254. 

  255.     _postbuild

  256. }

  257. 

  258. function build_autoconfgen() {

  259.     local pkgname="${1}"

  260.     local version="${2}"

  261.     local extraconfrules="${3}"

  262. 

  263.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  264. 

  265.     local EXTRA_CFLAGS2="${EXTRA_CFLAGS}"

  266.     local EXTRA_CXXFLAGS2="${EXTRA_CXXFLAGS}"

  267.     local EXTRA_LDFLAGS2="${EXTRA_LDFLAGS}"

  268.     local EXTRA_MAKE_ARGS2="${EXTRA_MAKE_ARGS}"

  269. 

  270.     _prebuild "${pkgname}" "${pkgdir}"

  271. 

  272.     if [ ! -f "${pkgdir}/.stamp_preconfigured" ]; then

  273.         pushd "${pkgdir}"

  274.         if [ -f utils/autogen.sh ]; then

  275.             ./utils/autogen.sh

  276.         else

  277.             ${autoconf}

  278.         fi

  279.         touch .stamp_preconfigured

  280.         popd

  281.     fi

  282. 

  283.     _postbuild

  284. 

  285.     export EXTRA_CFLAGS="${EXTRA_CFLAGS2}"

  286.     export EXTRA_CXXFLAGS="${EXTRA_CXXFLAGS2}"

  287.     export EXTRA_LDFLAGS="${EXTRA_LDFLAGS2}"

  288.     export EXTRA_MAKE_ARGS="${EXTRA_MAKE_ARGS2}"

  289. 

  290.     build_autoconf "${pkgname}" "${version}" "${extraconfrules}"

  291. }

  292. 

  293. function build_conf() {

  294.     local pkgname="${1}"

  295.     local version="${2}"

  296.     local extraconfrules="${3}"

  297. 

  298.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  299. 

  300.     _prebuild "${pkgname}" "${pkgdir}"

  301. 

  302.     if [ ! -f "${pkgdir}/.stamp_configured" ]; then

  303.         pushd "${pkgdir}"

  304.         ./configure ${extraconfrules}

  305.         touch .stamp_configured

  306.         popd

  307.     fi

  308. 

  309.     if [ ! -f "${pkgdir}/.stamp_built" ]; then

  310.         pushd "${pkgdir}"

  311.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  312.         touch .stamp_built

  313.         popd

  314.     fi

  315. 

  316.     if [ ! -f "${pkgdir}/.stamp_installed" ]; then

  317.         pushd "${pkgdir}"

  318.         make ${MAKE_ARGS} -j 1 install

  319.         touch .stamp_installed

  320.         popd

  321.     fi

  322. 

  323.     _postbuild

  324. }

  325. 

  326. function build_cmake() {

  327.     local pkgname="${1}"

  328.     local version="${2}"

  329.     local extraconfrules="${3}"

  330. 

  331.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  332. 

  333.     _prebuild "${pkgname}" "${pkgdir}"

  334.     mkdir -p "${pkgdir}/build"

  335. 

  336.     if [ "${WASM}" -eq 1 ]; then

  337.         CMAKE_EXE_WRAPPER="emcmake"

  338.     elif [ "${CROSS_COMPILING}" -eq 1 ]; then

  339.         local CMAKE_AR=$(which ${TARGET_AR})

  340.         local CMAKE_RANLIB=$(which ${TARGET_RANLIB})

  341.         extraconfrules+=" -DCMAKE_CROSSCOMPILING=ON"

  342.         extraconfrules+=" -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}"

  343.         extraconfrules+=" -DCMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}"

  344.         extraconfrules+=" -DCMAKE_AR=${CMAKE_AR}"

  345.         extraconfrules+=" -DCMAKE_C_COMPILER_AR=${CMAKE_AR}"

  346.         extraconfrules+=" -DCMAKE_CXX_COMPILER_AR=${CMAKE_AR}"

  347.         extraconfrules+=" -DCMAKE_RANLIB=${CMAKE_RANLIB}"

  348.         extraconfrules+=" -DCMAKE_C_COMPILER_RANLIB=${CMAKE_RANLIB}"

  349.         extraconfrules+=" -DCMAKE_CXX_COMPILER_RANLIB=${CMAKE_RANLIB}"

  350.         if [ -n "${EXE_WRAPPER}" ]; then

  351.             extraconfrules+=" -DCMAKE_CROSSCOMPILING_EMULATOR=${EXE_WRAPPER}"

  352.         fi

  353.     fi

  354. 

  355.     if [ "${MACOS}" -eq 1 ]; then

  356.         extraconfrules+=" -DCMAKE_OSX_SYSROOT=macosx"

  357.         if [ "${MACOS_10_15}" -eq 1 ]; then

  358.             extraconfrules+=" -DCMAKE_OSX_DEPLOYMENT_TARGET=10.15"

  359.         elif [ "${MACOS_UNIVERSAL}" -eq 1 ]; then

  360.             extraconfrules+=" -DCMAKE_OSX_DEPLOYMENT_TARGET=10.12"

  361.         else

  362.             extraconfrules+=" -DCMAKE_OSX_DEPLOYMENT_TARGET=10.8"

  363.         fi

  364.         if [ "${MACOS_UNIVERSAL}" -eq 1 ]; then

  365.             extraconfrules+=" -DCMAKE_OSX_ARCHITECTURES='arm64;x86_64'"

  366.         else

  367.             extraconfrules+=" -DCMAKE_OSX_ARCHITECTURES=x86_64"

  368.         fi

  369.     elif [ "${WIN32}" -eq 1 ]; then

  370.         extraconfrules+=" -DCMAKE_RC_COMPILER=${WINDRES}"

  371.     fi

  372. 

  373.     if [ -n "${PAWPAW_DEBUG}" ] && [ "${PAWPAW_DEBUG}" -eq 1 ]; then

  374.         extraconfrules+=" -DCMAKE_BUILD_TYPE=Debug"

  375.     else

  376.         extraconfrules+=" -DCMAKE_BUILD_TYPE=Release"

  377.     fi

  378. 

  379.     if [ ! -f "${pkgdir}/.stamp_configured" ]; then

  380.         pushd "${pkgdir}/build"

  381.         ${CMAKE_EXE_WRAPPER} ${cmake} -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_LIBDIR=lib -DCMAKE_INSTALL_PREFIX="${PAWPAW_PREFIX}" ${extraconfrules} ..

  382.         touch ../.stamp_configured

  383.         popd

  384.     fi

  385. 

  386.     if [ ! -f "${pkgdir}/.stamp_built" ]; then

  387.         pushd "${pkgdir}/build"

  388.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  389.         touch ../.stamp_built

  390.         popd

  391.     fi

  392. 

  393.     if [ ! -f "${pkgdir}/.stamp_installed" ]; then

  394.         pushd "${pkgdir}/build"

  395.         make ${MAKE_ARGS} -j 1 install

  396.         touch ../.stamp_installed

  397.         popd

  398.     fi

  399. 

  400.     _postbuild

  401. }

  402. 

  403. function build_make() {

  404.     local pkgname="${1}"

  405.     local version="${2}"

  406.     local extraconfrules="${3}"

  407. 

  408.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  409. 

  410.     _prebuild "${pkgname}" "${pkgdir}"

  411. 

  412.     touch "${pkgdir}/.stamp_configured"

  413. 

  414.     if [ ! -f "${pkgdir}/.stamp_built" ]; then

  415.         pushd "${pkgdir}"

  416.         make PREFIX="${PAWPAW_PREFIX}" PKG_CONFIG="${TARGET_PKG_CONFIG}" ${MAKE_ARGS} ${extraconfrules}

  417.         touch .stamp_built

  418.         popd

  419.     fi

  420. 

  421.     if [ ! -f "${pkgdir}/.stamp_installed" ]; then

  422.         pushd "${pkgdir}"

  423.         make PREFIX="${PAWPAW_PREFIX}" PKG_CONFIG="${TARGET_PKG_CONFIG}" ${MAKE_ARGS} ${extraconfrules} -j 1 install

  424.         touch .stamp_installed

  425.         popd

  426.     fi

  427. 

  428.     _postbuild

  429. }

  430. 

  431. function build_meson() {

  432.     local pkgname="${1}"

  433.     local version="${2}"

  434.     local extraconfrules="${3}"

  435. 

  436.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  437. 

  438.     if [ "${CROSS_COMPILING}" -eq 1 ]; then

  439.         extraconfrules+=" --cross-file ${PAWPAW_ROOT}/setup/meson/${PAWPAW_TARGET}.ini"

  440.     fi

  441. 

  442.     if [ -n "${PAWPAW_DEBUG}" ] && [ "${PAWPAW_DEBUG}" -eq 1 ]; then

  443.         extraconfrules+=" --buildtype debug"

  444.     else

  445.         extraconfrules+=" --buildtype release"

  446.     fi

  447. 

  448.     _prebuild "${pkgname}" "${pkgdir}"

  449. 

  450.     if [ ! -f "${pkgdir}/.stamp_configured" ]; then

  451.         pushd "${pkgdir}"

  452.         env NINJA="${ninja}" ${meson} setup build --prefix "${PAWPAW_PREFIX}" --libdir lib ${extraconfrules}

  453.         touch .stamp_configured

  454.         popd

  455.     fi

  456. 

  457.     if [ ! -f "${pkgdir}/.stamp_built" ]; then

  458.         pushd "${pkgdir}"

  459.         ${ninja} -v -C build

  460.         touch .stamp_built

  461.         popd

  462.     fi

  463. 

  464.     if [ ! -f "${pkgdir}/.stamp_installed" ]; then

  465.         pushd "${pkgdir}"

  466.         ${ninja} -C build install

  467.         touch .stamp_installed

  468.         popd

  469.     fi

  470. 

  471.     _postbuild

  472. }

  473. 

  474. function build_python() {

  475.     local pkgname="${1}"

  476.     local version="${2}"

  477.     local extraconfrules="${3}"

  478. 

  479.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  480.     local python="python$(echo ${PYTHON_VERSION} | cut -b 1,2,3)"

  481. 

  482.     _prebuild "${pkgname}" "${pkgdir}"

  483. 

  484.     # remove flags not compatible with python

  485.     export CFLAGS="$(echo ${CFLAGS} | sed -e 's/-fvisibility=hidden//')"

  486.     export CFLAGS="$(echo ${CFLAGS} | sed -e 's/-fdata-sections -ffunction-sections//')"

  487.     export CFLAGS="$(echo ${CFLAGS} | sed -e 's/-ffast-math//')"

  488.     export CFLAGS="$(echo ${CFLAGS} | sed -e 's/-fno-finite-math-only//')"

  489.     export CFLAGS="$(echo ${CFLAGS} | sed -e 's/-fno-strict-aliasing -flto//')"

  490.     export CXXFLAGS="$(echo ${CXXFLAGS} | sed -e 's/-fvisibility=hidden//')"

  491.     export CXXFLAGS="$(echo ${CXXFLAGS} | sed -e 's/-fvisibility-inlines-hidden//')"

  492.     export CXXFLAGS="$(echo ${CXXFLAGS} | sed -e 's/-fdata-sections -ffunction-sections//')"

  493.     export CXXFLAGS="$(echo ${CXXFLAGS} | sed -e 's/-ffast-math//')"

  494.     export CXXFLAGS="$(echo ${CXXFLAGS} | sed -e 's/-fno-finite-math-only//')"

  495.     export CXXFLAGS="$(echo ${CXXFLAGS} | sed -e 's/-fno-strict-aliasing -flto//')"

  496.     export LDFLAGS="$(echo ${LDFLAGS} | sed -e 's/-Wl,-dead_strip,-dead_strip_dylibs,-x//')"

  497.     export LDFLAGS="$(echo ${LDFLAGS} | sed -e 's/-Wl,--gc-sections,--no-undefined//')"

  498.     export LDFLAGS="$(echo ${LDFLAGS} | sed -e 's/-Wl,-O1//')"

  499.     export LDFLAGS="$(echo ${LDFLAGS} | sed -e 's/-Wl,--as-needed,--strip-all//')"

  500.     export LDFLAGS="$(echo ${LDFLAGS} | sed -e 's/-fdata-sections -ffunction-sections//')"

  501.     export LDFLAGS="$(echo ${LDFLAGS} | sed -e 's/-fno-strict-aliasing -flto//')"

  502. 

  503.     # add host/native binaries to path

  504.     if [ "${CROSS_COMPILING}" -eq 1 ]; then

  505.         export PATH="${PAWPAW_PREFIX}-host/bin:${PATH}"

  506.     elif [ "${LINUX}" -eq 1 ]; then

  507.         export LD_LIBRARY_PATH="${PAWPAW_PREFIX}/lib"

  508.     fi

  509. 

  510.     touch "${pkgdir}/.stamp_configured"

  511. 

  512.     if [ ! -f "${pkgdir}/.stamp_built" ]; then

  513.         pushd "${pkgdir}"

  514.         ${python} setup.py build_ext ${extraconfrules} --verbose

  515.         touch .stamp_built

  516.         popd

  517.     fi

  518. 

  519.     if [ ! -f "${pkgdir}/.stamp_installed" ]; then

  520.         pushd "${pkgdir}"

  521.         # always try twice, python checks for installed deps and fails the first time

  522.         ${python} setup.py install --prefix="${PAWPAW_PREFIX}" --verbose || \

  523.         ${python} setup.py install --prefix="${PAWPAW_PREFIX}" --verbose || true

  524.         touch .stamp_installed

  525.         popd

  526.     fi

  527. 

  528.     if [ "${CROSS_COMPILING}" -eq 0 ] && [ "${LINUX}" -eq 1 ]; then

  529.         unset LD_LIBRARY_PATH

  530.     fi

  531. 

  532.     _postbuild

  533. }

  534. 

  535. function build_qmake() {

  536.     local pkgname="${1}"

  537.     local version="${2}"

  538.     local extraconfrules="${3}"

  539. 

  540.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  541. 

  542.     _prebuild "${pkgname}" "${pkgdir}"

  543. 

  544.     # if [ "${CROSS_COMPILING}" -eq 1 ]; then

  545.     #     export PKG_CONFIG_LIBDIR="${TARGET_PKG_CONFIG_PATH}"

  546.     #     export PKG_CONFIG_SYSROOT_DIR="/"

  547.     # fi

  548. 

  549.     if [ ! -f "${pkgdir}/.stamp_configured" ]; then

  550.         pushd "${pkgdir}"

  551.         qmake ${extraconfrules}

  552.         touch .stamp_configured

  553.         popd

  554.     fi

  555. 

  556.     if [ ! -f "${pkgdir}/.stamp_built" ]; then

  557.         pushd "${pkgdir}"

  558.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  559.         touch .stamp_built

  560.         popd

  561.     fi

  562. 

  563.     if [ ! -f "${pkgdir}/.stamp_installed" ]; then

  564.         pushd "${pkgdir}"

  565.         make ${MAKE_ARGS} -j 1 install

  566.         touch .stamp_installed

  567.         popd

  568.     fi

  569. 

  570.     # unset PKG_CONFIG_LIBDIR

  571.     # unset PKG_CONFIG_SYSROOT_DIR

  572. 

  573.     _postbuild

  574. }

  575. 

  576. function build_waf() {

  577.     local pkgname="${1}"

  578.     local version="${2}"

  579.     local extraconfrules="${3}"

  580. 

  581.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  582.     local python=python3

  583. 

  584.     if ! which python3 > /dev/null; then

  585.         python=python

  586.     fi

  587. 

  588.     if [ "${CROSS_COMPILING}" -eq 0 ] && [ "${LINUX}" -eq 1 ]; then

  589.         export LD_LIBRARY_PATH="${PAWPAW_PREFIX}/lib"

  590.     fi

  591. 

  592.     _prebuild "${pkgname}" "${pkgdir}"

  593. 

  594.     if [ ! -f "${pkgdir}/.stamp_configured" ]; then

  595.         pushd "${pkgdir}"

  596.         ${python} waf configure --prefix="${PAWPAW_PREFIX}" ${extraconfrules}

  597.         touch .stamp_configured

  598.         popd

  599.     fi

  600. 

  601.     if [ ! -f "${pkgdir}/.stamp_built" ]; then

  602.         pushd "${pkgdir}"

  603.         ${python} waf build ${WAF_ARGS}

  604.         touch .stamp_built

  605.         popd

  606.     fi

  607. 

  608.     if [ ! -f "${pkgdir}/.stamp_installed" ]; then

  609.         pushd "${pkgdir}"

  610.         ${python} waf install ${WAF_ARGS} --prefix="${PAWPAW_PREFIX}" ${extraconfrules} -j 1

  611.         rm -f ${PAWPAW_PREFIX}/lib/lv2/*/*.a

  612.         touch .stamp_installed

  613.         popd

  614.     fi

  615. 

  616.     if [ "${CROSS_COMPILING}" -eq 0 ] && [ "${LINUX}" -eq 1 ]; then

  617.         unset LD_LIBRARY_PATH

  618.     fi

  619. 

  620.     _postbuild

  621. }

  622. 

  623. # ---------------------------------------------------------------------------------------------------------------------

  624. 

  625. function run_make() {

  626.     local pkgname="${1}"

  627.     local version="${2}"

  628.     local makerule="${3}"

  629. 

  630.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  631. 

  632.     _prebuild "${pkgname}" "${pkgdir}"

  633. 

  634.     if [ ! -f "${pkgdir}/.stamp_custom_run" ]; then

  635.         pushd "${pkgdir}"

  636.         make ${MAKE_ARGS} ${makerule}

  637.         touch .stamp_custom_run

  638.         popd

  639.     fi

  640. 

  641.     _postbuild

  642. }

  643. 

  644. # ---------------------------------------------------------------------------------------------------------------------

  645. 

  646. function build_host_autoconf() {

  647.     local pkgname="${1}"

  648.     local version="${2}"

  649.     local extraconfrules="${3}"

  650. 

  651.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  652. 

  653.     unset AR

  654.     unset CC

  655.     unset CXX

  656.     unset LD

  657.     unset STRIP

  658.     unset CFLAGS

  659.     unset CPPFLAGS

  660.     unset CXXFLAGS

  661.     unset LDFLAGS

  662. 

  663.     if [ -e "${PAWPAW_ROOT}/patches/${pkgname}" ] && [ ! -f "${pkgdir}/.stamp_cleanup" ] && [ ! -f "${pkgdir}/.stamp_configured" ]; then

  664.         local patchtargets="${PAWPAW_TARGET}"

  665.         if [[ "${PAWPAW_TARGET}" = "linux-"* ]]; then

  666.             patchtargets+=" linux"

  667.         elif [ "${PAWPAW_TARGET}" = "macos-universal-10.15" ]; then

  668.             patchtargets+=" macos-10.15 macos-universal"

  669.         elif [ "${PAWPAW_TARGET}" = "win64" ]; then

  670.             patchtargets+=" win32"

  671.         fi

  672. 

  673.         for target in ${patchtargets[@]}; do

  674.             if [ -e "${PAWPAW_ROOT}/patches/${pkgname}/${target}" ]; then

  675.                 for p in $(ls "${PAWPAW_ROOT}/patches/${pkgname}/${target}/" | grep "\.patch$" | sort); do

  676.                     if [ ! -f "${pkgdir}/.stamp_applied_${p}" ]; then

  677.                         patch -p1 -d "${pkgdir}" -i "${PAWPAW_ROOT}/patches/${pkgname}/${target}/${p}"

  678.                         touch "${pkgdir}/.stamp_applied_${p}"

  679.                     fi

  680.                 done

  681.             fi

  682.         done

  683. 

  684.         for p in $(ls "${PAWPAW_ROOT}/patches/${pkgname}/" | grep "\.patch$" | sort); do

  685.             if [ ! -f "${pkgdir}/.stamp_applied_${p}" ]; then

  686.                 patch -p1 -d "${pkgdir}" -i "${PAWPAW_ROOT}/patches/${pkgname}/${p}"

  687.                 touch "${pkgdir}/.stamp_applied_${p}"

  688.             fi

  689.         done

  690.     fi

  691. 

  692.     if [ ! -f "${pkgdir}/.stamp_configured" ]; then

  693.         pushd "${pkgdir}"

  694.         ./configure --enable-static --disable-shared --disable-maintainer-mode --prefix="${PAWPAW_PREFIX}" ${extraconfrules}

  695.         touch .stamp_configured

  696.         popd

  697.     fi

  698. 

  699.     if [ ! -f "${pkgdir}/.stamp_built" ]; then

  700.         pushd "${pkgdir}"

  701.         make ${MAKE_ARGS}

  702.         touch .stamp_built

  703.         popd

  704.     fi

  705. 

  706.     if [ ! -f "${pkgdir}/.stamp_installed" ]; then

  707.         pushd "${pkgdir}"

  708.         make ${MAKE_ARGS} install -j 1

  709.         touch .stamp_installed

  710.         popd

  711.     fi

  712. }

  713. 

  714. function build_host_cmake() {

  715.     local pkgname="${1}"

  716.     local version="${2}"

  717.     local extraconfrules="${3}"

  718. 

  719.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  720. 

  721.     unset AR

  722.     unset CC

  723.     unset CXX

  724.     unset LD

  725.     unset STRIP

  726.     unset CFLAGS

  727.     unset CPPFLAGS

  728.     unset CXXFLAGS

  729.     unset LDFLAGS

  730. 

  731.     if [ -e "${PAWPAW_ROOT}/patches/${pkgname}" ] && [ ! -f "${pkgdir}/.stamp_cleanup" ] && [ ! -f "${pkgdir}/.stamp_configured" ]; then

  732.         local patchtargets="${PAWPAW_TARGET}"

  733.         if [[ "${PAWPAW_TARGET}" = "linux-"* ]]; then

  734.             patchtargets+=" linux"

  735.         elif [ "${PAWPAW_TARGET}" = "macos-universal-10.15" ]; then

  736.             patchtargets+=" macos-10.15 macos-universal"

  737.         elif [ "${PAWPAW_TARGET}" = "win64" ]; then

  738.             patchtargets+=" win32"

  739.         fi

  740. 

  741.         for target in ${patchtargets[@]}; do

  742.             if [ -e "${PAWPAW_ROOT}/patches/${pkgname}/${target}" ]; then

  743.                 for p in $(ls "${PAWPAW_ROOT}/patches/${pkgname}/${target}/" | grep "\.patch$" | sort); do

  744.                     if [ ! -f "${pkgdir}/.stamp_applied_${p}" ]; then

  745.                         patch -p1 -d "${pkgdir}" -i "${PAWPAW_ROOT}/patches/${pkgname}/${target}/${p}"

  746.                         touch "${pkgdir}/.stamp_applied_${p}"

  747.                     fi

  748.                 done

  749.             fi

  750.         done

  751. 

  752.         for p in $(ls "${PAWPAW_ROOT}/patches/${pkgname}/" | grep "\.patch$" | sort); do

  753.             if [ ! -f "${pkgdir}/.stamp_applied_${p}" ]; then

  754.                 patch -p1 -d "${pkgdir}" -i "${PAWPAW_ROOT}/patches/${pkgname}/${p}"

  755.                 touch "${pkgdir}/.stamp_applied_${p}"

  756.             fi

  757.         done

  758.     fi

  759. 

  760.     mkdir -p "${pkgdir}/build"

  761. 

  762.     if [ ! -f "${pkgdir}/.stamp_configured" ]; then

  763.         pushd "${pkgdir}/build"

  764.         ${CMAKE_EXE_WRAPPER} ${cmake} \

  765.             -DCMAKE_BUILD_TYPE=Release \

  766.             -DCMAKE_INSTALL_LIBDIR=lib \

  767.             -DCMAKE_INSTALL_PREFIX="${PAWPAW_PREFIX}-host" \

  768.             -DCMAKE_MODULE_PATH="${PAWPAW_PREFIX}-host/lib/cmake" \

  769.             -DBUILD_SHARED_LIBS=OFF \

  770.             ${extraconfrules} ..

  771.         touch ../.stamp_configured

  772.         popd

  773.     fi

  774. 

  775.     if [ ! -f "${pkgdir}/.stamp_built" ]; then

  776.         pushd "${pkgdir}/build"

  777.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  778.         touch ../.stamp_built

  779.         popd

  780.     fi

  781. 

  782.     if [ ! -f "${pkgdir}/.stamp_installed" ]; then

  783.         pushd "${pkgdir}/build"

  784.         make ${MAKE_ARGS} -j 1 install

  785.         touch ../.stamp_installed

  786.         popd

  787.     fi

  788. }

  789. 

  790. # ---------------------------------------------------------------------------------------------------------------------

  791. 

  792. function patch_file() {

  793.     local pkgname="${1}"

  794.     local version="${2}"

  795.     local file="${3}"

  796.     local rule="${4}"

  797. 

  798.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  799. 

  800.     if [ -e "${pkgdir}/${file}" ]; then

  801.         sed -i -e "${rule}" "${pkgdir}/${file}"

  802.     fi

  803. }

  804. 

  805. function copy_file() {

  806.     local pkgname="${1}"

  807.     local version="${2}"

  808.     local source="${3}"

  809.     local target="${4}"

  810. 

  811.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  812. 

  813.     if [ ! -e "${pkgdir}/${target}" ] || [ "${source}" -nt "${target}" ]; then

  814.         pushd "${pkgdir}"

  815.         cp -v "${source}" "${target}"

  816.         popd

  817.     fi

  818. }

  819. 

  820. function install_file() {

  821.     local pkgname="${1}"

  822.     local version="${2}"

  823.     local source="${3}"

  824.     local targetdir="${4}"

  825.     local targetname="${5}"

  826. 

  827.     if [ -z "${targetname}" ]; then

  828.         targetname="$(basename ${source})"

  829.     fi

  830. 

  831.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  832. 

  833.     if [ ! -e "${PAWPAW_PREFIX}/${targetdir}/${targetname}" ]; then

  834.         pushd "${pkgdir}"

  835.         cp -v "${source}" "${PAWPAW_PREFIX}/${targetdir}/${targetname}"

  836.         popd

  837.     fi

  838. }

  839. 

  840. function link_file() {

  841.     local pkgname="${1}"

  842.     local version="${2}"

  843.     local source="${3}"

  844.     local target="${4}"

  845. 

  846.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  847. 

  848.     if [ ! -e "${pkgdir}/${target}" ]; then

  849.         pushd "${pkgdir}"

  850.         ln -sfv "${source}" "${target}"

  851.         popd

  852.     fi

  853. }

  854. 

  855. function link_host_file() {

  856.     local pkgname="${1}"

  857.     local version="${2}"

  858.     local source="${3}"

  859.     local target="${4}"

  860. 

  861.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  862. 

  863.     if [ ! -e "${PAWPAW_PREFIX}-host/${target}" ]; then

  864.         ln -sfv "${source}" "${PAWPAW_PREFIX}-host/${target}"

  865.     fi

  866. }

  867. 

  868. function link_target_file() {

  869.     local pkgname="${1}"

  870.     local version="${2}"

  871.     local source="${3}"

  872.     local target="${4}"

  873. 

  874.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  875. 

  876.     if [ ! -e "${PAWPAW_PREFIX}/${target}" ]; then

  877.         ln -sfv "${source}" "${PAWPAW_PREFIX}/${target}"

  878.     fi

  879. }

  880. 

  881. function remove_file() {

  882.     local pkgname="${1}"

  883.     local version="${2}"

  884.     local file="${3}"

  885. 

  886.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  887. 

  888.     if [ -e "${pkgdir}/${file}" ]; then

  889.         rm -fv "${pkgdir}/${file}"

  890.     fi

  891. }

  892. 

  893. # ---------------------------------------------------------------------------------------------------------------------

  894. 

  895. function patch_osx_binary_libs() {

  896.     local file="${1}"

  897. 

  898.     if [ -L "${file}" ]; then

  899.         return 0

  900.     fi

  901. 

  902.     idname=$(otool -D "${file}")

  903. 

  904.     if otool -L "${file}" | grep -v ":" | grep -v "${idname}" | grep -q "${PAWPAW_PREFIX}"; then

  905.         #install_name_tool -change "@rpath/QtCore.framework/Versions/5/QtCore" "@executable_path/QtCore" "${file}"

  906.         #install_name_tool -change "@rpath/QtGui.framework/Versions/5/QtGui" "@executable_path/QtGui" "${file}"

  907.         #install_name_tool -change "@rpath/QtWidgets.framework/Versions/5/QtWidgets" "@executable_path/QtWidgets" "${file}"

  908.         #install_name_tool -change "@rpath/QtXml.framework/Versions/5/QtXml" "@executable_path/QtXml" "${file}"

  909.         install_name_tool -change "@executable_path/../Frameworks/libjack.0.dylib" "/usr/local/lib/libjack.0.dylib" "${file}"

  910.         install_name_tool -change "${PAWPAW_PREFIX}/jack2/lib/libjack.0.dylib" "/usr/local/lib/libjack.0.dylib" "${file}"

  911.         install_name_tool -change "${PAWPAW_PREFIX}/jack2/lib/libjacknet.0.dylib" "/usr/local/lib/libjacknet.0.dylib" "${file}"

  912.         install_name_tool -change "${PAWPAW_PREFIX}/jack2/lib/libjackserver.0.dylib" "/usr/local/lib/libjackserver.0.dylib" "${file}"

  913.      fi

  914. }

  915. 

  916. function patch_osx_qtapp() {

  917.     local pkgname="${1}"

  918.     local version="${2}"

  919.     local appfile="${3}"

  920. 

  921.     local pkgdir="${PAWPAW_BUILDDIR}/${pkgname}-${version}"

  922. 

  923.     _prebuild "${pkgname}" "${pkgdir}"

  924. 

  925.     mkdir -p "${appfile}/Contents/PlugIns/platforms"

  926.     mkdir -p "${appfile}/Contents/PlugIns/printsupport"

  927.     cp -v "${PAWPAW_PREFIX}/lib/qt5/plugins/platforms/libqcocoa.dylib" "${appfile}/Contents/PlugIns/platforms/"

  928.     cp -v "${PAWPAW_PREFIX}/lib/qt5/plugins/printsupport/libcocoaprintersupport.dylib" "${appfile}/Contents/PlugIns/printsupport/"

  929. 

  930.     macdeployqt "${appfile}"

  931. 

  932.     rm -f "${appfile}/Contents/Frameworks/libjack.0.1.0.dylib"

  933. 

  934.     _postbuild

  935. }

  936. 

  937. # ---------------------------------------------------------------------------------------------------------------------