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

509 lines
13KB
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. 

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

  13.         dlext="tar.gz"

  14.     fi

  15. 

  16.     local dlfile="${PAWPAW_DOWNLOADDIR}/${name}-${version}.${dlext}"

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

  18. 

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

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

  21.             local tmprepodir="${PAWPAW_TMPDIR}/${name}-${version}"

  22.             rm -rf "${tmprepodir}"

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

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

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

  26.             tar --exclude=".git" -czf "${dlfile}" -C "${PAWPAW_TMPDIR}" "${name}-${version}"

  27.             rm -rf "${tmprepodir}"

  28.         else

  29.             local dlurl

  30.             if echo ${dlbaseurl} | grep -q github.com; then

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

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

  33.                 dlurl="${dlbaseurl}/${name}_${version}.${dlext}"

  34.             else

  35.                 dlurl="${dlbaseurl}/${name}-${version}.${dlext}"

  36.             fi

  37.             curl -L "${dlurl}" -o "${dlfile}"

  38.         fi

  39.     fi

  40. 

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

  42.         mkdir "${dlfolder}"

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

  44.     fi

  45. }

  46. 

  47. function copy_download() {

  48.     local name1="${1}"

  49.     local name2="${2}"

  50.     local version="${3}"

  51.     local dlext="${4}"

  52. 

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

  54.         dlext="tar.gz"

  55.     fi

  56. 

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

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

  59. 

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

  61.         mkdir "${dlfolder2}"

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

  63.     fi

  64. }

  65. 

  66. # ---------------------------------------------------------------------------------------------------------------------

  67. 

  68. function _prebuild() {

  69.     local name="${1}"

  70.     local pkgdir="${2}"

  71. 

  72.     export AR="${TARGET_AR}"

  73.     export CC="${TARGET_CC}"

  74.     export CXX="${TARGET_CXX}"

  75.     export LD="${TARGET_LD}"

  76.     export STRIP="${TARGET_STRIP}"

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

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

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

  80.     export PKG_CONFIG_PATH="${TARGET_PKG_CONFIG_PATH}"

  81. 

  82.     unset CPPFLAGS

  83.     export OLD_PATH="${PATH}"

  84.     export PATH="${TARGET_PATH}"

  85. 

  86.     if [ -d "${PAWPAW_ROOT}/patches/${name}" ]; then

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

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

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

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

  91.             fi

  92.         done

  93.     fi

  94. 

  95.     if [ -d "${PAWPAW_ROOT}/patches/${name}/${PAWPAW_TARGET}" ]; then

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

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

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

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

  100.             fi

  101.         done

  102.     fi

  103. 

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

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

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

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

  108. 

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

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

  111. 

  112.     fi

  113. }

  114. 

  115. function _postbuild() {

  116.     unset AR

  117.     unset CC

  118.     unset CXX

  119.     unset LD

  120.     unset STRIP

  121.     unset CFLAGS

  122.     unset CPPFLAGS

  123.     unset CXXFLAGS

  124.     unset LDFLAGS

  125.     unset PKG_CONFIG_PATH

  126. 

  127.     unset EXTRA_CFLAGS

  128.     unset EXTRA_CXXFLAGS

  129.     unset EXTRA_LDFLAGS

  130.     unset EXTRA_MAKE_ARGS

  131. 

  132.     export PATH="${OLD_PATH}"

  133. }

  134. 

  135. # ---------------------------------------------------------------------------------------------------------------------

  136. 

  137. function build_autoconf() {

  138.     local name="${1}"

  139.     local version="${2}"

  140.     local extraconfrules="${3}"

  141. 

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

  143. 

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

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

  146.     fi

  147. 

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

  149. 

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

  151.         pushd "${pkgdir}"

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

  153.         touch .stamp_configured

  154.         popd

  155.     fi

  156. 

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

  158.         pushd "${pkgdir}"

  159.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  160.         touch .stamp_built

  161.         popd

  162.     fi

  163. 

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

  165.         pushd "${pkgdir}"

  166.         make ${MAKE_ARGS} install -j 1

  167.         touch .stamp_installed

  168.         popd

  169.     fi

  170. 

  171.     _postbuild

  172. }

  173. 

  174. function build_autoconfgen() {

  175.     local name="${1}"

  176.     local version="${2}"

  177.     local extraconfrules="${3}"

  178. 

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

  180. 

  181.     local EXTRA_CFLAGS2="${EXTRA_CFLAGS}"

  182.     local EXTRA_CXXFLAGS2="${EXTRA_CXXFLAGS}"

  183.     local EXTRA_LDFLAGS2="${EXTRA_LDFLAGS}"

  184.     local EXTRA_MAKE_ARGS2="${EXTRA_MAKE_ARGS}"

  185. 

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

  187. 

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

  189.         pushd "${pkgdir}"

  190.         autoconf

  191.         touch .stamp_preconfigured

  192.         popd

  193.     fi

  194. 

  195.     _postbuild

  196. 

  197.     export EXTRA_CFLAGS="${EXTRA_CFLAGS2}"

  198.     export EXTRA_CXXFLAGS="${EXTRA_CXXFLAGS2}"

  199.     export EXTRA_LDFLAGS="${EXTRA_LDFLAGS2}"

  200.     export EXTRA_MAKE_ARGS="${EXTRA_MAKE_ARGS2}"

  201. 

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

  203. }

  204. 

  205. function build_conf() {

  206.     local name="${1}"

  207.     local version="${2}"

  208.     local extraconfrules="${3}"

  209. 

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

  211. 

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

  213. 

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

  215.         pushd "${pkgdir}"

  216.         ./configure ${extraconfrules}

  217.         touch .stamp_configured

  218.         popd

  219.     fi

  220. 

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

  222.         pushd "${pkgdir}"

  223.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  224.         touch .stamp_built

  225.         popd

  226.     fi

  227. 

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

  229.         pushd "${pkgdir}"

  230.         make ${MAKE_ARGS} -j 1 install

  231.         touch .stamp_installed

  232.         popd

  233.     fi

  234. 

  235.     _postbuild

  236. }

  237. 

  238. function build_cmake() {

  239.     local name="${1}"

  240.     local version="${2}"

  241.     local extraconfrules="${3}"

  242. 

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

  244. 

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

  246.         extraconfrules="-DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME} ${extraconfrules}"

  247.     fi

  248. 

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

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

  251. 

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

  253.         pushd "${pkgdir}/build"

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

  255.         touch ../.stamp_configured

  256.         popd

  257.     fi

  258. 

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

  260.         pushd "${pkgdir}/build"

  261.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  262.         touch ../.stamp_built

  263.         popd

  264.     fi

  265. 

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

  267.         pushd "${pkgdir}/build"

  268.         make ${MAKE_ARGS} -j 1 install

  269.         touch ../.stamp_installed

  270.         popd

  271.     fi

  272. 

  273.     _postbuild

  274. }

  275. 

  276. function build_make() {

  277.     local name="${1}"

  278.     local version="${2}"

  279.     local extraconfrules="${3}"

  280. 

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

  282. 

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

  284. 

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

  286. 

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

  288.         pushd "${pkgdir}"

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

  290.         touch .stamp_built

  291.         popd

  292.     fi

  293. 

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

  295.         pushd "${pkgdir}"

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

  297.         touch .stamp_installed

  298.         popd

  299.     fi

  300. 

  301.     _postbuild

  302. }

  303. 

  304. function build_meson() {

  305.     local name="${1}"

  306.     local version="${2}"

  307.     local extraconfrules="${3}"

  308. 

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

  310. 

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

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

  313.     fi

  314. 

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

  316. 

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

  318.         pushd "${pkgdir}"

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

  320.         touch .stamp_configured

  321.         popd

  322.     fi

  323. 

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

  325.         pushd "${pkgdir}"

  326.         ninja -v -C build

  327.         touch .stamp_built

  328.         popd

  329.     fi

  330. 

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

  332.         pushd "${pkgdir}"

  333.         ninja -C build install

  334.         touch .stamp_installed

  335.         popd

  336.     fi

  337. 

  338.     _postbuild

  339. }

  340. 

  341. function build_qmake() {

  342.     local name="${1}"

  343.     local version="${2}"

  344.     local extraconfrules="${3}"

  345. 

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

  347. 

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

  349. 

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

  351.         pushd "${pkgdir}"

  352.         qmake ${extraconfrules}

  353.         touch .stamp_configured

  354.         popd

  355.     fi

  356. 

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

  358.         pushd "${pkgdir}"

  359.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  360.         touch .stamp_built

  361.         popd

  362.     fi

  363. 

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

  365.         pushd "${pkgdir}"

  366.         make ${MAKE_ARGS} -j 1 install

  367.         touch .stamp_installed

  368.         popd

  369.     fi

  370. 

  371.     _postbuild

  372. }

  373. 

  374. function build_waf() {

  375.     local name="${1}"

  376.     local version="${2}"

  377.     local extraconfrules="${3}"

  378. 

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

  380.     local python=python3

  381. 

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

  383.         python=python

  384.     fi

  385. 

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

  387. 

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

  389.         pushd "${pkgdir}"

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

  391.         touch .stamp_configured

  392.         popd

  393.     fi

  394. 

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

  396.         pushd "${pkgdir}"

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

  398.         touch .stamp_built

  399.         popd

  400.     fi

  401. 

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

  403.         pushd "${pkgdir}"

  404.         ${python} waf install ${WAF_ARGS} -j 1

  405.         touch .stamp_installed

  406.         popd

  407.     fi

  408. 

  409.     _postbuild

  410. }

  411. 

  412. # ---------------------------------------------------------------------------------------------------------------------

  413. 

  414. function build_host_autoconf() {

  415.     local name="${1}"

  416.     local version="${2}"

  417.     local extraconfrules="${3}"

  418. 

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

  420. 

  421.     unset AR

  422.     unset CC

  423.     unset CXX

  424.     unset LD

  425.     unset STRIP

  426.     unset CFLAGS

  427.     unset CPPFLAGS

  428.     unset CXXFLAGS

  429.     unset LDFLAGS

  430. 

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

  432.         pushd "${pkgdir}"

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

  434.         touch .stamp_configured

  435.         popd

  436.     fi

  437. 

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

  439.         pushd "${pkgdir}"

  440.         make ${MAKE_ARGS}

  441.         touch .stamp_built

  442.         popd

  443.     fi

  444. 

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

  446.         pushd "${pkgdir}"

  447.         make ${MAKE_ARGS} install -j 1

  448.         touch .stamp_installed

  449.         popd

  450.     fi

  451. }

  452. 

  453. # ---------------------------------------------------------------------------------------------------------------------

  454. 

  455. function patch_file() {

  456.     local name="${1}"

  457.     local version="${2}"

  458.     local file="${3}"

  459.     local rule="${4}"

  460. 

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

  462. 

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

  464. }

  465. 

  466. function copy_file() {

  467.     local name="${1}"

  468.     local version="${2}"

  469.     local source="${3}"

  470.     local target="${4}"

  471. 

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

  473. 

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

  475.         pushd "${pkgdir}"

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

  477.         popd

  478.     fi

  479. }

  480. 

  481. function link_file() {

  482.     local name="${1}"

  483.     local version="${2}"

  484.     local source="${3}"

  485.     local target="${4}"

  486. 

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

  488. 

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

  490.         pushd "${pkgdir}"

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

  492.         popd

  493.     fi

  494. }

  495. 

  496. function remove_file() {

  497.     local name="${1}"

  498.     local version="${2}"

  499.     local file="${3}"

  500. 

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

  502. 

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

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

  505.     fi

  506. }

  507. 

  508. # ---------------------------------------------------------------------------------------------------------------------