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

700 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 STRIP="${TARGET_STRIP}"

  115.     export WINDRES="${TARGET_WINDRES}"

  116. 

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

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

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

  120.     export PKG_CONFIG_PATH="${TARGET_PKG_CONFIG_PATH}"

  121. 

  122.     unset CPPFLAGS

  123.     export OLD_PATH="${PATH}"

  124.     export PATH="${TARGET_PATH}"

  125. 

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

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

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

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

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

  131.             fi

  132.         done

  133.     fi

  134. 

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

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

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

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

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

  140.             fi

  141.         done

  142.     fi

  143. 

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

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

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

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

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

  149. 

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

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

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

  153. 

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

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

  156. 

  157.     fi

  158. }

  159. 

  160. function _postbuild() {

  161.     unset AR

  162.     unset CC

  163.     unset CXX

  164.     unset DLLWRAP

  165.     unset LD

  166.     unset STRIP

  167.     unset WINDRES

  168. 

  169.     unset CFLAGS

  170.     unset CPPFLAGS

  171.     unset CXXFLAGS

  172.     unset LDFLAGS

  173.     unset PKG_CONFIG_PATH

  174. 

  175.     unset EXTRA_CFLAGS

  176.     unset EXTRA_CXXFLAGS

  177.     unset EXTRA_LDFLAGS

  178.     unset EXTRA_MAKE_ARGS

  179. 

  180.     export PATH="${OLD_PATH}"

  181. }

  182. 

  183. # ---------------------------------------------------------------------------------------------------------------------

  184. 

  185. function build_autoconf() {

  186.     local name="${1}"

  187.     local version="${2}"

  188.     local extraconfrules="${3}"

  189. 

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

  191. 

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

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

  194.     fi

  195. 

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

  197. 

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

  199.         pushd "${pkgdir}"

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

  201.         touch .stamp_configured

  202.         popd

  203.     fi

  204. 

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

  206.         pushd "${pkgdir}"

  207.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  208.         touch .stamp_built

  209.         popd

  210.     fi

  211. 

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

  213.         pushd "${pkgdir}"

  214.         make ${MAKE_ARGS} install -j 1

  215.         touch .stamp_installed

  216.         popd

  217.     fi

  218. 

  219.     _postbuild

  220. }

  221. 

  222. function build_autoconfgen() {

  223.     local name="${1}"

  224.     local version="${2}"

  225.     local extraconfrules="${3}"

  226. 

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

  228. 

  229.     local EXTRA_CFLAGS2="${EXTRA_CFLAGS}"

  230.     local EXTRA_CXXFLAGS2="${EXTRA_CXXFLAGS}"

  231.     local EXTRA_LDFLAGS2="${EXTRA_LDFLAGS}"

  232.     local EXTRA_MAKE_ARGS2="${EXTRA_MAKE_ARGS}"

  233. 

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

  235. 

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

  237.         pushd "${pkgdir}"

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

  239.             ./utils/autogen.sh

  240.         else

  241.             autoconf

  242.         fi

  243.         touch .stamp_preconfigured

  244.         popd

  245.     fi

  246. 

  247.     _postbuild

  248. 

  249.     export EXTRA_CFLAGS="${EXTRA_CFLAGS2}"

  250.     export EXTRA_CXXFLAGS="${EXTRA_CXXFLAGS2}"

  251.     export EXTRA_LDFLAGS="${EXTRA_LDFLAGS2}"

  252.     export EXTRA_MAKE_ARGS="${EXTRA_MAKE_ARGS2}"

  253. 

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

  255. }

  256. 

  257. function build_conf() {

  258.     local name="${1}"

  259.     local version="${2}"

  260.     local extraconfrules="${3}"

  261. 

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

  263. 

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

  265. 

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

  267.         pushd "${pkgdir}"

  268.         ./configure ${extraconfrules}

  269.         touch .stamp_configured

  270.         popd

  271.     fi

  272. 

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

  274.         pushd "${pkgdir}"

  275.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  276.         touch .stamp_built

  277.         popd

  278.     fi

  279. 

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

  281.         pushd "${pkgdir}"

  282.         make ${MAKE_ARGS} -j 1 install

  283.         touch .stamp_installed

  284.         popd

  285.     fi

  286. 

  287.     _postbuild

  288. }

  289. 

  290. function build_cmake() {

  291.     local name="${1}"

  292.     local version="${2}"

  293.     local extraconfrules="${3}"

  294. 

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

  296. 

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

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

  299. 

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

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

  302.     fi

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

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

  305.             OSX_ARCHS="arm64;x86_64"

  306.             OSX_TARGET="10.12"

  307.         else

  308.             OSX_ARCHS="x86_64"

  309.             OSX_TARGET="10.8"

  310.         fi

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

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

  313.     fi

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

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

  316.     fi

  317. 

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

  319.         pushd "${pkgdir}/build"

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

  321.         touch ../.stamp_configured

  322.         popd

  323.     fi

  324. 

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

  326.         pushd "${pkgdir}/build"

  327.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  328.         touch ../.stamp_built

  329.         popd

  330.     fi

  331. 

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

  333.         pushd "${pkgdir}/build"

  334.         make ${MAKE_ARGS} -j 1 install

  335.         touch ../.stamp_installed

  336.         popd

  337.     fi

  338. 

  339.     _postbuild

  340. }

  341. 

  342. function build_make() {

  343.     local name="${1}"

  344.     local version="${2}"

  345.     local extraconfrules="${3}"

  346. 

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

  348. 

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

  350. 

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

  352. 

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

  354.         pushd "${pkgdir}"

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

  356.         touch .stamp_built

  357.         popd

  358.     fi

  359. 

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

  361.         pushd "${pkgdir}"

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

  363.         touch .stamp_installed

  364.         popd

  365.     fi

  366. 

  367.     _postbuild

  368. }

  369. 

  370. function build_meson() {

  371.     local name="${1}"

  372.     local version="${2}"

  373.     local extraconfrules="${3}"

  374. 

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

  376. 

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

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

  379.     fi

  380. 

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

  382. 

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

  384.         pushd "${pkgdir}"

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

  386.         touch .stamp_configured

  387.         popd

  388.     fi

  389. 

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

  391.         pushd "${pkgdir}"

  392.         ninja -v -C build

  393.         touch .stamp_built

  394.         popd

  395.     fi

  396. 

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

  398.         pushd "${pkgdir}"

  399.         ninja -C build install

  400.         touch .stamp_installed

  401.         popd

  402.     fi

  403. 

  404.     _postbuild

  405. }

  406. 

  407. function build_python() {

  408.     local name="${1}"

  409.     local version="${2}"

  410.     local extraconfrules="${3}"

  411. 

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

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

  414. 

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

  416. 

  417.     # fix build of python packages

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

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

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

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

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

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

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

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

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

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

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

  429. 

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

  431. 

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

  433.         pushd "${pkgdir}"

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

  435.         touch .stamp_built

  436.         popd

  437.     fi

  438. 

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

  440.         pushd "${pkgdir}"

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

  442.         touch .stamp_installed

  443.         popd

  444.     fi

  445. 

  446.     _postbuild

  447. }

  448. 

  449. function build_qmake() {

  450.     local name="${1}"

  451.     local version="${2}"

  452.     local extraconfrules="${3}"

  453. 

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

  455. 

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

  457. 

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

  459.         pushd "${pkgdir}"

  460.         qmake ${extraconfrules}

  461.         touch .stamp_configured

  462.         popd

  463.     fi

  464. 

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

  466.         pushd "${pkgdir}"

  467.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  468.         touch .stamp_built

  469.         popd

  470.     fi

  471. 

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

  473.         pushd "${pkgdir}"

  474.         make ${MAKE_ARGS} -j 1 install

  475.         touch .stamp_installed

  476.         popd

  477.     fi

  478. 

  479.     _postbuild

  480. }

  481. 

  482. function build_waf() {

  483.     local name="${1}"

  484.     local version="${2}"

  485.     local extraconfrules="${3}"

  486. 

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

  488.     local python=python3

  489. 

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

  491.         python=python

  492.     fi

  493. 

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

  495. 

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

  497.         pushd "${pkgdir}"

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

  499.         touch .stamp_configured

  500.         popd

  501.     fi

  502. 

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

  504.         pushd "${pkgdir}"

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

  506.         touch .stamp_built

  507.         popd

  508.     fi

  509. 

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

  511.         pushd "${pkgdir}"

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

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

  514.         touch .stamp_installed

  515.         popd

  516.     fi

  517. 

  518.     _postbuild

  519. }

  520. 

  521. # ---------------------------------------------------------------------------------------------------------------------

  522. 

  523. function run_make() {

  524.     local name="${1}"

  525.     local version="${2}"

  526.     local makerule="${3}"

  527. 

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

  529. 

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

  531. 

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

  533.         pushd "${pkgdir}"

  534.         make ${MAKE_ARGS} ${makerule}

  535.         touch .stamp_custom_run

  536.         popd

  537.     fi

  538. 

  539.     _postbuild

  540. }

  541. 

  542. # ---------------------------------------------------------------------------------------------------------------------

  543. 

  544. function build_host_autoconf() {

  545.     local name="${1}"

  546.     local version="${2}"

  547.     local extraconfrules="${3}"

  548. 

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

  550. 

  551.     unset AR

  552.     unset CC

  553.     unset CXX

  554.     unset LD

  555.     unset STRIP

  556.     unset CFLAGS

  557.     unset CPPFLAGS

  558.     unset CXXFLAGS

  559.     unset LDFLAGS

  560. 

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

  562.         pushd "${pkgdir}"

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

  564.         touch .stamp_configured

  565.         popd

  566.     fi

  567. 

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

  569.         pushd "${pkgdir}"

  570.         make ${MAKE_ARGS}

  571.         touch .stamp_built

  572.         popd

  573.     fi

  574. 

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

  576.         pushd "${pkgdir}"

  577.         make ${MAKE_ARGS} install -j 1

  578.         touch .stamp_installed

  579.         popd

  580.     fi

  581. }

  582. 

  583. # ---------------------------------------------------------------------------------------------------------------------

  584. 

  585. function patch_file() {

  586.     local name="${1}"

  587.     local version="${2}"

  588.     local file="${3}"

  589.     local rule="${4}"

  590. 

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

  592. 

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

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

  595.     fi

  596. }

  597. 

  598. function copy_file() {

  599.     local name="${1}"

  600.     local version="${2}"

  601.     local source="${3}"

  602.     local target="${4}"

  603. 

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

  605. 

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

  607.         pushd "${pkgdir}"

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

  609.         popd

  610.     fi

  611. }

  612. 

  613. function install_file() {

  614.     local name="${1}"

  615.     local version="${2}"

  616.     local source="${3}"

  617.     local targetdir="${4}"

  618. 

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

  620. 

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

  622.         pushd "${pkgdir}"

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

  624.         popd

  625.     fi

  626. }

  627. 

  628. function link_file() {

  629.     local name="${1}"

  630.     local version="${2}"

  631.     local source="${3}"

  632.     local target="${4}"

  633. 

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

  635. 

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

  637.         pushd "${pkgdir}"

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

  639.         popd

  640.     fi

  641. }

  642. 

  643. function remove_file() {

  644.     local name="${1}"

  645.     local version="${2}"

  646.     local file="${3}"

  647. 

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

  649. 

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

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

  652.     fi

  653. }

  654. 

  655. # ---------------------------------------------------------------------------------------------------------------------

  656. 

  657. function patch_osx_binary_libs() {

  658.     local file="${1}"

  659. 

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

  661.         return 0

  662.     fi

  663. 

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

  665. 

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

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

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

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

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

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

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

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

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

  675.      fi

  676. }

  677. 

  678. function patch_osx_qtapp() {

  679.     local name="${1}"

  680.     local version="${2}"

  681.     local appfile="${3}"

  682. 

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

  684. 

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

  686. 

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

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

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

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

  691. 

  692.     macdeployqt "${appfile}"

  693. 

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

  695. 

  696.     _postbuild

  697. }

  698. 

  699. # ---------------------------------------------------------------------------------------------------------------------