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

468 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-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_conf() {

  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_configured" ]; then

  175.         pushd "${pkgdir}"

  176.         ./configure ${extraconfrules}

  177.         touch .stamp_configured

  178.         popd

  179.     fi

  180. 

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

  182.         pushd "${pkgdir}"

  183.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  184.         touch .stamp_built

  185.         popd

  186.     fi

  187. 

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

  189.         pushd "${pkgdir}"

  190.         make ${MAKE_ARGS} -j 1 install

  191.         touch .stamp_installed

  192.         popd

  193.     fi

  194. 

  195.     _postbuild

  196. }

  197. 

  198. function build_cmake() {

  199.     local name="${1}"

  200.     local version="${2}"

  201.     local extraconfrules="${3}"

  202. 

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

  204. 

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

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

  207.     fi

  208. 

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

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

  211. 

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

  213.         pushd "${pkgdir}/build"

  214.         cmake -DCMAKE_INSTALL_LIBDIR=lib -DCMAKE_INSTALL_PREFIX="${PAWPAW_PREFIX}" ${extraconfrules} ..

  215.         touch ../.stamp_configured

  216.         popd

  217.     fi

  218. 

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

  220.         pushd "${pkgdir}/build"

  221.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  222.         touch ../.stamp_built

  223.         popd

  224.     fi

  225. 

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

  227.         pushd "${pkgdir}/build"

  228.         make ${MAKE_ARGS} -j 1 install

  229.         touch ../.stamp_installed

  230.         popd

  231.     fi

  232. 

  233.     _postbuild

  234. }

  235. 

  236. function build_make() {

  237.     local name="${1}"

  238.     local version="${2}"

  239.     local extraconfrules="${3}"

  240. 

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

  242. 

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

  244. 

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

  246. 

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

  248.         pushd "${pkgdir}"

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

  250.         touch .stamp_built

  251.         popd

  252.     fi

  253. 

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

  255.         pushd "${pkgdir}"

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

  257.         touch .stamp_installed

  258.         popd

  259.     fi

  260. 

  261.     _postbuild

  262. }

  263. 

  264. function build_meson() {

  265.     local name="${1}"

  266.     local version="${2}"

  267.     local extraconfrules="${3}"

  268. 

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

  270. 

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

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

  273.     fi

  274. 

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

  276. 

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

  278.         pushd "${pkgdir}"

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

  280.         touch .stamp_configured

  281.         popd

  282.     fi

  283. 

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

  285.         pushd "${pkgdir}"

  286.         ninja -v -C build

  287.         touch .stamp_built

  288.         popd

  289.     fi

  290. 

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

  292.         pushd "${pkgdir}"

  293.         ninja -C build install

  294.         touch .stamp_installed

  295.         popd

  296.     fi

  297. 

  298.     _postbuild

  299. }

  300. 

  301. function build_qmake() {

  302.     local name="${1}"

  303.     local version="${2}"

  304.     local extraconfrules="${3}"

  305. 

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

  307. 

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

  309. 

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

  311.         pushd "${pkgdir}"

  312.         qmake ${extraconfrules}

  313.         touch .stamp_configured

  314.         popd

  315.     fi

  316. 

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

  318.         pushd "${pkgdir}"

  319.         make ${MAKE_ARGS} ${EXTRA_MAKE_ARGS}

  320.         touch .stamp_built

  321.         popd

  322.     fi

  323. 

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

  325.         pushd "${pkgdir}"

  326.         make ${MAKE_ARGS} -j 1 install

  327.         touch .stamp_installed

  328.         popd

  329.     fi

  330. 

  331.     _postbuild

  332. }

  333. 

  334. function build_waf() {

  335.     local name="${1}"

  336.     local version="${2}"

  337.     local extraconfrules="${3}"

  338. 

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

  340.     local python=python3

  341. 

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

  343.         python=python

  344.     fi

  345. 

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

  347. 

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

  349.         pushd "${pkgdir}"

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

  351.         touch .stamp_configured

  352.         popd

  353.     fi

  354. 

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

  356.         pushd "${pkgdir}"

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

  358.         touch .stamp_built

  359.         popd

  360.     fi

  361. 

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

  363.         pushd "${pkgdir}"

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

  365.         touch .stamp_installed

  366.         popd

  367.     fi

  368. 

  369.     _postbuild

  370. }

  371. 

  372. # ---------------------------------------------------------------------------------------------------------------------

  373. 

  374. function build_host_autoconf() {

  375.     local name="${1}"

  376.     local version="${2}"

  377.     local extraconfrules="${3}"

  378. 

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

  380. 

  381.     unset AR

  382.     unset CC

  383.     unset CXX

  384.     unset LD

  385.     unset STRIP

  386.     unset CFLAGS

  387.     unset CPPFLAGS

  388.     unset CXXFLAGS

  389.     unset LDFLAGS

  390. 

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

  392.         pushd "${pkgdir}"

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

  394.         touch .stamp_configured

  395.         popd

  396.     fi

  397. 

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

  399.         pushd "${pkgdir}"

  400.         make ${MAKE_ARGS}

  401.         touch .stamp_built

  402.         popd

  403.     fi

  404. 

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

  406.         pushd "${pkgdir}"

  407.         make ${MAKE_ARGS} install -j 1

  408.         touch .stamp_installed

  409.         popd

  410.     fi

  411. }

  412. 

  413. # ---------------------------------------------------------------------------------------------------------------------

  414. 

  415. function patch_file() {

  416.     local name="${1}"

  417.     local version="${2}"

  418.     local file="${3}"

  419.     local rule="${4}"

  420. 

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

  422. 

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

  424. }

  425. 

  426. function copy_file() {

  427.     local name="${1}"

  428.     local version="${2}"

  429.     local source="${3}"

  430.     local target="${4}"

  431. 

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

  433. 

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

  435.         pushd "${pkgdir}"

  436.         cp "${source}" "${target}"

  437.         popd

  438.     fi

  439. }

  440. 

  441. function link_file() {

  442.     local name="${1}"

  443.     local version="${2}"

  444.     local source="${3}"

  445.     local target="${4}"

  446. 

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

  448. 

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

  450.         pushd "${pkgdir}"

  451.         ln -sf "${source}" "${target}"

  452.         popd

  453.     fi

  454. }

  455. 

  456. function remove_file() {

  457.     local name="${1}"

  458.     local version="${2}"

  459.     local file="${3}"

  460. 

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

  462. 

  463.     echo rm -f "${pkgdir}/${file}"

  464.     rm -f "${pkgdir}/${file}"

  465. }

  466. 

  467. # ---------------------------------------------------------------------------------------------------------------------