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

799 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.     local patchtargets="${PAWPAW_TARGET}"

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

  151.         patchtargets+=" linux"

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

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

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

  155.         patchtargets+=" win32"

  156.     fi

  157.  

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

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

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

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

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

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

  164.                 fi

  165.             done

  166.         fi

  167.     done

  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 name="${1}"

  215.     local version="${2}"

  216.     local extraconfrules="${3}"

  217. 

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

  219. 

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

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

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

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

  224.     fi

  225. 

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

  227. 

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

  229.         pushd "${pkgdir}"

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

  231.         touch .stamp_configured

  232.         popd

  233.     fi

  234. 

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

  236.         pushd "${pkgdir}"

  237.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  238.         touch .stamp_built

  239.         popd

  240.     fi

  241. 

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

  243.         pushd "${pkgdir}"

  244.         make ${MAKE_ARGS} install -j 1

  245.         touch .stamp_installed

  246.         popd

  247.     fi

  248. 

  249.     _postbuild

  250. }

  251. 

  252. function build_autoconfgen() {

  253.     local name="${1}"

  254.     local version="${2}"

  255.     local extraconfrules="${3}"

  256. 

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

  258. 

  259.     local EXTRA_CFLAGS2="${EXTRA_CFLAGS}"

  260.     local EXTRA_CXXFLAGS2="${EXTRA_CXXFLAGS}"

  261.     local EXTRA_LDFLAGS2="${EXTRA_LDFLAGS}"

  262.     local EXTRA_MAKE_ARGS2="${EXTRA_MAKE_ARGS}"

  263. 

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

  265. 

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

  267.         pushd "${pkgdir}"

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

  269.             ./utils/autogen.sh

  270.         else

  271.             ${autoconf}

  272.         fi

  273.         touch .stamp_preconfigured

  274.         popd

  275.     fi

  276. 

  277.     _postbuild

  278. 

  279.     export EXTRA_CFLAGS="${EXTRA_CFLAGS2}"

  280.     export EXTRA_CXXFLAGS="${EXTRA_CXXFLAGS2}"

  281.     export EXTRA_LDFLAGS="${EXTRA_LDFLAGS2}"

  282.     export EXTRA_MAKE_ARGS="${EXTRA_MAKE_ARGS2}"

  283. 

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

  285. }

  286. 

  287. function build_conf() {

  288.     local name="${1}"

  289.     local version="${2}"

  290.     local extraconfrules="${3}"

  291. 

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

  293. 

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

  295. 

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

  297.         pushd "${pkgdir}"

  298.         ./configure ${extraconfrules}

  299.         touch .stamp_configured

  300.         popd

  301.     fi

  302. 

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

  304.         pushd "${pkgdir}"

  305.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  306.         touch .stamp_built

  307.         popd

  308.     fi

  309. 

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

  311.         pushd "${pkgdir}"

  312.         make ${MAKE_ARGS} -j 1 install

  313.         touch .stamp_installed

  314.         popd

  315.     fi

  316. 

  317.     _postbuild

  318. }

  319. 

  320. function build_cmake() {

  321.     local name="${1}"

  322.     local version="${2}"

  323.     local extraconfrules="${3}"

  324. 

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

  326. 

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

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

  329. 

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

  331.         CMAKE_EXE_WRAPPER="emcmake"

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

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

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

  335.         extraconfrules+=" -DCMAKE_CROSSCOMPILING=ON"

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

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

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

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

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

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

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

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

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

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

  346.         fi

  347.     fi

  348. 

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

  350.         extraconfrules+=" -DCMAKE_OSX_SYSROOT=macosx"

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

  352.             extraconfrules+=" -DCMAKE_OSX_DEPLOYMENT_TARGET=10.15"

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

  354.             extraconfrules+=" -DCMAKE_OSX_DEPLOYMENT_TARGET=10.12"

  355.         else

  356.             extraconfrules+=" -DCMAKE_OSX_DEPLOYMENT_TARGET=10.8"

  357.         fi

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

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

  360.         else

  361.             extraconfrules+=" -DCMAKE_OSX_ARCHITECTURES=x86_64"

  362.         fi

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

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

  365.     fi

  366. 

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

  368.         pushd "${pkgdir}/build"

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

  370.         touch ../.stamp_configured

  371.         popd

  372.     fi

  373. 

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

  375.         pushd "${pkgdir}/build"

  376.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  377.         touch ../.stamp_built

  378.         popd

  379.     fi

  380. 

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

  382.         pushd "${pkgdir}/build"

  383.         make ${MAKE_ARGS} -j 1 install

  384.         touch ../.stamp_installed

  385.         popd

  386.     fi

  387. 

  388.     _postbuild

  389. }

  390. 

  391. function build_make() {

  392.     local name="${1}"

  393.     local version="${2}"

  394.     local extraconfrules="${3}"

  395. 

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

  397. 

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

  399. 

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

  401. 

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

  403.         pushd "${pkgdir}"

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

  405.         touch .stamp_built

  406.         popd

  407.     fi

  408. 

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

  410.         pushd "${pkgdir}"

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

  412.         touch .stamp_installed

  413.         popd

  414.     fi

  415. 

  416.     _postbuild

  417. }

  418. 

  419. function build_meson() {

  420.     local name="${1}"

  421.     local version="${2}"

  422.     local extraconfrules="${3}"

  423. 

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

  425. 

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

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

  428.     fi

  429. 

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

  431. 

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

  433.         pushd "${pkgdir}"

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

  435.         touch .stamp_configured

  436.         popd

  437.     fi

  438. 

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

  440.         pushd "${pkgdir}"

  441.         ${ninja} -v -C build

  442.         touch .stamp_built

  443.         popd

  444.     fi

  445. 

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

  447.         pushd "${pkgdir}"

  448.         ${ninja} -C build install

  449.         touch .stamp_installed

  450.         popd

  451.     fi

  452. 

  453.     _postbuild

  454. }

  455. 

  456. function build_python() {

  457.     local name="${1}"

  458.     local version="${2}"

  459.     local extraconfrules="${3}"

  460. 

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

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

  463. 

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

  465. 

  466.     # remove flags not compatible with python

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  481. 

  482.     # add host/native binaries to path

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

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

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

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

  487.     fi

  488. 

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

  490. 

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

  492.         pushd "${pkgdir}"

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

  494.         touch .stamp_built

  495.         popd

  496.     fi

  497. 

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

  499.         pushd "${pkgdir}"

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

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

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

  503.         touch .stamp_installed

  504.         popd

  505.     fi

  506. 

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

  508.         unset LD_LIBRARY_PATH

  509.     fi

  510. 

  511.     _postbuild

  512. }

  513. 

  514. function build_qmake() {

  515.     local name="${1}"

  516.     local version="${2}"

  517.     local extraconfrules="${3}"

  518. 

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

  520. 

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

  522. 

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

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

  525.     #     export PKG_CONFIG_SYSROOT_DIR="/"

  526.     # fi

  527. 

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

  529.         pushd "${pkgdir}"

  530.         qmake ${extraconfrules}

  531.         touch .stamp_configured

  532.         popd

  533.     fi

  534. 

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

  536.         pushd "${pkgdir}"

  537.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  538.         touch .stamp_built

  539.         popd

  540.     fi

  541. 

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

  543.         pushd "${pkgdir}"

  544.         make ${MAKE_ARGS} -j 1 install

  545.         touch .stamp_installed

  546.         popd

  547.     fi

  548. 

  549.     # unset PKG_CONFIG_LIBDIR

  550.     # unset PKG_CONFIG_SYSROOT_DIR

  551. 

  552.     _postbuild

  553. }

  554. 

  555. function build_waf() {

  556.     local name="${1}"

  557.     local version="${2}"

  558.     local extraconfrules="${3}"

  559. 

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

  561.     local python=python3

  562. 

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

  564.         python=python

  565.     fi

  566. 

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

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

  569.     fi

  570. 

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

  572. 

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

  574.         pushd "${pkgdir}"

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

  576.         touch .stamp_configured

  577.         popd

  578.     fi

  579. 

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

  581.         pushd "${pkgdir}"

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

  583.         touch .stamp_built

  584.         popd

  585.     fi

  586. 

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

  588.         pushd "${pkgdir}"

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

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

  591.         touch .stamp_installed

  592.         popd

  593.     fi

  594. 

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

  596.         unset LD_LIBRARY_PATH

  597.     fi

  598. 

  599.     _postbuild

  600. }

  601. 

  602. # ---------------------------------------------------------------------------------------------------------------------

  603. 

  604. function run_make() {

  605.     local name="${1}"

  606.     local version="${2}"

  607.     local makerule="${3}"

  608. 

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

  610. 

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

  612. 

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

  614.         pushd "${pkgdir}"

  615.         make ${MAKE_ARGS} ${makerule}

  616.         touch .stamp_custom_run

  617.         popd

  618.     fi

  619. 

  620.     _postbuild

  621. }

  622. 

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

  624. 

  625. function build_host_autoconf() {

  626.     local name="${1}"

  627.     local version="${2}"

  628.     local extraconfrules="${3}"

  629. 

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

  631. 

  632.     unset AR

  633.     unset CC

  634.     unset CXX

  635.     unset LD

  636.     unset STRIP

  637.     unset CFLAGS

  638.     unset CPPFLAGS

  639.     unset CXXFLAGS

  640.     unset LDFLAGS

  641. 

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

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

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

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

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

  647.             fi

  648.         done

  649.     fi

  650. 

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

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

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

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

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

  656.             fi

  657.         done

  658.     fi

  659. 

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

  661.         pushd "${pkgdir}"

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

  663.         touch .stamp_configured

  664.         popd

  665.     fi

  666. 

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

  668.         pushd "${pkgdir}"

  669.         make ${MAKE_ARGS}

  670.         touch .stamp_built

  671.         popd

  672.     fi

  673. 

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

  675.         pushd "${pkgdir}"

  676.         make ${MAKE_ARGS} install -j 1

  677.         touch .stamp_installed

  678.         popd

  679.     fi

  680. }

  681. 

  682. # ---------------------------------------------------------------------------------------------------------------------

  683. 

  684. function patch_file() {

  685.     local name="${1}"

  686.     local version="${2}"

  687.     local file="${3}"

  688.     local rule="${4}"

  689. 

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

  691. 

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

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

  694.     fi

  695. }

  696. 

  697. function copy_file() {

  698.     local name="${1}"

  699.     local version="${2}"

  700.     local source="${3}"

  701.     local target="${4}"

  702. 

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

  704. 

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

  706.         pushd "${pkgdir}"

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

  708.         popd

  709.     fi

  710. }

  711. 

  712. function install_file() {

  713.     local name="${1}"

  714.     local version="${2}"

  715.     local source="${3}"

  716.     local targetdir="${4}"

  717. 

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

  719. 

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

  721.         pushd "${pkgdir}"

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

  723.         popd

  724.     fi

  725. }

  726. 

  727. function link_file() {

  728.     local name="${1}"

  729.     local version="${2}"

  730.     local source="${3}"

  731.     local target="${4}"

  732. 

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

  734. 

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

  736.         pushd "${pkgdir}"

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

  738.         popd

  739.     fi

  740. }

  741. 

  742. function remove_file() {

  743.     local name="${1}"

  744.     local version="${2}"

  745.     local file="${3}"

  746. 

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

  748. 

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

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

  751.     fi

  752. }

  753. 

  754. # ---------------------------------------------------------------------------------------------------------------------

  755. 

  756. function patch_osx_binary_libs() {

  757.     local file="${1}"

  758. 

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

  760.         return 0

  761.     fi

  762. 

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

  764. 

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

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

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

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

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

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

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

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

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

  774.      fi

  775. }

  776. 

  777. function patch_osx_qtapp() {

  778.     local name="${1}"

  779.     local version="${2}"

  780.     local appfile="${3}"

  781. 

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

  783. 

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

  785. 

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

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

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

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

  790. 

  791.     macdeployqt "${appfile}"

  792. 

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

  794. 

  795.     _postbuild

  796. }

  797. 

  798. # ---------------------------------------------------------------------------------------------------------------------