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

653 lines
18KB
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. # ---------------------------------------------------------------------------------------------------------------------

  75. 

  76. function _prebuild() {

  77.     local name="${1}"

  78.     local pkgdir="${2}"

  79. 

  80.     export AR="${TARGET_AR}"

  81.     export CC="${TARGET_CC}"

  82.     export CXX="${TARGET_CXX}"

  83.     export DLLWRAP="${TARGET_DLLWRAP}"

  84.     export LD="${TARGET_LD}"

  85.     export STRIP="${TARGET_STRIP}"

  86.     export WINDRES="${TARGET_WINDRES}"

  87. 

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

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

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

  91.     export PKG_CONFIG_PATH="${TARGET_PKG_CONFIG_PATH}"

  92. 

  93.     unset CPPFLAGS

  94.     export OLD_PATH="${PATH}"

  95.     export PATH="${TARGET_PATH}"

  96. 

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

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

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

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

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

  102.             fi

  103.         done

  104.     fi

  105. 

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

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

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

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

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

  111.             fi

  112.         done

  113.     fi

  114. 

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

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

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

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

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

  120. 

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

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

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

  124. 

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

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

  127. 

  128.     fi

  129. }

  130. 

  131. function _postbuild() {

  132.     unset AR

  133.     unset CC

  134.     unset CXX

  135.     unset DLLWRAP

  136.     unset LD

  137.     unset STRIP

  138.     unset WINDRES

  139. 

  140.     unset CFLAGS

  141.     unset CPPFLAGS

  142.     unset CXXFLAGS

  143.     unset LDFLAGS

  144.     unset PKG_CONFIG_PATH

  145. 

  146.     unset EXTRA_CFLAGS

  147.     unset EXTRA_CXXFLAGS

  148.     unset EXTRA_LDFLAGS

  149.     unset EXTRA_MAKE_ARGS

  150. 

  151.     export PATH="${OLD_PATH}"

  152. }

  153. 

  154. # ---------------------------------------------------------------------------------------------------------------------

  155. 

  156. function build_autoconf() {

  157.     local name="${1}"

  158.     local version="${2}"

  159.     local extraconfrules="${3}"

  160. 

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

  162. 

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

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

  165.     fi

  166. 

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

  168. 

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

  170.         pushd "${pkgdir}"

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

  172.         touch .stamp_configured

  173.         popd

  174.     fi

  175. 

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

  177.         pushd "${pkgdir}"

  178.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  179.         touch .stamp_built

  180.         popd

  181.     fi

  182. 

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

  184.         pushd "${pkgdir}"

  185.         make ${MAKE_ARGS} install -j 1

  186.         touch .stamp_installed

  187.         popd

  188.     fi

  189. 

  190.     _postbuild

  191. }

  192. 

  193. function build_autoconfgen() {

  194.     local name="${1}"

  195.     local version="${2}"

  196.     local extraconfrules="${3}"

  197. 

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

  199. 

  200.     local EXTRA_CFLAGS2="${EXTRA_CFLAGS}"

  201.     local EXTRA_CXXFLAGS2="${EXTRA_CXXFLAGS}"

  202.     local EXTRA_LDFLAGS2="${EXTRA_LDFLAGS}"

  203.     local EXTRA_MAKE_ARGS2="${EXTRA_MAKE_ARGS}"

  204. 

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

  206. 

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

  208.         pushd "${pkgdir}"

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

  210.             ./utils/autogen.sh

  211.         else

  212.             autoconf

  213.         fi

  214.         touch .stamp_preconfigured

  215.         popd

  216.     fi

  217. 

  218.     _postbuild

  219. 

  220.     export EXTRA_CFLAGS="${EXTRA_CFLAGS2}"

  221.     export EXTRA_CXXFLAGS="${EXTRA_CXXFLAGS2}"

  222.     export EXTRA_LDFLAGS="${EXTRA_LDFLAGS2}"

  223.     export EXTRA_MAKE_ARGS="${EXTRA_MAKE_ARGS2}"

  224. 

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

  226. }

  227. 

  228. function build_conf() {

  229.     local name="${1}"

  230.     local version="${2}"

  231.     local extraconfrules="${3}"

  232. 

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

  234. 

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

  236. 

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

  238.         pushd "${pkgdir}"

  239.         ./configure ${extraconfrules}

  240.         touch .stamp_configured

  241.         popd

  242.     fi

  243. 

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

  245.         pushd "${pkgdir}"

  246.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  247.         touch .stamp_built

  248.         popd

  249.     fi

  250. 

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

  252.         pushd "${pkgdir}"

  253.         make ${MAKE_ARGS} -j 1 install

  254.         touch .stamp_installed

  255.         popd

  256.     fi

  257. 

  258.     _postbuild

  259. }

  260. 

  261. function build_cmake() {

  262.     local name="${1}"

  263.     local version="${2}"

  264.     local extraconfrules="${3}"

  265. 

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

  267. 

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

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

  270. 

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

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

  273.     fi

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

  275.         if [ "${MACOS_OLD}" -eq 1 ]; then

  276.             OSX_ARCHS="i686"

  277.             OSX_TARGET="10.5"

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

  279.             OSX_ARCHS="arm64;x86_64"

  280.             OSX_TARGET="10.12"

  281.         else

  282.             OSX_ARCHS="x86_64"

  283.             OSX_TARGET="10.8"

  284.         fi

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

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

  287.     fi

  288.     if [ "${WIN32}" -eq 1 ]; then

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

  290.     fi

  291. 

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

  293.         pushd "${pkgdir}/build"

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

  295.         touch ../.stamp_configured

  296.         popd

  297.     fi

  298. 

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

  300.         pushd "${pkgdir}/build"

  301.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  302.         touch ../.stamp_built

  303.         popd

  304.     fi

  305. 

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

  307.         pushd "${pkgdir}/build"

  308.         make ${MAKE_ARGS} -j 1 install

  309.         touch ../.stamp_installed

  310.         popd

  311.     fi

  312. 

  313.     _postbuild

  314. }

  315. 

  316. function build_make() {

  317.     local name="${1}"

  318.     local version="${2}"

  319.     local extraconfrules="${3}"

  320. 

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

  322. 

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

  324. 

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

  326. 

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

  328.         pushd "${pkgdir}"

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

  330.         touch .stamp_built

  331.         popd

  332.     fi

  333. 

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

  335.         pushd "${pkgdir}"

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

  337.         touch .stamp_installed

  338.         popd

  339.     fi

  340. 

  341.     _postbuild

  342. }

  343. 

  344. function build_meson() {

  345.     local name="${1}"

  346.     local version="${2}"

  347.     local extraconfrules="${3}"

  348. 

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

  350. 

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

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

  353.     fi

  354. 

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

  356. 

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

  358.         pushd "${pkgdir}"

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

  360.         touch .stamp_configured

  361.         popd

  362.     fi

  363. 

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

  365.         pushd "${pkgdir}"

  366.         ninja -v -C build

  367.         touch .stamp_built

  368.         popd

  369.     fi

  370. 

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

  372.         pushd "${pkgdir}"

  373.         ninja -C build install

  374.         touch .stamp_installed

  375.         popd

  376.     fi

  377. 

  378.     _postbuild

  379. }

  380. 

  381. function build_python() {

  382.     local name="${1}"

  383.     local version="${2}"

  384.     local extraconfrules="${3}"

  385. 

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

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

  388. 

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

  390. 

  391.     # fix build of python packages

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

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

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

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

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

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

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

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

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

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

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

  403. 

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

  405. 

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

  407.         pushd "${pkgdir}"

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

  409.         touch .stamp_built

  410.         popd

  411.     fi

  412. 

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

  414.         pushd "${pkgdir}"

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

  416.         touch .stamp_installed

  417.         popd

  418.     fi

  419. 

  420.     _postbuild

  421. }

  422. 

  423. function build_qmake() {

  424.     local name="${1}"

  425.     local version="${2}"

  426.     local extraconfrules="${3}"

  427. 

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

  429. 

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

  431. 

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

  433.         pushd "${pkgdir}"

  434.         qmake ${extraconfrules}

  435.         touch .stamp_configured

  436.         popd

  437.     fi

  438. 

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

  440.         pushd "${pkgdir}"

  441.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  442.         touch .stamp_built

  443.         popd

  444.     fi

  445. 

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

  447.         pushd "${pkgdir}"

  448.         make ${MAKE_ARGS} -j 1 install

  449.         touch .stamp_installed

  450.         popd

  451.     fi

  452. 

  453.     _postbuild

  454. }

  455. 

  456. function build_waf() {

  457.     local name="${1}"

  458.     local version="${2}"

  459.     local extraconfrules="${3}"

  460. 

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

  462.     local python=python3

  463. 

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

  465.         python=python

  466.     fi

  467. 

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

  469. 

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

  471.         pushd "${pkgdir}"

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

  473.         touch .stamp_configured

  474.         popd

  475.     fi

  476. 

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

  478.         pushd "${pkgdir}"

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

  480.         touch .stamp_built

  481.         popd

  482.     fi

  483. 

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

  485.         pushd "${pkgdir}"

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

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

  488.         touch .stamp_installed

  489.         popd

  490.     fi

  491. 

  492.     _postbuild

  493. }

  494. 

  495. # ---------------------------------------------------------------------------------------------------------------------

  496. 

  497. function build_host_autoconf() {

  498.     local name="${1}"

  499.     local version="${2}"

  500.     local extraconfrules="${3}"

  501. 

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

  503. 

  504.     unset AR

  505.     unset CC

  506.     unset CXX

  507.     unset LD

  508.     unset STRIP

  509.     unset CFLAGS

  510.     unset CPPFLAGS

  511.     unset CXXFLAGS

  512.     unset LDFLAGS

  513. 

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

  515.         pushd "${pkgdir}"

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

  517.         touch .stamp_configured

  518.         popd

  519.     fi

  520. 

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

  522.         pushd "${pkgdir}"

  523.         make ${MAKE_ARGS}

  524.         touch .stamp_built

  525.         popd

  526.     fi

  527. 

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

  529.         pushd "${pkgdir}"

  530.         make ${MAKE_ARGS} install -j 1

  531.         touch .stamp_installed

  532.         popd

  533.     fi

  534. }

  535. 

  536. # ---------------------------------------------------------------------------------------------------------------------

  537. 

  538. function patch_file() {

  539.     local name="${1}"

  540.     local version="${2}"

  541.     local file="${3}"

  542.     local rule="${4}"

  543. 

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

  545. 

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

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

  548.     fi

  549. }

  550. 

  551. function copy_file() {

  552.     local name="${1}"

  553.     local version="${2}"

  554.     local source="${3}"

  555.     local target="${4}"

  556. 

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

  558. 

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

  560.         pushd "${pkgdir}"

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

  562.         popd

  563.     fi

  564. }

  565. 

  566. function install_file() {

  567.     local name="${1}"

  568.     local version="${2}"

  569.     local source="${3}"

  570.     local targetdir="${4}"

  571. 

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

  573. 

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

  575.         pushd "${pkgdir}"

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

  577.         popd

  578.     fi

  579. }

  580. 

  581. function link_file() {

  582.     local name="${1}"

  583.     local version="${2}"

  584.     local source="${3}"

  585.     local target="${4}"

  586. 

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

  588. 

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

  590.         pushd "${pkgdir}"

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

  592.         popd

  593.     fi

  594. }

  595. 

  596. function remove_file() {

  597.     local name="${1}"

  598.     local version="${2}"

  599.     local file="${3}"

  600. 

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

  602. 

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

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

  605.     fi

  606. }

  607. 

  608. # ---------------------------------------------------------------------------------------------------------------------

  609. 

  610. function patch_osx_binary_libs() {

  611.     local file="${1}"

  612. 

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

  614.         return 0

  615.     fi

  616. 

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

  618. 

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

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

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

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

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

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

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

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

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

  628.      fi

  629. }

  630. 

  631. function patch_osx_qtapp() {

  632.     local name="${1}"

  633.     local version="${2}"

  634.     local appfile="${3}"

  635. 

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

  637. 

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

  639. 

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

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

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

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

  644. 

  645.     macdeployqt "${appfile}"

  646. 

  647.     rm -f "${appfile}/Contents/Frameworks/libjack.0.dylib"

  648. 

  649.     _postbuild

  650. }

  651. 

  652. # ---------------------------------------------------------------------------------------------------------------------