uboot: (firmwareOdroidC2/C4) don't invoke patch tool, use patches = [] instead

https://github.com/NixOS/nixpkgs/blob/master/pkgs/stdenv/generic/setup.sh#L948
this can do it nicely.

Signed-off-by: Anton Arapov <anton@deadbeef.mx>

pkgs/applications/audio/faust/faust1.nix

@@ -0,0 +1,207 @@
+{ lib, stdenv
+, coreutils
+, fetchurl
+, makeWrapper
+, pkg-config
+}:
+
+with lib.strings;
+
+let
+
+  version = "0.9.90";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/project/faudiostream/faust-${version}.tgz";
+    sha256 = "0d1fqwymyfb73zkmpwv4zk4gsg4ji7qs20mfsr20skmnqx30xvna";
+  };
+
+  meta = with lib; {
+    homepage = "https://faust.grame.fr/";
+    downloadPage = "https://sourceforge.net/projects/faudiostream/files/";
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ magnetophon pmahoney ];
+  };
+
+  faust = stdenv.mkDerivation {
+    pname = "faust";
+    inherit version;
+
+    inherit src;
+
+    nativeBuildInputs = [ makeWrapper ];
+
+    passthru = {
+      inherit wrap wrapWithBuildEnv;
+    };
+
+    preConfigure = ''
+      makeFlags="$makeFlags prefix=$out"
+
+      # The faust makefiles use 'system ?= $(shell uname -s)' but nix
+      # defines 'system' env var, so undefine that so faust detects the
+      # correct system.
+      unset system
+    '';
+
+    # Remove most faust2appl scripts since they won't run properly
+    # without additional paths setup. See faust.wrap,
+    # faust.wrapWithBuildEnv.
+    postInstall = ''
+      # syntax error when eval'd directly
+      pattern="faust2!(*@(atomsnippets|graph|graphviewer|md|plot|sig|sigviewer|svg))"
+      (shopt -s extglob; rm "$out"/bin/$pattern)
+    '';
+
+    postFixup = ''
+      # Set faustpath explicitly.
+      substituteInPlace "$out"/bin/faustpath \
+        --replace "/usr/local /usr /opt /opt/local" "$out"
+
+      # The 'faustoptflags' is 'source'd into other faust scripts and
+      # not used as an executable, so patch 'uname' usage directly
+      # rather than use makeWrapper.
+      substituteInPlace "$out"/bin/faustoptflags \
+        --replace uname "${coreutils}/bin/uname"
+
+      # wrapper for scripts that don't need faust.wrap*
+      for script in "$out"/bin/faust2*; do
+        wrapProgram "$script" \
+          --prefix PATH : "$out"/bin
+      done
+    '';
+
+    meta = meta // {
+      description = "A functional programming language for realtime audio signal processing";
+      longDescription = ''
+        FAUST (Functional Audio Stream) is a functional programming
+        language specifically designed for real-time signal processing
+        and synthesis. FAUST targets high-performance signal processing
+        applications and audio plug-ins for a variety of platforms and
+        standards.
+        The Faust compiler translates DSP specifications into very
+        efficient C++ code. Thanks to the notion of architecture,
+        FAUST programs can be easily deployed on a large variety of
+        audio platforms and plugin formats (jack, alsa, ladspa, maxmsp,
+        puredata, csound, supercollider, pure, vst, coreaudio) without
+        any change to the FAUST code.
+
+        This package has just the compiler, libraries, and headers.
+        Install faust2* for specific faust2appl scripts.
+      '';
+    };
+
+  };
+
+  # Default values for faust2appl.
+  faust2ApplBase =
+    { baseName
+    , dir ? "tools/faust2appls"
+    , scripts ? [ baseName ]
+    , ...
+    }@args:
+
+    args // {
+      name = "${baseName}-${version}";
+
+      inherit src;
+
+      dontBuild = true;
+
+      installPhase = ''
+        runHook preInstall
+
+        mkdir -p "$out/bin"
+        for script in ${concatStringsSep " " scripts}; do
+          cp "${dir}/$script" "$out/bin/"
+        done
+
+        runHook postInstall
+      '';
+
+      postInstall = ''
+        # For the faust2appl script, change 'faustpath' and
+        # 'faustoptflags' to absolute paths.
+        for script in "$out"/bin/*; do
+          substituteInPlace "$script" \
+            --replace ". faustpath" ". '${faust}/bin/faustpath'" \
+            --replace ". faustoptflags" ". '${faust}/bin/faustoptflags'"
+        done
+      '';
+
+      meta = meta // {
+        description = "The ${baseName} script, part of faust functional programming language for realtime audio signal processing";
+      };
+    };
+
+  # Some 'faust2appl' scripts, such as faust2alsa, run faust to
+  # generate cpp code, then invoke the c++ compiler to build the code.
+  # This builder wraps these scripts in parts of the stdenv such that
+  # when the scripts are called outside any nix build, they behave as
+  # if they were running inside a nix build in terms of compilers and
+  # paths being configured (e.g. rpath is set so that compiled
+  # binaries link to the libs inside the nix store)
+  #
+  # The function takes two main args: the appl name (e.g.
+  # 'faust2alsa') and an optional list of propagatedBuildInputs. It
+  # returns a derivation that contains only the bin/${appl} script,
+  # wrapped up so that it will run as if it was inside a nix build
+  # with those build inputs.
+  #
+  # The build input 'faust' is automatically added to the
+  # propagatedBuildInputs.
+  wrapWithBuildEnv =
+    { baseName
+    , propagatedBuildInputs ? [ ]
+    , ...
+    }@args:
+
+    stdenv.mkDerivation ((faust2ApplBase args) // {
+
+      nativeBuildInputs = [ pkg-config makeWrapper ];
+
+      propagatedBuildInputs = [ faust ] ++ propagatedBuildInputs;
+
+      postFixup = ''
+
+        # export parts of the build environment
+        for script in "$out"/bin/*; do
+          wrapProgram "$script" \
+            --set FAUSTLIB "${faust}/lib/faust" \
+            --set FAUSTINC "${faust}/include/faust" \
+            --prefix PATH : "$PATH" \
+            --prefix PKG_CONFIG_PATH : "$PKG_CONFIG_PATH" \
+            --set NIX_CFLAGS_COMPILE "$NIX_CFLAGS_COMPILE" \
+            --set NIX_LDFLAGS "$NIX_LDFLAGS"
+        done
+      '';
+    });
+
+  # Builder for 'faust2appl' scripts, such as faust2firefox that
+  # simply need to be wrapped with some dependencies on PATH.
+  #
+  # The build input 'faust' is automatically added to the PATH.
+  wrap =
+    { baseName
+    , runtimeInputs ? [ ]
+    , ...
+    }@args:
+
+    let
+
+      runtimePath = concatStringsSep ":" (map (p: "${p}/bin") ([ faust ] ++ runtimeInputs));
+
+    in stdenv.mkDerivation ((faust2ApplBase args) // {
+
+      nativeBuildInputs = [ makeWrapper ];
+
+      postFixup = ''
+        for script in "$out"/bin/*; do
+          wrapProgram "$script" --prefix PATH : "${runtimePath}"
+        done
+      '';
+
+    });
+
+in faust

pkgs/applications/audio/faust/faust2.nix

@@ -0,0 +1,229 @@
+{ lib, stdenv
+, coreutils
+, fetchFromGitHub
+, makeWrapper
+, pkg-config
+, cmake
+, llvm
+, emscripten
+, openssl
+, libsndfile
+, libmicrohttpd
+, gnutls
+, libtasn1
+, p11-kit
+, vim
+, which
+}:
+
+with lib.strings;
+
+let
+
+  version = "2.40.0";
+
+  src = fetchFromGitHub {
+    owner = "grame-cncm";
+    repo = "faust";
+    rev = version;
+    sha256 = "sha256-IsrLaoMDwrDPxtqCXIy/7tZCdogTUkJ00obSco9SR/A=";
+    fetchSubmodules = true;
+  };
+
+  meta = with lib; {
+    homepage = "https://faust.grame.fr/";
+    downloadPage = "https://github.com/grame-cncm/faust/";
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ magnetophon pmahoney ];
+  };
+
+  faust = stdenv.mkDerivation {
+
+    pname = "faust";
+    inherit version;
+
+    inherit src;
+
+    nativeBuildInputs = [ makeWrapper pkg-config cmake vim which ];
+    buildInputs = [ llvm emscripten openssl libsndfile libmicrohttpd gnutls libtasn1 p11-kit ];
+
+
+    passthru = {
+      inherit wrap wrapWithBuildEnv;
+    };
+
+
+    preConfigure = ''
+      cd build
+    '';
+
+    cmakeFlags = ''
+      -C ../backends/all.cmake -C  ../targets/all.cmake ..
+    '';
+
+    postInstall = ''
+      # syntax error when eval'd directly
+      pattern="faust2!(*@(atomsnippets|graph|graphviewer|md|plot|sig|sigviewer|svg))"
+      (shopt -s extglob; rm "$out"/bin/$pattern)
+    '';
+
+    postFixup = ''
+      # The 'faustoptflags' is 'source'd into other faust scripts and
+      # not used as an executable, so patch 'uname' usage directly
+      # rather than use makeWrapper.
+      substituteInPlace "$out"/bin/faustoptflags \
+        --replace uname "${coreutils}/bin/uname"
+
+      # wrapper for scripts that don't need faust.wrap*
+      for script in "$out"/bin/faust2*; do
+        wrapProgram "$script" \
+          --prefix PATH : "$out"/bin
+      done
+    '';
+
+    meta = meta // {
+      description = "A functional programming language for realtime audio signal processing";
+      longDescription = ''
+        FAUST (Functional Audio Stream) is a functional programming
+        language specifically designed for real-time signal processing
+        and synthesis. FAUST targets high-performance signal processing
+        applications and audio plug-ins for a variety of platforms and
+        standards.
+        The Faust compiler translates DSP specifications into very
+        efficient C++ code. Thanks to the notion of architecture,
+        FAUST programs can be easily deployed on a large variety of
+        audio platforms and plugin formats (jack, alsa, ladspa, maxmsp,
+        puredata, csound, supercollider, pure, vst, coreaudio) without
+        any change to the FAUST code.
+
+        This package has just the compiler, libraries, and headers.
+        Install faust2* for specific faust2appl scripts.
+      '';
+    };
+
+  };
+
+  # Default values for faust2appl.
+  faust2ApplBase =
+    { baseName
+    , dir ? "tools/faust2appls"
+    , scripts ? [ baseName ]
+    , ...
+    }@args:
+
+    args // {
+      name = "${baseName}-${version}";
+
+      inherit src;
+
+      dontBuild = true;
+
+      installPhase = ''
+        runHook preInstall
+
+        mkdir -p "$out/bin"
+        for script in ${concatStringsSep " " scripts}; do
+          cp "${dir}/$script" "$out/bin/"
+        done
+
+        runHook postInstall
+      '';
+
+      postInstall = ''
+        # For the faust2appl script, change 'faustpath' and
+        # 'faustoptflags' to absolute paths.
+        for script in "$out"/bin/*; do
+          substituteInPlace "$script" \
+            --replace " error " "echo"
+        done
+      '';
+
+      meta = meta // {
+        description = "The ${baseName} script, part of faust functional programming language for realtime audio signal processing";
+      };
+    };
+
+  # Some 'faust2appl' scripts, such as faust2alsa, run faust to
+  # generate cpp code, then invoke the c++ compiler to build the code.
+  # This builder wraps these scripts in parts of the stdenv such that
+  # when the scripts are called outside any nix build, they behave as
+  # if they were running inside a nix build in terms of compilers and
+  # paths being configured (e.g. rpath is set so that compiled
+  # binaries link to the libs inside the nix store)
+  #
+  # The function takes two main args: the appl name (e.g.
+  # 'faust2alsa') and an optional list of propagatedBuildInputs. It
+  # returns a derivation that contains only the bin/${appl} script,
+  # wrapped up so that it will run as if it was inside a nix build
+  # with those build inputs.
+  #
+  # The build input 'faust' is automatically added to the
+  # propagatedBuildInputs.
+  wrapWithBuildEnv =
+    { baseName
+    , propagatedBuildInputs ? [ ]
+    , ...
+    }@args:
+
+    stdenv.mkDerivation ((faust2ApplBase args) // {
+
+      nativeBuildInputs = [ pkg-config makeWrapper ];
+
+      propagatedBuildInputs = [ faust ] ++ propagatedBuildInputs;
+
+      libPath = lib.makeLibraryPath propagatedBuildInputs;
+
+      postFixup = ''
+
+        # export parts of the build environment
+        for script in "$out"/bin/*; do
+          # e.g. NIX_CC_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu
+          nix_cc_wrapper_target_host="$(printenv | grep ^NIX_CC_WRAPPER_TARGET_HOST | sed 's/=.*//')"
+
+          # e.g. NIX_BINTOOLS_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu
+          nix_bintools_wrapper_target_host="$(printenv | grep ^NIX_BINTOOLS_WRAPPER_TARGET_HOST | sed 's/=.*//')"
+
+          wrapProgram "$script" \
+            --set FAUSTLDDIR "${faust}/lib" \
+            --set FAUSTLIB "${faust}/share/faust" \
+            --set FAUSTINC "${faust}/include/faust" \
+            --set FAUSTARCH "${faust}/share/faust" \
+            --prefix PATH : "$PATH" \
+            --prefix PKG_CONFIG_PATH : "$PKG_CONFIG_PATH" \
+            --set NIX_CFLAGS_COMPILE "$NIX_CFLAGS_COMPILE" \
+            --set NIX_LDFLAGS "$NIX_LDFLAGS -lpthread" \
+            --set "$nix_cc_wrapper_target_host" "''${!nix_cc_wrapper_target_host}" \
+            --set "$nix_bintools_wrapper_target_host" "''${!nix_bintools_wrapper_target_host}" \
+            --prefix LIBRARY_PATH "$libPath"
+        done
+      '';
+    });
+
+  # Builder for 'faust2appl' scripts, such as faust2firefox that
+  # simply need to be wrapped with some dependencies on PATH.
+  #
+  # The build input 'faust' is automatically added to the PATH.
+  wrap =
+    { baseName
+    , runtimeInputs ? [ ]
+    , ...
+    }@args:
+
+    let
+
+      runtimePath = concatStringsSep ":" (map (p: "${p}/bin") ([ faust ] ++ runtimeInputs));
+
+    in stdenv.mkDerivation ((faust2ApplBase args) // {
+
+      nativeBuildInputs = [ makeWrapper ];
+
+      postFixup = ''
+        for script in "$out"/bin/*; do
+          wrapProgram "$script" --prefix PATH : "${runtimePath}"
+        done
+      '';
+
+    });
+
+in faust

pkgs/applications/audio/faust/faust2alqt.nix

@@ -0,0 +1,15 @@
+{ faust
+, alsa-lib
+, qt4
+}:
+
+faust.wrapWithBuildEnv {
+
+  baseName = "faust2alqt";
+
+  propagatedBuildInputs = [
+    alsa-lib
+    qt4
+  ];
+
+}

pkgs/applications/audio/faust/faust2alsa.nix

@@ -0,0 +1,29 @@
+{ faust
+, alsa-lib
+, atk
+, cairo
+, fontconfig
+, freetype
+, gdk-pixbuf
+, glib
+, gtk2
+, pango
+}:
+
+faust.wrapWithBuildEnv {
+
+  baseName = "faust2alsa";
+
+  propagatedBuildInputs = [
+    alsa-lib
+    atk
+    cairo
+    fontconfig
+    freetype
+    gdk-pixbuf
+    glib
+    gtk2
+    pango
+  ];
+
+}

pkgs/applications/audio/faust/faust2csound.nix

@@ -0,0 +1,20 @@
+{ faust
+, csound
+}:
+
+faust.wrapWithBuildEnv {
+
+  baseName = "faust2csound";
+
+  propagatedBuildInputs = [
+    csound
+  ];
+
+  # faust2csound generated .cpp files have
+  #   #include "csdl.h"
+  # but that file is in the csound/ subdirectory
+  preFixup = ''
+    NIX_CFLAGS_COMPILE="$(printf '%s' "$NIX_CFLAGS_COMPILE" | sed 's%${csound}/include%${csound}/include/csound%')"
+  '';
+
+}

pkgs/applications/audio/faust/faust2firefox.nix

@@ -0,0 +1,14 @@
+{ faust
+, xdg-utils
+}:
+
+# This just runs faust2svg, then attempts to open a browser using
+# 'xdg-open'.
+
+faust.wrap {
+
+  baseName = "faust2firefox";
+
+  runtimeInputs = [ xdg-utils ];
+
+}

pkgs/applications/audio/faust/faust2jack.nix

@@ -0,0 +1,28 @@
+{ faust
+, gtk2
+, jack2
+, alsa-lib
+, opencv
+, libsndfile
+, which
+}:
+
+faust.wrapWithBuildEnv {
+
+  baseName = "faust2jack";
+
+  scripts = [
+    "faust2jack"
+    "faust2jackconsole"
+  ];
+
+  propagatedBuildInputs = [
+    gtk2
+    jack2
+    alsa-lib
+    opencv
+    libsndfile
+    which
+  ];
+
+}

pkgs/applications/audio/faust/faust2jackrust.nix

@@ -0,0 +1,17 @@
+{ faust
+, libjack2
+, cargo
+, binutils
+, gcc
+, gnumake
+, openssl
+, pkg-config
+
+}:
+
+faust.wrapWithBuildEnv {
+
+  baseName = "faust2jackrust";
+
+  propagatedBuildInputs = [ libjack2 cargo binutils gcc gnumake openssl pkg-config ];
+}

pkgs/applications/audio/faust/faust2jaqt.nix

@@ -0,0 +1,26 @@
+{ faust
+, jack2
+, qt4
+, libsndfile
+, alsa-lib
+, which
+}:
+
+faust.wrapWithBuildEnv {
+
+  baseName = "faust2jaqt";
+
+  scripts = [
+    "faust2jaqt"
+    "faust2jackserver"
+  ];
+
+  propagatedBuildInputs = [
+    jack2
+    qt4
+    libsndfile
+    alsa-lib
+    which
+  ];
+
+}

pkgs/applications/audio/faust/faust2ladspa.nix

@@ -0,0 +1,12 @@
+{ boost
+, faust
+, ladspaH
+}:
+
+faust.wrapWithBuildEnv {
+
+  baseName = "faust2ladspa";
+
+  propagatedBuildInputs = [ boost ladspaH ];
+
+}

pkgs/applications/audio/faust/faust2lv2.nix

@@ -0,0 +1,15 @@
+{ boost
+, faust
+, lv2
+, qt4
+, which
+
+}:
+
+faust.wrapWithBuildEnv {
+
+  baseName = "faust2lv2";
+
+  propagatedBuildInputs = [ boost lv2 qt4 which ];
+
+}

pkgs/applications/audio/faust/faustlive.nix

@@ -0,0 +1,43 @@
+{ lib, stdenv, fetchFromGitHub
+, llvm_10, qt5, qrencode, libmicrohttpd, libjack2, alsa-lib, faust, curl
+, bc, coreutils, which, libsndfile, flac, libogg, libvorbis, libopus, pkg-config, libxcb, cmake, gnutls, libtasn1, p11-kit
+}:
+
+stdenv.mkDerivation rec {
+  pname = "faustlive";
+  version = "2.5.10";
+  src = fetchFromGitHub {
+    owner = "grame-cncm";
+    repo = "faustlive";
+    rev = version;
+    sha256 = "sha256-yLpIJr6A+NIX9RSGfQXT0O0USuRr0Ni9aUA+mbk31/o=";
+    fetchSubmodules = true;
+  };
+
+  nativeBuildInputs = [ pkg-config qt5.wrapQtAppsHook cmake ];
+
+  buildInputs = [
+    llvm_10 qt5.qtbase qrencode libmicrohttpd libjack2 alsa-lib faust curl
+    bc coreutils which libsndfile flac libogg libvorbis libopus libxcb gnutls libtasn1 p11-kit
+  ];
+
+  makeFlags = [ "PREFIX=$(out)" ];
+
+  postInstall = ''
+    wrapProgram $out/bin/FaustLive --prefix LD_LIBRARY_PATH : "${lib.makeLibraryPath [ libmicrohttpd libsndfile faust llvm_10 ]}"
+  '';
+
+  postPatch = "cd Build";
+
+  meta = with lib; {
+    description = "A standalone just-in-time Faust compiler";
+    longDescription = ''
+      FaustLive is a standalone just-in-time Faust compiler. It tries to bring
+      together the convenience of a standalone interpreted language with the
+      efficiency of a compiled language. It's ideal for fast prototyping.
+    '';
+    homepage = "https://faust.grame.fr/";
+    license = licenses.gpl3;
+    maintainers = with maintainers; [ magnetophon ];
+  };
+}