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

717 lines
20KB
Raw Blame History 

  1. #!/bin/bash

  2. 

  3. # ---------------------------------------------------------------------------------------------------------------------

  4. 

  5. function download() {

  6.     local name="${1}"

  7.     local version="${2}"

  8.     local dlbaseurl="${3}"

  9.     local dlext="${4}"

  10.     local dlmethod="${5}"

  11.     local dlname="${6}"

  12. 

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

  14.         dlext="tar.gz"

  15.     fi

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

  17.         dlname="${name}"

  18.     fi

  19. 

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

  21.     local dlfolder="${PAWPAW_BUILDDIR}/${name}-${version}"

  22. 

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

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

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

  26.             rm -rf "${tmprepodir}"

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

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

  29.             git -C "${tmprepodir}" submodule update

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

  31.             rm -rf "${tmprepodir}"

  32.         else

  33.             local dlurl

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

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

  36.                     dlurl="${dlbaseurl}/${version}.${dlext}"

  37.                 else

  38.                     dlurl="${dlbaseurl}/v${version}.${dlext}"

  39.                 fi

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

  41.                 dlurl="${dlbaseurl}/${dlname}_${version}.${dlext}"

  42.             else

  43.                 dlurl="${dlbaseurl}/${dlname}-${version}.${dlext}"

  44.             fi

  45.             curl -L "${dlurl}" -o "${dlfile}" --fail

  46.         fi

  47.     fi

  48. 

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

  50.         mkdir "${dlfolder}"

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

  52.     fi

  53. }

  54. 

  55. function copy_download() {

  56.     local name1="${1}"

  57.     local name2="${2}"

  58.     local version="${3}"

  59.     local dlext="${4}"

  60. 

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

  62.         dlext="tar.gz"

  63.     fi

  64. 

  65.     local dlfile1="${PAWPAW_DOWNLOADDIR}/${name1}-${version}.${dlext}"

  66.     local dlfolder2="${PAWPAW_BUILDDIR}/${name2}-${version}"

  67. 

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

  69.         mkdir "${dlfolder2}"

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

  71.     fi

  72. }

  73. 

  74. function git_clone() {

  75.     local name="${1}"

  76.     local hash="${2}"

  77.     local repourl="${3}"

  78.     local dlname="${4}"

  79. 

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

  81.         dlname="${name}"

  82.     fi

  83. 

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

  85.     local dlfolder="${PAWPAW_BUILDDIR}/${name}-${hash}"

  86. 

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

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

  89.         rm -rf "${tmprepodir}"

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

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

  92.         git -C "${tmprepodir}" submodule update

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

  94.         rm -rf "${tmprepodir}"

  95.     fi

  96. 

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

  98.         mkdir "${dlfolder}"

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

  100.     fi

  101. }

  102. 

  103. # ---------------------------------------------------------------------------------------------------------------------

  104. 

  105. function _prebuild() {

  106.     local name="${1}"

  107.     local pkgdir="${2}"

  108. 

  109.     export AR="${TARGET_AR}"

  110.     export CC="${TARGET_CC}"

  111.     export CXX="${TARGET_CXX}"

  112.     export DLLWRAP="${TARGET_DLLWRAP}"

  113.     export LD="${TARGET_LD}"

  114.     export NM="${TARGET_NM}"

  115.     export RANLIB="${TARGET_RANLIB}"

  116.     export STRIP="${TARGET_STRIP}"

  117.     export WINDRES="${TARGET_WINDRES}"

  118. 

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

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

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

  122.     export PKG_CONFIG_PATH="${TARGET_PKG_CONFIG_PATH}"

  123. 

  124.     unset CPPFLAGS

  125.     export OLD_PATH="${PATH}"

  126.     export PATH="${TARGET_PATH}"

  127. 

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

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

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

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

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

  133.             fi

  134.         done

  135.     fi

  136. 

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

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

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

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

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

  142.             fi

  143.         done

  144.     fi

  145. 

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

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

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

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

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

  151. 

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

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

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

  155. 

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

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

  158. 

  159.     fi

  160. }

  161. 

  162. function _postbuild() {

  163.     unset AR

  164.     unset CC

  165.     unset CXX

  166.     unset DLLWRAP

  167.     unset LD

  168.     unset NM

  169.     unset RANLIB

  170.     unset STRIP

  171.     unset WINDRES

  172. 

  173.     unset CFLAGS

  174.     unset CPPFLAGS

  175.     unset CXXFLAGS

  176.     unset LDFLAGS

  177.     unset PKG_CONFIG_PATH

  178. 

  179.     unset EXTRA_CFLAGS

  180.     unset EXTRA_CXXFLAGS

  181.     unset EXTRA_LDFLAGS

  182.     unset EXTRA_MAKE_ARGS

  183. 

  184.     export PATH="${OLD_PATH}"

  185. }

  186. 

  187. # ---------------------------------------------------------------------------------------------------------------------

  188. 

  189. function build_autoconf() {

  190.     local name="${1}"

  191.     local version="${2}"

  192.     local extraconfrules="${3}"

  193. 

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

  195. 

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

  197.         extraconfrules="--host=x86_64-linux-gnu ${extraconfrules}"

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

  199.         extraconfrules="--host=${TOOLCHAIN_PREFIX} ${extraconfrules}"

  200.     fi

  201. 

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

  203. 

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

  205.         pushd "${pkgdir}"

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

  207.         touch .stamp_configured

  208.         popd

  209.     fi

  210. 

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

  212.         pushd "${pkgdir}"

  213.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  214.         touch .stamp_built

  215.         popd

  216.     fi

  217. 

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

  219.         pushd "${pkgdir}"

  220.         make ${MAKE_ARGS} install -j 1

  221.         touch .stamp_installed

  222.         popd

  223.     fi

  224. 

  225.     _postbuild

  226. }

  227. 

  228. function build_autoconfgen() {

  229.     local name="${1}"

  230.     local version="${2}"

  231.     local extraconfrules="${3}"

  232. 

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

  234. 

  235.     local EXTRA_CFLAGS2="${EXTRA_CFLAGS}"

  236.     local EXTRA_CXXFLAGS2="${EXTRA_CXXFLAGS}"

  237.     local EXTRA_LDFLAGS2="${EXTRA_LDFLAGS}"

  238.     local EXTRA_MAKE_ARGS2="${EXTRA_MAKE_ARGS}"

  239. 

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

  241. 

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

  243.         pushd "${pkgdir}"

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

  245.             ./utils/autogen.sh

  246.         else

  247.             autoconf

  248.         fi

  249.         touch .stamp_preconfigured

  250.         popd

  251.     fi

  252. 

  253.     _postbuild

  254. 

  255.     export EXTRA_CFLAGS="${EXTRA_CFLAGS2}"

  256.     export EXTRA_CXXFLAGS="${EXTRA_CXXFLAGS2}"

  257.     export EXTRA_LDFLAGS="${EXTRA_LDFLAGS2}"

  258.     export EXTRA_MAKE_ARGS="${EXTRA_MAKE_ARGS2}"

  259. 

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

  261. }

  262. 

  263. function build_conf() {

  264.     local name="${1}"

  265.     local version="${2}"

  266.     local extraconfrules="${3}"

  267. 

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

  269. 

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

  271. 

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

  273.         pushd "${pkgdir}"

  274.         ./configure ${extraconfrules}

  275.         touch .stamp_configured

  276.         popd

  277.     fi

  278. 

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

  280.         pushd "${pkgdir}"

  281.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  282.         touch .stamp_built

  283.         popd

  284.     fi

  285. 

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

  287.         pushd "${pkgdir}"

  288.         make ${MAKE_ARGS} -j 1 install

  289.         touch .stamp_installed

  290.         popd

  291.     fi

  292. 

  293.     _postbuild

  294. }

  295. 

  296. function build_cmake() {

  297.     local name="${1}"

  298.     local version="${2}"

  299.     local extraconfrules="${3}"

  300. 

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

  302. 

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

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

  305. 

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

  307.         CMAKE_EXE_WRAPPER="emcmake"

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

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

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

  311.         extraconfrules+=" -DCMAKE_CROSSCOMPILING=ON"

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

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

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

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

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

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

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

  319.     fi

  320. 

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

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

  323.             OSX_ARCHS="arm64;x86_64"

  324.             OSX_TARGET="10.12"

  325.         else

  326.             OSX_ARCHS="x86_64"

  327.             OSX_TARGET="10.8"

  328.         fi

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

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

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

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

  333.     fi

  334. 

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

  336.         pushd "${pkgdir}/build"

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

  338.         touch ../.stamp_configured

  339.         popd

  340.     fi

  341. 

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

  343.         pushd "${pkgdir}/build"

  344.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  345.         touch ../.stamp_built

  346.         popd

  347.     fi

  348. 

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

  350.         pushd "${pkgdir}/build"

  351.         make ${MAKE_ARGS} -j 1 install

  352.         touch ../.stamp_installed

  353.         popd

  354.     fi

  355. 

  356.     _postbuild

  357. }

  358. 

  359. function build_make() {

  360.     local name="${1}"

  361.     local version="${2}"

  362.     local extraconfrules="${3}"

  363. 

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

  365. 

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

  367. 

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

  369. 

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

  371.         pushd "${pkgdir}"

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

  373.         touch .stamp_built

  374.         popd

  375.     fi

  376. 

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

  378.         pushd "${pkgdir}"

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

  380.         touch .stamp_installed

  381.         popd

  382.     fi

  383. 

  384.     _postbuild

  385. }

  386. 

  387. function build_meson() {

  388.     local name="${1}"

  389.     local version="${2}"

  390.     local extraconfrules="${3}"

  391. 

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

  393. 

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

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

  396.     fi

  397. 

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

  399. 

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

  401.         pushd "${pkgdir}"

  402.         meson build --buildtype release --prefix "${PAWPAW_PREFIX}" ${extraconfrules}

  403.         touch .stamp_configured

  404.         popd

  405.     fi

  406. 

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

  408.         pushd "${pkgdir}"

  409.         ninja -v -C build

  410.         touch .stamp_built

  411.         popd

  412.     fi

  413. 

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

  415.         pushd "${pkgdir}"

  416.         ninja -C build install

  417.         touch .stamp_installed

  418.         popd

  419.     fi

  420. 

  421.     _postbuild

  422. }

  423. 

  424. function build_python() {

  425.     local name="${1}"

  426.     local version="${2}"

  427.     local extraconfrules="${3}"

  428. 

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

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

  431. 

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

  433. 

  434.     # fix build of python packages

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

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

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

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

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

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

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

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

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

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

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

  446. 

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

  448. 

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

  450.         pushd "${pkgdir}"

  451.         ${python} setup.py build ${extraconfrules} --verbose

  452.         touch .stamp_built

  453.         popd

  454.     fi

  455. 

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

  457.         pushd "${pkgdir}"

  458.         ${python} setup.py install --prefix="${PAWPAW_PREFIX}" ${extraconfrules} --verbose

  459.         touch .stamp_installed

  460.         popd

  461.     fi

  462. 

  463.     _postbuild

  464. }

  465. 

  466. function build_qmake() {

  467.     local name="${1}"

  468.     local version="${2}"

  469.     local extraconfrules="${3}"

  470. 

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

  472. 

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

  474. 

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

  476.         pushd "${pkgdir}"

  477.         qmake ${extraconfrules}

  478.         touch .stamp_configured

  479.         popd

  480.     fi

  481. 

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

  483.         pushd "${pkgdir}"

  484.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  485.         touch .stamp_built

  486.         popd

  487.     fi

  488. 

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

  490.         pushd "${pkgdir}"

  491.         make ${MAKE_ARGS} -j 1 install

  492.         touch .stamp_installed

  493.         popd

  494.     fi

  495. 

  496.     _postbuild

  497. }

  498. 

  499. function build_waf() {

  500.     local name="${1}"

  501.     local version="${2}"

  502.     local extraconfrules="${3}"

  503. 

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

  505.     local python=python3

  506. 

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

  508.         python=python

  509.     fi

  510. 

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

  512. 

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

  514.         pushd "${pkgdir}"

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

  516.         touch .stamp_configured

  517.         popd

  518.     fi

  519. 

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

  521.         pushd "${pkgdir}"

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

  523.         touch .stamp_built

  524.         popd

  525.     fi

  526. 

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

  528.         pushd "${pkgdir}"

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

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

  531.         touch .stamp_installed

  532.         popd

  533.     fi

  534. 

  535.     _postbuild

  536. }

  537. 

  538. # ---------------------------------------------------------------------------------------------------------------------

  539. 

  540. function run_make() {

  541.     local name="${1}"

  542.     local version="${2}"

  543.     local makerule="${3}"

  544. 

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

  546. 

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

  548. 

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

  550.         pushd "${pkgdir}"

  551.         make ${MAKE_ARGS} ${makerule}

  552.         touch .stamp_custom_run

  553.         popd

  554.     fi

  555. 

  556.     _postbuild

  557. }

  558. 

  559. # ---------------------------------------------------------------------------------------------------------------------

  560. 

  561. function build_host_autoconf() {

  562.     local name="${1}"

  563.     local version="${2}"

  564.     local extraconfrules="${3}"

  565. 

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

  567. 

  568.     unset AR

  569.     unset CC

  570.     unset CXX

  571.     unset LD

  572.     unset STRIP

  573.     unset CFLAGS

  574.     unset CPPFLAGS

  575.     unset CXXFLAGS

  576.     unset LDFLAGS

  577. 

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

  579.         pushd "${pkgdir}"

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

  581.         touch .stamp_configured

  582.         popd

  583.     fi

  584. 

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

  586.         pushd "${pkgdir}"

  587.         make ${MAKE_ARGS}

  588.         touch .stamp_built

  589.         popd

  590.     fi

  591. 

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

  593.         pushd "${pkgdir}"

  594.         make ${MAKE_ARGS} install -j 1

  595.         touch .stamp_installed

  596.         popd

  597.     fi

  598. }

  599. 

  600. # ---------------------------------------------------------------------------------------------------------------------

  601. 

  602. function patch_file() {

  603.     local name="${1}"

  604.     local version="${2}"

  605.     local file="${3}"

  606.     local rule="${4}"

  607. 

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

  609. 

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

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

  612.     fi

  613. }

  614. 

  615. function copy_file() {

  616.     local name="${1}"

  617.     local version="${2}"

  618.     local source="${3}"

  619.     local target="${4}"

  620. 

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

  622. 

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

  624.         pushd "${pkgdir}"

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

  626.         popd

  627.     fi

  628. }

  629. 

  630. function install_file() {

  631.     local name="${1}"

  632.     local version="${2}"

  633.     local source="${3}"

  634.     local targetdir="${4}"

  635. 

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

  637. 

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

  639.         pushd "${pkgdir}"

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

  641.         popd

  642.     fi

  643. }

  644. 

  645. function link_file() {

  646.     local name="${1}"

  647.     local version="${2}"

  648.     local source="${3}"

  649.     local target="${4}"

  650. 

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

  652. 

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

  654.         pushd "${pkgdir}"

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

  656.         popd

  657.     fi

  658. }

  659. 

  660. function remove_file() {

  661.     local name="${1}"

  662.     local version="${2}"

  663.     local file="${3}"

  664. 

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

  666. 

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

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

  669.     fi

  670. }

  671. 

  672. # ---------------------------------------------------------------------------------------------------------------------

  673. 

  674. function patch_osx_binary_libs() {

  675.     local file="${1}"

  676. 

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

  678.         return 0

  679.     fi

  680. 

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

  682. 

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

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

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

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

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

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

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

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

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

  692.      fi

  693. }

  694. 

  695. function patch_osx_qtapp() {

  696.     local name="${1}"

  697.     local version="${2}"

  698.     local appfile="${3}"

  699. 

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

  701. 

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

  703. 

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

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

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

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

  708. 

  709.     macdeployqt "${appfile}"

  710. 

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

  712. 

  713.     _postbuild

  714. }

  715. 

  716. # ---------------------------------------------------------------------------------------------------------------------