commit 10eef8c19687bac5628054a129044db9807c468e · pyrox.dev/nixpkgs

+2 -2

doc/languages-frameworks/rust.md

···

       17
       17
        
       `nix-shell -p rustStable.rustc -p rustStable.cargo`.

     

       18
       18
        
       

     

       19
       19
        
       There are also `rustBeta` and `rustNightly` package sets available.

     

       20
       20
       -
       These are not updated very regulary. For daily builds see

     

       21
       21
       -
       [Using the Rust nightlies overlay](#using-the-rust-nightlies-overlay)

     

       20
       20
       +
       These are not updated very regulary. For daily builds use either rustup from

     

       21
       21
       +
       nixpkgs or use the [Rust nightlies overlay](#using-the-rust-nightlies-overlay).

     

       22
       22
        
       

     

       23
       23
        
       ## Packaging Rust applications

     

       24
       24

+75

pkgs/development/tools/rust/rustup/0001-use-hardcoded-dynamic-linker.patch

···

       1
       1
       +
       From 36c053f37670c6003f9e8dc001741f7c49e9526a Mon Sep 17 00:00:00 2001

     

       2
       2
       +
       From: =?UTF-8?q?J=C3=B6rg=20Thalheim?= <joerg@thalheim.io>

     

       3
       3
       +
       Date: Sat, 15 Apr 2017 20:42:10 +0200

     

       4
       4
       +
       Subject: [PATCH] use hardcoded dynamic-linker

     

       5
       5
       +
       MIME-Version: 1.0

     

       6
       6
       +
       Content-Type: text/plain; charset=UTF-8

     

       7
       7
       +
       Content-Transfer-Encoding: 8bit

     

       8
       8
       +
       

     

       9
       9
       +
       Signed-off-by: Jörg Thalheim <joerg@thalheim.io>

     

       10
       10
       +
       ---

     

       11
       11
       +
        src/rustup-cli/common.rs |  3 ++-

     

       12
       12
       +
        src/rustup/toolchain.rs  | 22 ++++++++++++++++++++--

     

       13
       13
       +
        2 files changed, 22 insertions(+), 3 deletions(-)

     

       14
       14
       +
       

     

       15
       15
       +
       diff --git a/src/rustup-cli/common.rs b/src/rustup-cli/common.rs

     

       16
       16
       +
       index 1abf345..21096e7 100644

     

       17
       17
       +
       --- a/src/rustup-cli/common.rs

     

       18
       18
       +
       +++ b/src/rustup-cli/common.rs

     

       19
       19
       +
       @@ -220,7 +220,8 @@ pub fn rustc_version(toolchain: &Toolchain) -> String {

     

       20
       20
       +
            if toolchain.exists() {

     

       21
       21
       +
                let rustc_path = toolchain.binary_file("rustc");

     

       22
       22
       +
                if utils::is_file(&rustc_path) {

     

       23
       23
       +
       -            let mut cmd = Command::new(&rustc_path);

     

       24
       24
       +
       +            let mut cmd = Command::new("@dynamicLinker@");

     

       25
       25
       +
       +            cmd.arg(&rustc_path);

     

       26
       26
       +
                    cmd.arg("--version");

     

       27
       27
       +
                    toolchain.set_ldpath(&mut cmd);

     

       28
       28
       +
        

     

       29
       29
       +
       diff --git a/src/rustup/toolchain.rs b/src/rustup/toolchain.rs

     

       30
       30
       +
       index dc29c32..212a4ab 100644

     

       31
       31
       +
       --- a/src/rustup/toolchain.rs

     

       32
       32
       +
       +++ b/src/rustup/toolchain.rs

     

       33
       33
       +
       @@ -315,7 +315,7 @@ impl<'a> Toolchain<'a> {

     

       34
       34
       +
                    }

     

       35
       35
       +
                    Path::new(&binary)

     

       36
       36
       +
                };

     

       37
       37
       +
       -        let mut cmd = Command::new(&path);

     

       38
       38
       +
       +        let mut cmd = wrap_elf_interpreter(&path);

     

       39
       39
       +
                self.set_env(&mut cmd);

     

       40
       40
       +
                Ok(cmd)

     

       41
       41
       +
            }

     

       42
       42
       +
       @@ -363,7 +363,7 @@ impl<'a> Toolchain<'a> {

     

       43
       43
       +
                } else {

     

       44
       44
       +
                    src_file

     

       45
       45
       +
                };

     

       46
       46
       +
       -        let mut cmd = Command::new(exe_path);

     

       47
       47
       +
       +        let mut cmd = wrap_elf_interpreter(exe_path);

     

       48
       48
       +
                self.set_env(&mut cmd);

     

       49
       49
       +
                cmd.env("RUSTUP_TOOLCHAIN", &primary_toolchain.name);

     

       50
       50
       +
                Ok(cmd)

     

       51
       51
       +
       @@ -648,3 +648,21 @@ impl<'a> Toolchain<'a> {

     

       52
       52
       +
                path

     

       53
       53
       +
            }

     

       54
       54
       +
        }

     

       55
       55
       +
       +

     

       56
       56
       +
       +fn wrap_elf_interpreter<S: AsRef<OsStr>>(p: S) -> Command {

     

       57
       57
       +
       +    use std::fs::File;

     

       58
       58
       +
       +    use std::io::Read;

     

       59
       59
       +
       +    let path = Path::new(&p);

     

       60
       60
       +
       +    let is_elf = File::open(path).map(|mut f| {

     

       61
       61
       +
       +        let mut buf = [0; 4];

     

       62
       62
       +
       +        let _ = f.read(&mut buf);

     

       63
       63
       +
       +        buf == b"\x7fELF"[..]

     

       64
       64
       +
       +    }).unwrap_or(false);

     

       65
       65
       +
       +    if is_elf {

     

       66
       66
       +
       +        let mut cmd = Command::new("@dynamicLinker@");

     

       67
       67
       +
       +        cmd.arg(&path);

     

       68
       68
       +
       +        cmd

     

       69
       69
       +
       +    } else {

     

       70
       70
       +
       +        Command::new(&path)

     

       71
       71
       +
       +    }

     

       72
       72
       +
       +}

     

       73
       73
       +
       -- 

     

       74
       74
       +
       2.12.2

     

       75
       75
       +

+55

pkgs/development/tools/rust/rustup/default.nix

···

       1
       1
       +
       { stdenv, lib, runCommand

     

       2
       2
       +
       , fetchFromGitHub, rustPlatform

     

       3
       3
       +
       , pkgconfig, curl, Security }:

     

       4
       4
       +
       

     

       5
       5
       +
       rustPlatform.buildRustPackage rec {

     

       6
       6
       +
         name = "rustup-${version}";

     

       7
       7
       +
         version = "1.2.0";

     

       8
       8
       +
       

     

       9
       9
       +
         depsSha256 = "06bfz5kyj3k0yxv55dq0s1arx34sy1jjfrpgd83rf99026vcm5x2";

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchFromGitHub {

     

       12
       12
       +
           owner = "rust-lang-nursery";

     

       13
       13
       +
           repo = "rustup.rs";

     

       14
       14
       +
           rev = version;

     

       15
       15
       +
           sha256 = "0qwl27wh7j03h511bd8fq5fif5xcmkiyy9rm3hri7czjqr01mw0v";

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         nativeBuildInputs = [ pkgconfig ];

     

       19
       19
       +
       

     

       20
       20
       +
         buildInputs = [

     

       21
       21
       +
           curl

     

       22
       22
       +
         ] ++ stdenv.lib.optionals stdenv.isDarwin [ Security ];

     

       23
       23
       +
       

     

       24
       24
       +
         cargoBuildFlags = [ "--features no-self-update" ];

     

       25
       25
       +
       

     

       26
       26
       +
         patches = lib.optionals stdenv.isLinux [

     

       27
       27
       +
           (runCommand "0001-use-hardcoded-dynamic-linker.patch" { CC=stdenv.cc; } ''

     

       28
       28
       +
              export dynamicLinker=$(cat $CC/nix-support/dynamic-linker)

     

       29
       29
       +
              substituteAll ${./0001-use-hardcoded-dynamic-linker.patch} $out

     

       30
       30
       +
           '')

     

       31
       31
       +
         ];

     

       32
       32
       +
       

     

       33
       33
       +
         postInstall = ''

     

       34
       34
       +
           pushd $out/bin

     

       35
       35
       +
           mv rustup-init rustup

     

       36
       36
       +
           for link in cargo rustc rustdoc rust-gdb rust-lldb; do

     

       37
       37
       +
             ln -s rustup $link

     

       38
       38
       +
           done

     

       39
       39
       +
           popd

     

       40
       40
       +
       

     

       41
       41
       +
           # tries to create .rustup

     

       42
       42
       +
           export HOME=$(mktemp -d)

     

       43
       43
       +
           mkdir -p "$out/share/"{bash-completion/completions,fish/completions,zsh/site-functions}

     

       44
       44
       +
           $out/bin/rustup completions bash > "$out/share/bash-completion/completions/rustup"

     

       45
       45
       +
           $out/bin/rustup completions fish > "$out/share/fish/completions/rustup.fish"

     

       46
       46
       +
           $out/bin/rustup completions zsh >  "$out/share/zsh/site-functions/_rustup"

     

       47
       47
       +
         '';

     

       48
       48
       +
       

     

       49
       49
       +
         meta = with stdenv.lib; {

     

       50
       50
       +
           description = "The Rust toolchain installer";

     

       51
       51
       +
           homepage = https://www.rustup.rs/;

     

       52
       52
       +
           license = licenses.mit;

     

       53
       53
       +
           maintainer = [ maintainers.mic92 ];

     

       54
       54
       +
         };

     

       55
       55
       +
       }

+4 -1

pkgs/top-level/all-packages.nix

···

       771
       771
        
         cfdyndns = callPackage ../applications/networking/dyndns/cfdyndns { };

     

       772
       772
        
       

     

       773
       773
        
         ckbcomp = callPackage ../tools/X11/ckbcomp { };

     

       774
       774
       -
         

     

       774
       774
       +
       

     

       775
       775
        
         clac = callPackage ../tools/misc/clac {};

     

       776
       776
        
       

     

       777
       777
        
         clasp = callPackage ../tools/misc/clasp { };

     
···

       5610
       5610
        
         rustracer = callPackage ../development/tools/rust/racer { };

     

       5611
       5611
        
         rustracerd = callPackage ../development/tools/rust/racerd { };

     

       5612
       5612
        
         rust-bindgen = callPackage ../development/tools/rust/bindgen { };

     

       5613
       5613
       +
         rustup = callPackage ../development/tools/rust/rustup {

     

       5614
       5614
       +
           inherit (darwin.apple_sdk.frameworks) Security;

     

       5615
       5615
       +
         };

     

       5613
       5616
        
       

     

       5614
       5617
        
         sbclBootstrap = callPackage ../development/compilers/sbcl/bootstrap.nix {};

     

       5615
       5618
        
         sbcl = callPackage ../development/compilers/sbcl {};