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

788 lines
24KB
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 name="${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="${name}"

  20.     fi

  21. 

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

  23.     local dlfolder="${PAWPAW_BUILDDIR}/${name}-${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 name1="${1}"

  64.     local name2="${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}/${name1}-${version}.${dlext}"

  73.     local dlfolder2="${PAWPAW_BUILDDIR}/${name2}-${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 name="${1}"

  83.     local hash="${2}"

  84.     local repourl="${3}"

  85.     local dlname="${4}"

  86. 

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

  88.         dlname="${name}"

  89.     fi

  90. 

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

  92.     local dlfolder="${PAWPAW_BUILDDIR}/${name}-${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 name="${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 [ -d "${PAWPAW_ROOT}/patches/${name}" ] && [ ! -f "${pkgdir}/.stamp_cleanup" ]; then

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

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

  143.                 patch -p1 -d "${pkgdir}" -i "${PAWPAW_ROOT}/patches/${name}/${p}"

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

  145.             fi

  146.         done

  147.     fi

  148. 

  149.     if [ -d "${PAWPAW_ROOT}/patches/${name}/${PAWPAW_TARGET}" ] && [ ! -f "${pkgdir}/.stamp_cleanup" ]; then

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

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

  152.                 patch -p1 -d "${pkgdir}" -i "${PAWPAW_ROOT}/patches/${name}/${PAWPAW_TARGET}/${p}"

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

  154.             fi

  155.         done

  156.     fi

  157. 

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

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

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

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

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

  163. 

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

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

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

  167. 

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

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

  170. 

  171.     fi

  172. }

  173. 

  174. function _postbuild() {

  175.     unset AR

  176.     unset CC

  177.     unset CXX

  178.     unset DLLWRAP

  179.     unset LD

  180.     unset NM

  181.     unset RANLIB

  182.     unset STRIP

  183.     unset WINDRES

  184. 

  185.     unset CFLAGS

  186.     unset CPPFLAGS

  187.     unset CXXFLAGS

  188.     unset LDFLAGS

  189.     unset PKG_CONFIG_PATH

  190. 

  191.     unset EXTRA_CFLAGS

  192.     unset EXTRA_CPPFLAGS

  193.     unset EXTRA_CXXFLAGS

  194.     unset EXTRA_LDFLAGS

  195.     unset EXTRA_MAKE_ARGS

  196. 

  197.     export PATH="${OLD_PATH}"

  198. }

  199. 

  200. # ---------------------------------------------------------------------------------------------------------------------

  201. 

  202. function build_autoconf() {

  203.     local name="${1}"

  204.     local version="${2}"

  205.     local extraconfrules="${3}"

  206. 

  207.     local pkgdir="${PAWPAW_BUILDDIR}/${name}-${version}"

  208. 

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

  210.         extraconfrules="--host=$(uname -m)-linux-gnu ${extraconfrules}"

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

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

  213.     fi

  214. 

  215.     _prebuild "${name}" "${pkgdir}"

  216. 

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

  218.         pushd "${pkgdir}"

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

  220.         touch .stamp_configured

  221.         popd

  222.     fi

  223. 

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

  225.         pushd "${pkgdir}"

  226.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  227.         touch .stamp_built

  228.         popd

  229.     fi

  230. 

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

  232.         pushd "${pkgdir}"

  233.         make ${MAKE_ARGS} install -j 1

  234.         touch .stamp_installed

  235.         popd

  236.     fi

  237. 

  238.     _postbuild

  239. }

  240. 

  241. function build_autoconfgen() {

  242.     local name="${1}"

  243.     local version="${2}"

  244.     local extraconfrules="${3}"

  245. 

  246.     local pkgdir="${PAWPAW_BUILDDIR}/${name}-${version}"

  247. 

  248.     local EXTRA_CFLAGS2="${EXTRA_CFLAGS}"

  249.     local EXTRA_CXXFLAGS2="${EXTRA_CXXFLAGS}"

  250.     local EXTRA_LDFLAGS2="${EXTRA_LDFLAGS}"

  251.     local EXTRA_MAKE_ARGS2="${EXTRA_MAKE_ARGS}"

  252. 

  253.     _prebuild "${name}" "${pkgdir}"

  254. 

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

  256.         pushd "${pkgdir}"

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

  258.             ./utils/autogen.sh

  259.         else

  260.             ${autoconf}

  261.         fi

  262.         touch .stamp_preconfigured

  263.         popd

  264.     fi

  265. 

  266.     _postbuild

  267. 

  268.     export EXTRA_CFLAGS="${EXTRA_CFLAGS2}"

  269.     export EXTRA_CXXFLAGS="${EXTRA_CXXFLAGS2}"

  270.     export EXTRA_LDFLAGS="${EXTRA_LDFLAGS2}"

  271.     export EXTRA_MAKE_ARGS="${EXTRA_MAKE_ARGS2}"

  272. 

  273.     build_autoconf "${name}" "${version}" "${extraconfrules}"

  274. }

  275. 

  276. function build_conf() {

  277.     local name="${1}"

  278.     local version="${2}"

  279.     local extraconfrules="${3}"

  280. 

  281.     local pkgdir="${PAWPAW_BUILDDIR}/${name}-${version}"

  282. 

  283.     _prebuild "${name}" "${pkgdir}"

  284. 

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

  286.         pushd "${pkgdir}"

  287.         ./configure ${extraconfrules}

  288.         touch .stamp_configured

  289.         popd

  290.     fi

  291. 

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

  293.         pushd "${pkgdir}"

  294.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  295.         touch .stamp_built

  296.         popd

  297.     fi

  298. 

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

  300.         pushd "${pkgdir}"

  301.         make ${MAKE_ARGS} -j 1 install

  302.         touch .stamp_installed

  303.         popd

  304.     fi

  305. 

  306.     _postbuild

  307. }

  308. 

  309. function build_cmake() {

  310.     local name="${1}"

  311.     local version="${2}"

  312.     local extraconfrules="${3}"

  313. 

  314.     local pkgdir="${PAWPAW_BUILDDIR}/${name}-${version}"

  315. 

  316.     _prebuild "${name}" "${pkgdir}"

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

  318. 

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

  320.         CMAKE_EXE_WRAPPER="emcmake"

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

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

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

  324.         extraconfrules+=" -DCMAKE_CROSSCOMPILING=ON"

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

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

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

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

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

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

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

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

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

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

  335.         fi

  336.     fi

  337. 

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

  339.         if [ "${MACOS_UNIVERSAL_10_15}" -eq 1 ]; then

  340.             OSX_ARCHS="arm64;x86_64"

  341.             OSX_TARGET="10.15"

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

  343.             OSX_ARCHS="arm64;x86_64"

  344.             OSX_TARGET="10.12"

  345.         else

  346.             OSX_ARCHS="x86_64"

  347.             OSX_TARGET="10.8"

  348.         fi

  349.         extraconfrules+=" -DCMAKE_OSX_ARCHITECTURES=${OSX_ARCHS}"

  350.         extraconfrules+=" -DCMAKE_OSX_DEPLOYMENT_TARGET=${OSX_TARGET}"

  351.         extraconfrules+=" -DCMAKE_OSX_SYSROOT=macosx"

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

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

  354.     fi

  355. 

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

  357.         pushd "${pkgdir}/build"

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

  359.         touch ../.stamp_configured

  360.         popd

  361.     fi

  362. 

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

  364.         pushd "${pkgdir}/build"

  365.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  366.         touch ../.stamp_built

  367.         popd

  368.     fi

  369. 

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

  371.         pushd "${pkgdir}/build"

  372.         make ${MAKE_ARGS} -j 1 install

  373.         touch ../.stamp_installed

  374.         popd

  375.     fi

  376. 

  377.     _postbuild

  378. }

  379. 

  380. function build_make() {

  381.     local name="${1}"

  382.     local version="${2}"

  383.     local extraconfrules="${3}"

  384. 

  385.     local pkgdir="${PAWPAW_BUILDDIR}/${name}-${version}"

  386. 

  387.     _prebuild "${name}" "${pkgdir}"

  388. 

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

  390. 

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

  392.         pushd "${pkgdir}"

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

  394.         touch .stamp_built

  395.         popd

  396.     fi

  397. 

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

  399.         pushd "${pkgdir}"

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

  401.         touch .stamp_installed

  402.         popd

  403.     fi

  404. 

  405.     _postbuild

  406. }

  407. 

  408. function build_meson() {

  409.     local name="${1}"

  410.     local version="${2}"

  411.     local extraconfrules="${3}"

  412. 

  413.     local pkgdir="${PAWPAW_BUILDDIR}/${name}-${version}"

  414. 

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

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

  417.     fi

  418. 

  419.     _prebuild "${name}" "${pkgdir}"

  420. 

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

  422.         pushd "${pkgdir}"

  423.         env NINJA="${ninja}" ${meson} build --buildtype release --prefix "${PAWPAW_PREFIX}" --libdir lib ${extraconfrules}

  424.         touch .stamp_configured

  425.         popd

  426.     fi

  427. 

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

  429.         pushd "${pkgdir}"

  430.         ${ninja} -v -C build

  431.         touch .stamp_built

  432.         popd

  433.     fi

  434. 

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

  436.         pushd "${pkgdir}"

  437.         ${ninja} -C build install

  438.         touch .stamp_installed

  439.         popd

  440.     fi

  441. 

  442.     _postbuild

  443. }

  444. 

  445. function build_python() {

  446.     local name="${1}"

  447.     local version="${2}"

  448.     local extraconfrules="${3}"

  449. 

  450.     local pkgdir="${PAWPAW_BUILDDIR}/${name}-${version}"

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

  452. 

  453.     _prebuild "${name}" "${pkgdir}"

  454. 

  455.     # remove flags not compatible with python

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  470. 

  471.     # add host/native binaries to path

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

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

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

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

  476.     fi

  477. 

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

  479. 

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

  481.         pushd "${pkgdir}"

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

  483.         touch .stamp_built

  484.         popd

  485.     fi

  486. 

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

  488.         pushd "${pkgdir}"

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

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

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

  492.         touch .stamp_installed

  493.         popd

  494.     fi

  495. 

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

  497.         unset LD_LIBRARY_PATH

  498.     fi

  499. 

  500.     _postbuild

  501. }

  502. 

  503. function build_qmake() {

  504.     local name="${1}"

  505.     local version="${2}"

  506.     local extraconfrules="${3}"

  507. 

  508.     local pkgdir="${PAWPAW_BUILDDIR}/${name}-${version}"

  509. 

  510.     _prebuild "${name}" "${pkgdir}"

  511. 

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

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

  514.     #     export PKG_CONFIG_SYSROOT_DIR="/"

  515.     # fi

  516. 

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

  518.         pushd "${pkgdir}"

  519.         qmake ${extraconfrules}

  520.         touch .stamp_configured

  521.         popd

  522.     fi

  523. 

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

  525.         pushd "${pkgdir}"

  526.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  527.         touch .stamp_built

  528.         popd

  529.     fi

  530. 

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

  532.         pushd "${pkgdir}"

  533.         make ${MAKE_ARGS} -j 1 install

  534.         touch .stamp_installed

  535.         popd

  536.     fi

  537. 

  538.     # unset PKG_CONFIG_LIBDIR

  539.     # unset PKG_CONFIG_SYSROOT_DIR

  540. 

  541.     _postbuild

  542. }

  543. 

  544. function build_waf() {

  545.     local name="${1}"

  546.     local version="${2}"

  547.     local extraconfrules="${3}"

  548. 

  549.     local pkgdir="${PAWPAW_BUILDDIR}/${name}-${version}"

  550.     local python=python3

  551. 

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

  553.         python=python

  554.     fi

  555. 

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

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

  558.     fi

  559. 

  560.     _prebuild "${name}" "${pkgdir}"

  561. 

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

  563.         pushd "${pkgdir}"

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

  565.         touch .stamp_configured

  566.         popd

  567.     fi

  568. 

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

  570.         pushd "${pkgdir}"

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

  572.         touch .stamp_built

  573.         popd

  574.     fi

  575. 

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

  577.         pushd "${pkgdir}"

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

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

  580.         touch .stamp_installed

  581.         popd

  582.     fi

  583. 

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

  585.         unset LD_LIBRARY_PATH

  586.     fi

  587. 

  588.     _postbuild

  589. }

  590. 

  591. # ---------------------------------------------------------------------------------------------------------------------

  592. 

  593. function run_make() {

  594.     local name="${1}"

  595.     local version="${2}"

  596.     local makerule="${3}"

  597. 

  598.     local pkgdir="${PAWPAW_BUILDDIR}/${name}-${version}"

  599. 

  600.     _prebuild "${name}" "${pkgdir}"

  601. 

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

  603.         pushd "${pkgdir}"

  604.         make ${MAKE_ARGS} ${makerule}

  605.         touch .stamp_custom_run

  606.         popd

  607.     fi

  608. 

  609.     _postbuild

  610. }

  611. 

  612. # ---------------------------------------------------------------------------------------------------------------------

  613. 

  614. function build_host_autoconf() {

  615.     local name="${1}"

  616.     local version="${2}"

  617.     local extraconfrules="${3}"

  618. 

  619.     local pkgdir="${PAWPAW_BUILDDIR}/${name}-${version}"

  620. 

  621.     unset AR

  622.     unset CC

  623.     unset CXX

  624.     unset LD

  625.     unset STRIP

  626.     unset CFLAGS

  627.     unset CPPFLAGS

  628.     unset CXXFLAGS

  629.     unset LDFLAGS

  630. 

  631.     if [ -d "${PAWPAW_ROOT}/patches/${name}" ] && [ ! -f "${pkgdir}/.stamp_cleanup" ]; then

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

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

  634.                 patch -p1 -d "${pkgdir}" -i "${PAWPAW_ROOT}/patches/${name}/${p}"

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

  636.             fi

  637.         done

  638.     fi

  639. 

  640.     if [ -d "${PAWPAW_ROOT}/patches/${name}/${PAWPAW_TARGET}" ] && [ ! -f "${pkgdir}/.stamp_cleanup" ]; then

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

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

  643.                 patch -p1 -d "${pkgdir}" -i "${PAWPAW_ROOT}/patches/${name}/${PAWPAW_TARGET}/${p}"

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

  645.             fi

  646.         done

  647.     fi

  648. 

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

  650.         pushd "${pkgdir}"

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

  652.         touch .stamp_configured

  653.         popd

  654.     fi

  655. 

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

  657.         pushd "${pkgdir}"

  658.         make ${MAKE_ARGS}

  659.         touch .stamp_built

  660.         popd

  661.     fi

  662. 

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

  664.         pushd "${pkgdir}"

  665.         make ${MAKE_ARGS} install -j 1

  666.         touch .stamp_installed

  667.         popd

  668.     fi

  669. }

  670. 

  671. # ---------------------------------------------------------------------------------------------------------------------

  672. 

  673. function patch_file() {

  674.     local name="${1}"

  675.     local version="${2}"

  676.     local file="${3}"

  677.     local rule="${4}"

  678. 

  679.     local pkgdir="${PAWPAW_BUILDDIR}/${name}-${version}"

  680. 

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

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

  683.     fi

  684. }

  685. 

  686. function copy_file() {

  687.     local name="${1}"

  688.     local version="${2}"

  689.     local source="${3}"

  690.     local target="${4}"

  691. 

  692.     local pkgdir="${PAWPAW_BUILDDIR}/${name}-${version}"

  693. 

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

  695.         pushd "${pkgdir}"

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

  697.         popd

  698.     fi

  699. }

  700. 

  701. function install_file() {

  702.     local name="${1}"

  703.     local version="${2}"

  704.     local source="${3}"

  705.     local targetdir="${4}"

  706. 

  707.     local pkgdir="${PAWPAW_BUILDDIR}/${name}-${version}"

  708. 

  709.     if [ ! -e "${PAWPAW_PREFIX}/${targetdir}/$(basename ${source})" ]; then

  710.         pushd "${pkgdir}"

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

  712.         popd

  713.     fi

  714. }

  715. 

  716. function link_file() {

  717.     local name="${1}"

  718.     local version="${2}"

  719.     local source="${3}"

  720.     local target="${4}"

  721. 

  722.     local pkgdir="${PAWPAW_BUILDDIR}/${name}-${version}"

  723. 

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

  725.         pushd "${pkgdir}"

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

  727.         popd

  728.     fi

  729. }

  730. 

  731. function remove_file() {

  732.     local name="${1}"

  733.     local version="${2}"

  734.     local file="${3}"

  735. 

  736.     local pkgdir="${PAWPAW_BUILDDIR}/${name}-${version}"

  737. 

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

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

  740.     fi

  741. }

  742. 

  743. # ---------------------------------------------------------------------------------------------------------------------

  744. 

  745. function patch_osx_binary_libs() {

  746.     local file="${1}"

  747. 

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

  749.         return 0

  750.     fi

  751. 

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

  753. 

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

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

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

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

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

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

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

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

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

  763.      fi

  764. }

  765. 

  766. function patch_osx_qtapp() {

  767.     local name="${1}"

  768.     local version="${2}"

  769.     local appfile="${3}"

  770. 

  771.     local pkgdir="${PAWPAW_BUILDDIR}/${name}-${version}"

  772. 

  773.     _prebuild "${name}" "${pkgdir}"

  774. 

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

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

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

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

  779. 

  780.     macdeployqt "${appfile}"

  781. 

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

  783. 

  784.     _postbuild

  785. }

  786. 

  787. # ---------------------------------------------------------------------------------------------------------------------