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.
748 Commits
3 Branches
4.3MB
Tree: 94eb0a16fd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '94eb0a16fd'
${ noResults }
PawPaw/setup/functions.sh

936 lines
28KB
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/-ffast-math//')"

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

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

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

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

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

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

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

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

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

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

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

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

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

  500. 

  501.     # add host/native binaries to path

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

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

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

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

  506.     fi

  507. 

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

  509. 

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

  511.         pushd "${pkgdir}"

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

  513.         touch .stamp_built

  514.         popd

  515.     fi

  516. 

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

  518.         pushd "${pkgdir}"

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

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

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

  522.         touch .stamp_installed

  523.         popd

  524.     fi

  525. 

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

  527.         unset LD_LIBRARY_PATH

  528.     fi

  529. 

  530.     _postbuild

  531. }

  532. 

  533. function build_qmake() {

  534.     local pkgname="${1}"

  535.     local version="${2}"

  536.     local extraconfrules="${3}"

  537. 

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

  539. 

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

  541. 

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

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

  544.     #     export PKG_CONFIG_SYSROOT_DIR="/"

  545.     # fi

  546. 

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

  548.         pushd "${pkgdir}"

  549.         qmake ${extraconfrules}

  550.         touch .stamp_configured

  551.         popd

  552.     fi

  553. 

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

  555.         pushd "${pkgdir}"

  556.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  557.         touch .stamp_built

  558.         popd

  559.     fi

  560. 

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

  562.         pushd "${pkgdir}"

  563.         make ${MAKE_ARGS} -j 1 install

  564.         touch .stamp_installed

  565.         popd

  566.     fi

  567. 

  568.     # unset PKG_CONFIG_LIBDIR

  569.     # unset PKG_CONFIG_SYSROOT_DIR

  570. 

  571.     _postbuild

  572. }

  573. 

  574. function build_waf() {

  575.     local pkgname="${1}"

  576.     local version="${2}"

  577.     local extraconfrules="${3}"

  578. 

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

  580.     local python=python3

  581. 

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

  583.         python=python

  584.     fi

  585. 

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

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

  588.     fi

  589. 

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

  591. 

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

  593.         pushd "${pkgdir}"

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

  595.         touch .stamp_configured

  596.         popd

  597.     fi

  598. 

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

  600.         pushd "${pkgdir}"

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

  602.         touch .stamp_built

  603.         popd

  604.     fi

  605. 

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

  607.         pushd "${pkgdir}"

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

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

  610.         touch .stamp_installed

  611.         popd

  612.     fi

  613. 

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

  615.         unset LD_LIBRARY_PATH

  616.     fi

  617. 

  618.     _postbuild

  619. }

  620. 

  621. # ---------------------------------------------------------------------------------------------------------------------

  622. 

  623. function run_make() {

  624.     local pkgname="${1}"

  625.     local version="${2}"

  626.     local makerule="${3}"

  627. 

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

  629. 

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

  631. 

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

  633.         pushd "${pkgdir}"

  634.         make ${MAKE_ARGS} ${makerule}

  635.         touch .stamp_custom_run

  636.         popd

  637.     fi

  638. 

  639.     _postbuild

  640. }

  641. 

  642. # ---------------------------------------------------------------------------------------------------------------------

  643. 

  644. function build_host_autoconf() {

  645.     local pkgname="${1}"

  646.     local version="${2}"

  647.     local extraconfrules="${3}"

  648. 

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

  650. 

  651.     unset AR

  652.     unset CC

  653.     unset CXX

  654.     unset LD

  655.     unset STRIP

  656.     unset CFLAGS

  657.     unset CPPFLAGS

  658.     unset CXXFLAGS

  659.     unset LDFLAGS

  660. 

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

  662.         local patchtargets="${PAWPAW_TARGET}"

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

  664.             patchtargets+=" linux"

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

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

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

  668.             patchtargets+=" win32"

  669.         fi

  670. 

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

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

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

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

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

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

  677.                     fi

  678.                 done

  679.             fi

  680.         done

  681. 

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

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

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

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

  686.             fi

  687.         done

  688.     fi

  689. 

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

  691.         pushd "${pkgdir}"

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

  693.         touch .stamp_configured

  694.         popd

  695.     fi

  696. 

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

  698.         pushd "${pkgdir}"

  699.         make ${MAKE_ARGS}

  700.         touch .stamp_built

  701.         popd

  702.     fi

  703. 

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

  705.         pushd "${pkgdir}"

  706.         make ${MAKE_ARGS} install -j 1

  707.         touch .stamp_installed

  708.         popd

  709.     fi

  710. }

  711. 

  712. function build_host_cmake() {

  713.     local pkgname="${1}"

  714.     local version="${2}"

  715.     local extraconfrules="${3}"

  716. 

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

  718. 

  719.     unset AR

  720.     unset CC

  721.     unset CXX

  722.     unset LD

  723.     unset STRIP

  724.     unset CFLAGS

  725.     unset CPPFLAGS

  726.     unset CXXFLAGS

  727.     unset LDFLAGS

  728. 

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

  730.         local patchtargets="${PAWPAW_TARGET}"

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

  732.             patchtargets+=" linux"

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

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

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

  736.             patchtargets+=" win32"

  737.         fi

  738. 

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

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

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

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

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

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

  745.                     fi

  746.                 done

  747.             fi

  748.         done

  749. 

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

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

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

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

  754.             fi

  755.         done

  756.     fi

  757. 

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

  759. 

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

  761.         pushd "${pkgdir}/build"

  762.         ${CMAKE_EXE_WRAPPER} ${cmake} \

  763.             -DCMAKE_BUILD_TYPE=Release \

  764.             -DCMAKE_INSTALL_LIBDIR=lib \

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

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

  767.             -DBUILD_SHARED_LIBS=OFF \

  768.             ${extraconfrules} ..

  769.         touch ../.stamp_configured

  770.         popd

  771.     fi

  772. 

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

  774.         pushd "${pkgdir}/build"

  775.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  776.         touch ../.stamp_built

  777.         popd

  778.     fi

  779. 

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

  781.         pushd "${pkgdir}/build"

  782.         make ${MAKE_ARGS} -j 1 install

  783.         touch ../.stamp_installed

  784.         popd

  785.     fi

  786. }

  787. 

  788. # ---------------------------------------------------------------------------------------------------------------------

  789. 

  790. function patch_file() {

  791.     local pkgname="${1}"

  792.     local version="${2}"

  793.     local file="${3}"

  794.     local rule="${4}"

  795. 

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

  797. 

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

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

  800.     fi

  801. }

  802. 

  803. function copy_file() {

  804.     local pkgname="${1}"

  805.     local version="${2}"

  806.     local source="${3}"

  807.     local target="${4}"

  808. 

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

  810. 

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

  812.         pushd "${pkgdir}"

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

  814.         popd

  815.     fi

  816. }

  817. 

  818. function install_file() {

  819.     local pkgname="${1}"

  820.     local version="${2}"

  821.     local source="${3}"

  822.     local targetdir="${4}"

  823.     local targetname="${5}"

  824. 

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

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

  827.     fi

  828. 

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

  830. 

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

  832.         pushd "${pkgdir}"

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

  834.         popd

  835.     fi

  836. }

  837. 

  838. function link_file() {

  839.     local pkgname="${1}"

  840.     local version="${2}"

  841.     local source="${3}"

  842.     local target="${4}"

  843. 

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

  845. 

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

  847.         pushd "${pkgdir}"

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

  849.         popd

  850.     fi

  851. }

  852. 

  853. function link_host_file() {

  854.     local pkgname="${1}"

  855.     local version="${2}"

  856.     local source="${3}"

  857.     local target="${4}"

  858. 

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

  860. 

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

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

  863.     fi

  864. }

  865. 

  866. function link_target_file() {

  867.     local pkgname="${1}"

  868.     local version="${2}"

  869.     local source="${3}"

  870.     local target="${4}"

  871. 

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

  873. 

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

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

  876.     fi

  877. }

  878. 

  879. function remove_file() {

  880.     local pkgname="${1}"

  881.     local version="${2}"

  882.     local file="${3}"

  883. 

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

  885. 

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

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

  888.     fi

  889. }

  890. 

  891. # ---------------------------------------------------------------------------------------------------------------------

  892. 

  893. function patch_osx_binary_libs() {

  894.     local file="${1}"

  895. 

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

  897.         return 0

  898.     fi

  899. 

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

  901. 

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

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

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

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

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

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

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

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

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

  911.      fi

  912. }

  913. 

  914. function patch_osx_qtapp() {

  915.     local pkgname="${1}"

  916.     local version="${2}"

  917.     local appfile="${3}"

  918. 

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

  920. 

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

  922. 

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

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

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

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

  927. 

  928.     macdeployqt "${appfile}"

  929. 

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

  931. 

  932.     _postbuild

  933. }

  934. 

  935. # ---------------------------------------------------------------------------------------------------------------------