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

492 lines
12KB
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 [ ! -f "${pkgdir}/.stamp_configured" ]; then

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

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

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

  99. 

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

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

  102. 

  103.     fi

  104. }

  105. 

  106. function _postbuild() {

  107.     unset AR

  108.     unset CC

  109.     unset CXX

  110.     unset LD

  111.     unset STRIP

  112.     unset CFLAGS

  113.     unset CPPFLAGS

  114.     unset CXXFLAGS

  115.     unset LDFLAGS

  116.     unset PKG_CONFIG_PATH

  117. 

  118.     unset EXTRA_CFLAGS

  119.     unset EXTRA_CXXFLAGS

  120.     unset EXTRA_LDFLAGS

  121.     unset EXTRA_MAKE_ARGS

  122. 

  123.     export PATH="${OLD_PATH}"

  124. }

  125. 

  126. # ---------------------------------------------------------------------------------------------------------------------

  127. 

  128. function build_autoconf() {

  129.     local name="${1}"

  130.     local version="${2}"

  131.     local extraconfrules="${3}"

  132. 

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

  134. 

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

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

  137.     fi

  138. 

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

  140. 

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

  142.         pushd "${pkgdir}"

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

  144.         touch .stamp_configured

  145.         popd

  146.     fi

  147. 

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

  149.         pushd "${pkgdir}"

  150.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  151.         touch .stamp_built

  152.         popd

  153.     fi

  154. 

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

  156.         pushd "${pkgdir}"

  157.         make ${MAKE_ARGS} install -j 1

  158.         touch .stamp_installed

  159.         popd

  160.     fi

  161. 

  162.     _postbuild

  163. }

  164. 

  165. function build_autoconfgen() {

  166.     local name="${1}"

  167.     local version="${2}"

  168.     local extraconfrules="${3}"

  169. 

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

  171. 

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

  173. 

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

  175.         pushd "${pkgdir}"

  176. #         autoreconf --force --install --verbose

  177. #         ./autogen.sh

  178.         autoconf

  179.         touch .stamp_preconfigured

  180.         popd

  181.     fi

  182. 

  183.     _postbuild

  184. 

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

  186. }

  187. 

  188. function build_conf() {

  189.     local name="${1}"

  190.     local version="${2}"

  191.     local extraconfrules="${3}"

  192. 

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

  194. 

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

  196. 

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

  198.         pushd "${pkgdir}"

  199.         ./configure ${extraconfrules}

  200.         touch .stamp_configured

  201.         popd

  202.     fi

  203. 

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

  205.         pushd "${pkgdir}"

  206.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  207.         touch .stamp_built

  208.         popd

  209.     fi

  210. 

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

  212.         pushd "${pkgdir}"

  213.         make ${MAKE_ARGS} -j 1 install

  214.         touch .stamp_installed

  215.         popd

  216.     fi

  217. 

  218.     _postbuild

  219. }

  220. 

  221. function build_cmake() {

  222.     local name="${1}"

  223.     local version="${2}"

  224.     local extraconfrules="${3}"

  225. 

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

  227. 

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

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

  230.     fi

  231. 

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

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

  234. 

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

  236.         pushd "${pkgdir}/build"

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

  238.         touch ../.stamp_configured

  239.         popd

  240.     fi

  241. 

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

  243.         pushd "${pkgdir}/build"

  244.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  245.         touch ../.stamp_built

  246.         popd

  247.     fi

  248. 

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

  250.         pushd "${pkgdir}/build"

  251.         make ${MAKE_ARGS} -j 1 install

  252.         touch ../.stamp_installed

  253.         popd

  254.     fi

  255. 

  256.     _postbuild

  257. }

  258. 

  259. function build_make() {

  260.     local name="${1}"

  261.     local version="${2}"

  262.     local extraconfrules="${3}"

  263. 

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

  265. 

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

  267. 

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

  269. 

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

  271.         pushd "${pkgdir}"

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

  273.         touch .stamp_built

  274.         popd

  275.     fi

  276. 

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

  278.         pushd "${pkgdir}"

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

  280.         touch .stamp_installed

  281.         popd

  282.     fi

  283. 

  284.     _postbuild

  285. }

  286. 

  287. function build_meson() {

  288.     local name="${1}"

  289.     local version="${2}"

  290.     local extraconfrules="${3}"

  291. 

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

  293. 

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

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

  296.     fi

  297. 

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

  299. 

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

  301.         pushd "${pkgdir}"

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

  303.         touch .stamp_configured

  304.         popd

  305.     fi

  306. 

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

  308.         pushd "${pkgdir}"

  309.         ninja -v -C build

  310.         touch .stamp_built

  311.         popd

  312.     fi

  313. 

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

  315.         pushd "${pkgdir}"

  316.         ninja -C build install

  317.         touch .stamp_installed

  318.         popd

  319.     fi

  320. 

  321.     _postbuild

  322. }

  323. 

  324. function build_qmake() {

  325.     local name="${1}"

  326.     local version="${2}"

  327.     local extraconfrules="${3}"

  328. 

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

  330. 

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

  332. 

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

  334.         pushd "${pkgdir}"

  335.         qmake ${extraconfrules}

  336.         touch .stamp_configured

  337.         popd

  338.     fi

  339. 

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

  341.         pushd "${pkgdir}"

  342.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  343.         touch .stamp_built

  344.         popd

  345.     fi

  346. 

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

  348.         pushd "${pkgdir}"

  349.         make ${MAKE_ARGS} -j 1 install

  350.         touch .stamp_installed

  351.         popd

  352.     fi

  353. 

  354.     _postbuild

  355. }

  356. 

  357. function build_waf() {

  358.     local name="${1}"

  359.     local version="${2}"

  360.     local extraconfrules="${3}"

  361. 

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

  363.     local python=python3

  364. 

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

  366.         python=python

  367.     fi

  368. 

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

  370. 

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

  372.         pushd "${pkgdir}"

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

  374.         touch .stamp_configured

  375.         popd

  376.     fi

  377. 

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

  379.         pushd "${pkgdir}"

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

  381.         touch .stamp_built

  382.         popd

  383.     fi

  384. 

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

  386.         pushd "${pkgdir}"

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

  388.         touch .stamp_installed

  389.         popd

  390.     fi

  391. 

  392.     _postbuild

  393. }

  394. 

  395. # ---------------------------------------------------------------------------------------------------------------------

  396. 

  397. function build_host_autoconf() {

  398.     local name="${1}"

  399.     local version="${2}"

  400.     local extraconfrules="${3}"

  401. 

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

  403. 

  404.     unset AR

  405.     unset CC

  406.     unset CXX

  407.     unset LD

  408.     unset STRIP

  409.     unset CFLAGS

  410.     unset CPPFLAGS

  411.     unset CXXFLAGS

  412.     unset LDFLAGS

  413. 

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

  415.         pushd "${pkgdir}"

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

  417.         touch .stamp_configured

  418.         popd

  419.     fi

  420. 

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

  422.         pushd "${pkgdir}"

  423.         make ${MAKE_ARGS}

  424.         touch .stamp_built

  425.         popd

  426.     fi

  427. 

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

  429.         pushd "${pkgdir}"

  430.         make ${MAKE_ARGS} install -j 1

  431.         touch .stamp_installed

  432.         popd

  433.     fi

  434. }

  435. 

  436. # ---------------------------------------------------------------------------------------------------------------------

  437. 

  438. function patch_file() {

  439.     local name="${1}"

  440.     local version="${2}"

  441.     local file="${3}"

  442.     local rule="${4}"

  443. 

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

  445. 

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

  447. }

  448. 

  449. function copy_file() {

  450.     local name="${1}"

  451.     local version="${2}"

  452.     local source="${3}"

  453.     local target="${4}"

  454. 

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

  456. 

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

  458.         pushd "${pkgdir}"

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

  460.         popd

  461.     fi

  462. }

  463. 

  464. function link_file() {

  465.     local name="${1}"

  466.     local version="${2}"

  467.     local source="${3}"

  468.     local target="${4}"

  469. 

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

  471. 

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

  473.         pushd "${pkgdir}"

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

  475.         popd

  476.     fi

  477. }

  478. 

  479. function remove_file() {

  480.     local name="${1}"

  481.     local version="${2}"

  482.     local file="${3}"

  483. 

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

  485. 

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

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

  488.     fi

  489. }

  490. 

  491. # ---------------------------------------------------------------------------------------------------------------------