commit 2c2f1e37d4374ea61caefd9389927ea03df4ce31 · pyrox.dev/nixpkgs

+1 -1

doc/old/cross.txt

···

       78
       78
        
       ---

     

       79
       79
        
       {stdenv, fetchurl}:

     

       80
       80
        
       

     

       81
       81
       -
       assert stdenv.system == "i686-linux";

     

       81
       81
       +
       assert stdenv.buildPlatform.system == "i686-linux";

     

       82
       82
        
       

     

       83
       83
        
       stdenv.mkDerivation {

     

       84
       84
        
         name = "linux-headers-2.6.13.1-arm";

+1 -1

nixos/lib/make-system-tarball.nix

···

       1
       1
        
       { stdenv, perl, pixz, pathsFromGraph

     

       2
       2
        
       

     

       3
       3
        
       , # The file name of the resulting tarball

     

       4
       4
       -
         fileName ? "nixos-system-${stdenv.system}"

     

       4
       4
       +
         fileName ? "nixos-system-${stdenv.hostPlatform.system}"

     

       5
       5
        
       

     

       6
       6
        
       , # The files and directories to be placed in the tarball.

     

       7
       7
        
         # This is a list of attribute sets {source, target} where `source'

+2 -2

nixos/lib/qemu-flags.nix

···

       14
       14
        
       

     

       15
       15
        
         qemuSerialDevice = if pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64 then "ttyS0"

     

       16
       16
        
               else if pkgs.stdenv.isAarch32 || pkgs.stdenv.isAarch64 then "ttyAMA0"

     

       17
       17
       -
               else throw "Unknown QEMU serial device for system '${pkgs.stdenv.system}'";

     

       17
       17
       +
               else throw "Unknown QEMU serial device for system '${pkgs.stdenv.hostPlatform.system}'";

     

       18
       18
        
       

     

       19
       19
        
         qemuBinary = qemuPkg: {

     

       20
       20
        
           "x86_64-linux" = "${qemuPkg}/bin/qemu-kvm -cpu kvm64";

     

       21
       21
        
           "armv7l-linux" = "${qemuPkg}/bin/qemu-system-arm -enable-kvm -machine virt -cpu host";

     

       22
       22
        
           "aarch64-linux" = "${qemuPkg}/bin/qemu-system-aarch64 -enable-kvm -machine virt,gic-version=host -cpu host";

     

       23
       23
        
           "x86_64-darwin" = "${qemuPkg}/bin/qemu-kvm -cpu kvm64";

     

       24
       24
       -
         }.${pkgs.stdenv.system} or "${qemuPkg}/bin/qemu-kvm";

     

       24
       24
       +
         }.${pkgs.stdenv.hostPlatform.system} or "${qemuPkg}/bin/qemu-kvm";

     

       25
       25
        
       }

+1 -1

nixos/modules/installer/cd-dvd/installation-cd-base.nix

···

       16
       16
        
           ];

     

       17
       17
        
       

     

       18
       18
        
         # ISO naming.

     

       19
       19
       -
         isoImage.isoName = "${config.isoImage.isoBaseName}-${config.system.nixos.label}-${pkgs.stdenv.system}.iso";

     

       19
       19
       +
         isoImage.isoName = "${config.isoImage.isoBaseName}-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}.iso";

     

       20
       20
        
       

     

       21
       21
        
         isoImage.volumeID = substring 0 11 "NIXOS_ISO";

     

       22
       22

+2 -1

nixos/modules/installer/cd-dvd/sd-image-aarch64.nix

···

       16
       16
        
         ];

     

       17
       17
        
       

     

       18
       18
        
         assertions = lib.singleton {

     

       19
       19
       -
           assertion = pkgs.stdenv.system == "aarch64-linux";

     

       19
       19
       +
           assertion = pkgs.stdenv.hostPlatform.system == "aarch64-linux"

     

       20
       20
       +
             && pkgs.stdenv.hostPlatform.system == pkgs.stdenv.buildPlatform.system;

     

       20
       21
        
           message = "sd-image-aarch64.nix can be only built natively on Aarch64 / ARM64; " +

     

       21
       22
        
             "it cannot be cross compiled";

     

       22
       23
        
         };

+2 -1

nixos/modules/installer/cd-dvd/sd-image-armv7l-multiplatform.nix

···

       16
       16
        
         ];

     

       17
       17
        
       

     

       18
       18
        
         assertions = lib.singleton {

     

       19
       19
       -
           assertion = pkgs.stdenv.system == "armv7l-linux";

     

       19
       19
       +
           assertion = pkgs.stdenv.hostPlatform.system == "armv7l-linux"

     

       20
       20
       +
             && pkgs.stdenv.hostPlatform.system == pkgs.stdenv.buildPlatform.system;

     

       20
       21
        
           message = "sd-image-armv7l-multiplatform.nix can be only built natively on ARMv7; " +

     

       21
       22
        
             "it cannot be cross compiled";

     

       22
       23
        
         };

+2 -1

nixos/modules/installer/cd-dvd/sd-image-raspberrypi.nix

···

       16
       16
        
         ];

     

       17
       17
        
       

     

       18
       18
        
         assertions = lib.singleton {

     

       19
       19
       -
           assertion = pkgs.stdenv.system == "armv6l-linux";

     

       19
       19
       +
           assertion = pkgs.stdenv.hostPlatform.system == "armv6l-linux"

     

       20
       20
       +
             && pkgs.stdenv.hostPlatform.system == pkgs.stdenv.buildPlatform.system;

     

       20
       21
        
           message = "sd-image-raspberrypi.nix can be only built natively on ARMv6; " +

     

       21
       22
        
             "it cannot be cross compiled";

     

       22
       23
        
         };

+2 -2

nixos/modules/installer/cd-dvd/sd-image.nix

···

       22
       22
        
       {

     

       23
       23
        
         options.sdImage = {

     

       24
       24
        
           imageName = mkOption {

     

       25
       25
       -
             default = "${config.sdImage.imageBaseName}-${config.system.nixos.label}-${pkgs.stdenv.system}.img";

     

       25
       25
       +
             default = "${config.sdImage.imageBaseName}-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}.img";

     

       26
       26
        
             description = ''

     

       27
       27
        
               Name of the generated image file.

     

       28
       28
        
             '';

     
···

       102
       102
        
               mkdir -p $out/nix-support $out/sd-image

     

       103
       103
        
               export img=$out/sd-image/${config.sdImage.imageName}

     

       104
       104
        
       

     

       105
       105
       -
               echo "${pkgs.stdenv.system}" > $out/nix-support/system

     

       105
       105
       +
               echo "${pkgs.stdenv.buildPlatform.system}" > $out/nix-support/system

     

       106
       106
        
               echo "file sd-image $img" >> $out/nix-support/hydra-build-products

     

       107
       107
        
       

     

       108
       108
        
               # Create the image file sized to fit /boot and /, plus 20M of slack

+1 -1

nixos/modules/installer/netboot/netboot.nix

···

       25
       25
        
       

     

       26
       26
        
           # !!! Hack - attributes expected by other modules.

     

       27
       27
        
           environment.systemPackages = [ pkgs.grub2_efi ]

     

       28
       28
       -
             ++ (if pkgs.stdenv.system == "aarch64-linux"

     

       28
       28
       +
             ++ (if pkgs.stdenv.hostPlatform.system == "aarch64-linux"

     

       29
       29
        
                 then []

     

       30
       30
        
                 else [ pkgs.grub2 pkgs.syslinux ]);

     

       31
       31

+1 -1

nixos/modules/services/misc/gitit.nix

···

       10
       10
        
       

     

       11
       11
        
         toYesNo = b: if b then "yes" else "no";

     

       12
       12
        
       

     

       13
       13
       -
         gititShared = with cfg.haskellPackages; gitit + "/share/" + pkgs.stdenv.system + "-" + ghc.name + "/" + gitit.pname + "-" + gitit.version;

     

       13
       13
       +
         gititShared = with cfg.haskellPackages; gitit + "/share/" + pkgs.stdenv.hostPlatform.system + "-" + ghc.name + "/" + gitit.pname + "-" + gitit.version;

     

       14
       14
        
       

     

       15
       15
        
         gititWithPkgs = hsPkgs: extras: hsPkgs.ghcWithPackages (self: with self; [ gitit ] ++ (extras self));

     

       16
       16

+1 -1

nixos/modules/services/networking/vsftpd.nix

···

       99
       99
        
             nopriv_user=vsftpd

     

       100
       100
        
             secure_chroot_dir=/var/empty

     

       101
       101
        
             syslog_enable=YES

     

       102
       102
       -
             ${optionalString (pkgs.stdenv.system == "x86_64-linux") ''

     

       102
       102
       +
             ${optionalString (pkgs.stdenv.hostPlatform.system == "x86_64-linux") ''

     

       103
       103
        
               seccomp_sandbox=NO

     

       104
       104
        
             ''}

     

       105
       105
        
             anon_umask=${cfg.anonymousUmask}

+1 -1

nixos/modules/system/boot/luksroot.nix

···

       324
       324
        
               [ "aes" "aes_generic" "blowfish" "twofish"

     

       325
       325
        
                 "serpent" "cbc" "xts" "lrw" "sha1" "sha256" "sha512"

     

       326
       326
        
       

     

       327
       327
       -
                 (if pkgs.stdenv.system == "x86_64-linux" then "aes_x86_64" else "aes_i586")

     

       327
       327
       +
                 (if pkgs.stdenv.hostPlatform.system == "x86_64-linux" then "aes_x86_64" else "aes_i586")

     

       328
       328
        
               ];

     

       329
       329
        
             description = ''

     

       330
       330
        
               A list of cryptographic kernel modules needed to decrypt the root device(s).

+1 -1

nixos/modules/virtualisation/azure-agent.nix

···

       77
       77
        
         config = mkIf cfg.enable {

     

       78
       78
        
           assertions = [ {

     

       79
       79
        
             assertion = pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64;

     

       80
       80
       -
             message = "Azure not currently supported on ${pkgs.stdenv.system}";

     

       80
       80
       +
             message = "Azure not currently supported on ${pkgs.stdenv.hostPlatform.system}";

     

       81
       81
        
           } {

     

       82
       82
        
             assertion = config.networking.networkmanager.enable == false;

     

       83
       83
        
             message = "Windows Azure Linux Agent is not compatible with NetworkManager";

+1 -1

nixos/modules/virtualisation/brightbox-image.nix

···

       26
       26
        
                     rm $diskImageBase

     

       27
       27
        
                     popd

     

       28
       28
        
                   '';

     

       29
       29
       -
                 diskImageBase = "nixos-image-${config.system.nixos.label}-${pkgs.stdenv.system}.raw";

     

       29
       29
       +
                 diskImageBase = "nixos-image-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}.raw";

     

       30
       30
        
                 buildInputs = [ pkgs.utillinux pkgs.perl ];

     

       31
       31
        
                 exportReferencesGraph =

     

       32
       32
        
                   [ "closure" config.system.build.toplevel ];

+1 -1

nixos/modules/virtualisation/google-compute-image.nix

···

       14
       14
        
             PATH=$PATH:${pkgs.stdenv.lib.makeBinPath [ pkgs.gnutar pkgs.gzip ]}

     

       15
       15
        
             pushd $out

     

       16
       16
        
             mv $diskImage disk.raw

     

       17
       17
       -
             tar -Szcf nixos-image-${config.system.nixos.label}-${pkgs.stdenv.system}.raw.tar.gz disk.raw

     

       17
       17
       +
             tar -Szcf nixos-image-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}.raw.tar.gz disk.raw

     

       18
       18
        
             rm $out/disk.raw

     

       19
       19
        
             popd

     

       20
       20
        
           '';

+1 -1

nixos/modules/virtualisation/virtualbox-guest.nix

···

       34
       34
        
         config = mkIf cfg.enable (mkMerge [{

     

       35
       35
        
           assertions = [{

     

       36
       36
        
             assertion = pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64;

     

       37
       37
       -
             message = "Virtualbox not currently supported on ${pkgs.stdenv.system}";

     

       37
       37
       +
             message = "Virtualbox not currently supported on ${pkgs.stdenv.hostPlatform.system}";

     

       38
       38
        
           }];

     

       39
       39
        
       

     

       40
       40
        
           environment.systemPackages = [ kernel.virtualboxGuestAdditions ];

+5 -5

nixos/modules/virtualisation/virtualbox-image.nix

···

       26
       26
        
             };

     

       27
       27
        
             vmDerivationName = mkOption {

     

       28
       28
        
               type = types.str;

     

       29
       29
       -
               default = "nixos-ova-${config.system.nixos.label}-${pkgs.stdenv.system}";

     

       29
       29
       +
               default = "nixos-ova-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}";

     

       30
       30
        
               description = ''

     

       31
       31
        
                 The name of the derivation for the VirtualBox appliance.

     

       32
       32
        
               '';

     

       33
       33
        
             };

     

       34
       34
        
             vmName = mkOption {

     

       35
       35
        
               type = types.str;

     

       36
       36
       -
               default = "NixOS ${config.system.nixos.label} (${pkgs.stdenv.system})";

     

       36
       36
       +
               default = "NixOS ${config.system.nixos.label} (${pkgs.stdenv.hostPlatform.system})";

     

       37
       37
        
               description = ''

     

       38
       38
        
                 The name of the VirtualBox appliance.

     

       39
       39
        
               '';

     

       40
       40
        
             };

     

       41
       41
        
             vmFileName = mkOption {

     

       42
       42
        
               type = types.str;

     

       43
       43
       -
               default = "nixos-${config.system.nixos.label}-${pkgs.stdenv.system}.ova";

     

       43
       43
       +
               default = "nixos-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}.ova";

     

       44
       44
        
               description = ''

     

       45
       45
        
                 The file name of the VirtualBox appliance.

     

       46
       46
        
               '';

     
···

       67
       67
        
                 echo "creating VirtualBox VM..."

     

       68
       68
        
                 vmName="${cfg.vmName}";

     

       69
       69
        
                 VBoxManage createvm --name "$vmName" --register \

     

       70
       70
       -
                   --ostype ${if pkgs.stdenv.system == "x86_64-linux" then "Linux26_64" else "Linux26"}

     

       70
       70
       +
                   --ostype ${if pkgs.stdenv.hostPlatform.system == "x86_64-linux" then "Linux26_64" else "Linux26"}

     

       71
       71
        
                 VBoxManage modifyvm "$vmName" \

     

       72
       72
        
                   --memory ${toString cfg.memorySize} --acpi on --vram 32 \

     

       73
       73
       -
                   ${optionalString (pkgs.stdenv.system == "i686-linux") "--pae on"} \

     

       73
       73
       +
                   ${optionalString (pkgs.stdenv.hostPlatform.system == "i686-linux") "--pae on"} \

     

       74
       74
        
                   --nictype1 virtio --nic1 nat \

     

       75
       75
        
                   --audiocontroller ac97 --audio alsa \

     

       76
       76
        
                   --rtcuseutc on \

+1 -1

nixos/modules/virtualisation/vmware-guest.nix

···

       22
       22
        
         config = mkIf cfg.enable {

     

       23
       23
        
           assertions = [ {

     

       24
       24
        
             assertion = pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64;

     

       25
       25
       -
             message = "VMWare guest is not currently supported on ${pkgs.stdenv.system}";

     

       25
       25
       +
             message = "VMWare guest is not currently supported on ${pkgs.stdenv.hostPlatform.system}";

     

       26
       26
        
           } ];

     

       27
       27
        
       

     

       28
       28
        
           environment.systemPackages = [ open-vm-tools ];

+1 -1

nixos/modules/virtualisation/xen-dom0.nix

···

       146
       146
        
         config = mkIf cfg.enable {

     

       147
       147
        
           assertions = [ {

     

       148
       148
        
             assertion = pkgs.stdenv.isx86_64;

     

       149
       149
       -
             message = "Xen currently not supported on ${pkgs.stdenv.system}";

     

       149
       149
       +
             message = "Xen currently not supported on ${pkgs.stdenv.hostPlatform.system}";

     

       150
       150
        
           } {

     

       151
       151
        
             assertion = config.boot.loader.grub.enable && (config.boot.loader.grub.efiSupport == false);

     

       152
       152
        
             message = "Xen currently does not support EFI boot";

+2 -2

pkgs/applications/altcoins/mist.nix

···

       4
       4
        
         version = "0.11.1";

     

       5
       5
        
         name = "mist";

     

       6
       6
        
       

     

       7
       7
       -
         throwSystem = throw "Unsupported system: ${stdenv.system}";

     

       7
       7
       +
         throwSystem = throw "Unsupported system: ${stdenv.hostPlatform.system}";

     

       8
       8
        
       

     

       9
       9
        
         meta = with stdenv.lib; {

     

       10
       10
        
           description = "Browse and use Ðapps on the Ethereum network";

     
···

       37
       37
        
               url = "https://github.com/ethereum/mist/releases/download/v${version}/Mist-linux64-${urlVersion}.zip";

     

       38
       38
        
               sha256 = "0yx4x72l8gk68yh9saki48zgqx8k92xnkm79dc651wdpd5c25cz3";

     

       39
       39
        
             };

     

       40
       40
       -
           }.${stdenv.system} or throwSystem;

     

       40
       40
       +
           }.${stdenv.hostPlatform.system} or throwSystem;

     

       41
       41
        
       

     

       42
       42
        
           buildInputs = [ unzip makeWrapper ];

     

       43
       43

+3 -3

pkgs/applications/audio/baudline/default.nix

···

       11
       11
        
         version = "1.08";

     

       12
       12
        
       

     

       13
       13
        
         src =

     

       14
       14
       -
           if stdenv.system == "x86_64-linux" then

     

       14
       14
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       15
       15
        
             fetchurl {

     

       16
       16
        
               url = "http://www.baudline.com/baudline_${version}_linux_x86_64.tar.gz";

     

       17
       17
        
               sha256 = "09fn0046i69in1jpizkzbaq5ggij0mpflcsparyskm3wh71mbzvr";

     

       18
       18
        
             }

     

       19
       19
       -
           else if stdenv.system == "i686-linux" then

     

       19
       19
       +
           else if stdenv.hostPlatform.system == "i686-linux" then

     

       20
       20
        
             fetchurl {

     

       21
       21
        
               url = "http://www.baudline.com/baudline_${version}_linux_i686.tar.gz";

     

       22
       22
        
               sha256 = "1waip5pmcf5ffcfvn8lf1rvsaq2ab66imrbfqs777scz7k8fhhjb";

     

       23
       23
        
             }

     

       24
       24
        
           else

     

       25
       25
       -
             throw "baudline isn't supported (yet?) on ${stdenv.system}";

     

       25
       25
       +
             throw "baudline isn't supported (yet?) on ${stdenv.hostPlatform.system}";

     

       26
       26
        
       

     

       27
       27
        
         buildInputs = [ makeWrapper ];

     

       28
       28

+1 -1

pkgs/applications/audio/google-musicmanager/default.nix

···

       1
       1
        
       { stdenv, fetchurl

     

       2
       2
        
       , flac, expat, libidn, qtbase, qtwebkit, libvorbis }:

     

       3
       3
       -
       assert stdenv.system == "x86_64-linux";

     

       3
       3
       +
       assert stdenv.hostPlatform.system == "x86_64-linux";

     

       4
       4
        
       

     

       5
       5
        
       stdenv.mkDerivation rec {

     

       6
       6
        
         version = "beta_1.0.467.4929-r0"; # friendly to nix-env version sorting algo

+2 -2

pkgs/applications/audio/renoise/default.nix

···

       17
       17
        
         version = "3.1.0";

     

       18
       18
        
       

     

       19
       19
        
         src =

     

       20
       20
       -
           if stdenv.system == "x86_64-linux" then

     

       20
       20
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       21
       21
        
               if builtins.isNull releasePath then

     

       22
       22
        
               fetchurl {

     

       23
       23
        
                 url = "https://files.renoise.com/demo/Renoise_${urlVersion version}_Demo_x86_64.tar.bz2";

     
···

       25
       25
        
               }

     

       26
       26
        
               else

     

       27
       27
        
               releasePath

     

       28
       28
       -
           else if stdenv.system == "i686-linux" then

     

       28
       28
       +
           else if stdenv.hostPlatform.system == "i686-linux" then

     

       29
       29
        
               if builtins.isNull releasePath then

     

       30
       30
        
               fetchurl {

     

       31
       31
        
                 url = "http://files.renoise.com/demo/Renoise_${urlVersion version}_Demo_x86.tar.bz2";

+2 -2

pkgs/applications/audio/transcribe/default.nix

···

       7
       7
        
         name = "transcribe-${version}";

     

       8
       8
        
         version = "8.40";

     

       9
       9
        
       

     

       10
       10
       -
         src = if stdenv.system == "i686-linux" then

     

       10
       10
       +
         src = if stdenv.hostPlatform.system == "i686-linux" then

     

       11
       11
        
           fetchzip {

     

       12
       12
        
             url = "https://www.seventhstring.com/xscribe/downlinux32_old/xscsetup.tar.gz";

     

       13
       13
        
             sha256 = "1ngidmj9zz8bmv754s5xfsjv7v6xr03vck4kigzq4bpc9b1fdhjq";

     

       14
       14
        
           }

     

       15
       15
       -
         else if stdenv.system == "x86_64-linux" then

     

       15
       15
       +
         else if stdenv.hostPlatform.system == "x86_64-linux" then

     

       16
       16
        
           fetchzip {

     

       17
       17
        
             url = "https://www.seventhstring.com/xscribe/downlinux64_old/xsc64setup.tar.gz";

     

       18
       18
        
             sha256 = "0svzi8svj6zn06gj0hr8mpnhq4416dvb4g5al0gpb1g3paywdaf9";

+1 -1

pkgs/applications/editors/eclipse/build-eclipse.nix

···

       2
       2
        
       , zlib, jdk, glib, gtk3, libXtst, gsettings-desktop-schemas, webkitgtk

     

       3
       3
        
       , makeWrapper, ... }:

     

       4
       4
        
       

     

       5
       5
       -
       { name, src ? builtins.getAttr stdenv.system sources, sources ? null, description }:

     

       5
       5
       +
       { name, src ? builtins.getAttr stdenv.hostPlatform.system sources, sources ? null, description }:

     

       6
       6
        
       

     

       7
       7
        
       stdenv.mkDerivation rec {

     

       8
       8
        
         inherit name src;

+7 -7

pkgs/applications/editors/eclipse/default.nix

···

       27
       27
        
           name = "eclipse-cpp-4.7.0";

     

       28
       28
        
           description = "Eclipse IDE for C/C++ Developers, Oxygen release";

     

       29
       29
        
           src =

     

       30
       30
       -
             if stdenv.system == "x86_64-linux" then

     

       30
       30
       +
             if stdenv.hostPlatform.system == "x86_64-linux" then

     

       31
       31
        
               fetchurl {

     

       32
       32
        
                 url = https://www.eclipse.org/downloads/download.php?r=1&nf=1&file=/technology/epp/downloads/release/oxygen/R/eclipse-cpp-oxygen-R-linux-gtk-x86_64.tar.gz;

     

       33
       33
        
                 sha512 = "813c791e739d7d0e2ab242a5bacadca135bbeee20ef97aa830353cd90f63fa6e9c89cfcc6aadf635c742befe035bd6e3f15103013f63c419f6144e86ebde3ed1";

     

       34
       34
        
               }

     

       35
       35
       -
             else if stdenv.system == "i686-linux" then

     

       35
       35
       +
             else if stdenv.hostPlatform.system == "i686-linux" then

     

       36
       36
        
               fetchurl {

     

       37
       37
        
                 url = https://www.eclipse.org/downloads/download.php?r=1&nf=1&file=/technology/epp/downloads/release/oxygen/R/eclipse-cpp-oxygen-R-linux-gtk.tar.gz;

     

       38
       38
        
                 sha512 = "2b50f4a00306a89cda1aaaa606e62285cacbf93464a9dd3f3319dca3e2c578b802e685de6f78e5e617d269e21271188effe73d41f491a6de946e28795d82db8a";

     

       39
       39
        
               }

     

       40
       40
       -
             else throw "Unsupported system: ${stdenv.system}";

     

       40
       40
       +
             else throw "Unsupported system: ${stdenv.hostPlatform.system}";

     

       41
       41
        
         };

     

       42
       42
        
       

     

       43
       43
        
         eclipse-cpp-37 = buildEclipse {

     

       44
       44
        
           name = "eclipse-cpp-3.7";

     

       45
       45
        
           description = "Eclipse IDE for C/C++ Developers";

     

       46
       46
        
           src =

     

       47
       47
       -
             if stdenv.system == "x86_64-linux" then

     

       47
       47
       +
             if stdenv.hostPlatform.system == "x86_64-linux" then

     

       48
       48
        
               fetchurl {

     

       49
       49
        
                 url = https://www.eclipse.org/downloads/download.php?r=1&nf=1&file=/technology/epp/downloads/release/indigo/R/eclipse-cpp-indigo-incubation-linux-gtk-x86_64.tar.gz;

     

       50
       50
        
                 sha256 = "14ppc9g9igzvj1pq7jl01vwhzb66nmzbl9wsdl1sf3xnwa9wnqk3";

     
···

       65
       65
        
           name = "eclipse-modeling-4.7";

     

       66
       66
        
           description = "Eclipse Modeling Tools";

     

       67
       67
        
           src =

     

       68
       68
       -
             if stdenv.system == "x86_64-linux" then

     

       68
       68
       +
             if stdenv.hostPlatform.system == "x86_64-linux" then

     

       69
       69
        
               fetchurl {

     

       70
       70
        
                 url = https://www.eclipse.org/downloads/download.php?r=1&nf=1&file=/technology/epp/downloads/release/oxygen/R/eclipse-modeling-oxygen-R-linux-gtk-x86_64.tar.gz;

     

       71
       71
        
                 sha512 = "3b9a7ad4b5d6b77fbdd64e8d323e0adb6c2904763ad042b374b4d87cef8607408cb407e395870fc755d58c0c800e20818adcf456ebe193d76cede16c5fe12271";

     
···

       81
       81
        
           name = "eclipse-modeling-3.6.2";

     

       82
       82
        
           description = "Eclipse Modeling Tools (includes Incubating components)";

     

       83
       83
        
           src =

     

       84
       84
       -
             if stdenv.system == "x86_64-linux" then

     

       84
       84
       +
             if stdenv.hostPlatform.system == "x86_64-linux" then

     

       85
       85
        
               fetchurl {

     

       86
       86
        
                 url = https://www.eclipse.org/downloads/download.php?r=1&nf=1&file=/technology/epp/downloads/release/helios/SR2/eclipse-modeling-helios-SR2-incubation-linux-gtk-x86_64.tar.gz;

     

       87
       87
        
                 sha1 = "e96f5f006298f68476f4a15a2be8589158d5cc61";

     
···

       151
       151
        
           name = "eclipse-scala-sdk-4.4.1";

     

       152
       152
        
           description = "Eclipse IDE for Scala Developers";

     

       153
       153
        
           src =

     

       154
       154
       -
             if stdenv.system == "x86_64-linux" then

     

       154
       154
       +
             if stdenv.hostPlatform.system == "x86_64-linux" then

     

       155
       155
        
               fetchurl { # tested

     

       156
       156
        
                 url = https://downloads.typesafe.com/scalaide-pack/4.4.1-vfinal-luna-211-20160504/scala-SDK-4.4.1-vfinal-2.11-linux.gtk.x86_64.tar.gz;

     

       157
       157
        
                 sha256  = "4c2d1ac68384e12a11a851cf0fc7757aea087eba69329b21d539382a65340d27";

+1 -1

pkgs/applications/editors/jetbrains/common.nix

···

       42
       42
        
             }

     

       43
       43
        
       

     

       44
       44
        
             interpreter=$(echo ${stdenv.glibc.out}/lib/ld-linux*.so.2)

     

       45
       45
       -
             if [ "${stdenv.system}" == "x86_64-linux" ]; then

     

       45
       45
       +
             if [ "${stdenv.hostPlatform.system}" == "x86_64-linux" ]; then

     

       46
       46
        
               target_size=$(get_file_size bin/fsnotifier64)

     

       47
       47
        
               patchelf --set-interpreter "$interpreter" bin/fsnotifier64

     

       48
       48
        
               munge_size_hack bin/fsnotifier64 $target_size

+7 -7

pkgs/applications/editors/kodestudio/default.nix

···

       8
       8
        
       

     

       9
       9
        
         version = "17.1";

     

       10
       10
        
       

     

       11
       11
       -
         sha256 = if stdenv.system == "x86_64-linux"  then "1kddisnvlk48jip6k59mw3wlkrl7rkck2lxpaghn0gfx02cvms5f"

     

       12
       12
       -
             else if stdenv.system == "i686-cygwin"   then "1izp42afrlh4yd322ax9w85ki388gnkqfqbw8dwnn4k3j7r5487z"

     

       13
       13
       -
             else throw "Unsupported system: ${stdenv.system}";

     

       11
       11
       +
         sha256 = if stdenv.hostPlatform.system == "x86_64-linux"  then "1kddisnvlk48jip6k59mw3wlkrl7rkck2lxpaghn0gfx02cvms5f"

     

       12
       12
       +
             else if stdenv.hostPlatform.system == "i686-cygwin"   then "1izp42afrlh4yd322ax9w85ki388gnkqfqbw8dwnn4k3j7r5487z"

     

       13
       13
       +
             else throw "Unsupported system: ${stdenv.hostPlatform.system}";

     

       14
       14
        
       

     

       15
       15
        
         urlBase = "https://github.com/Kode/KodeStudio/releases/download/v${version}/KodeStudio-";

     

       16
       16
        
       

     

       17
       17
       -
         urlStr = if stdenv.system == "x86_64-linux"  then urlBase + "linux64.tar.gz"

     

       18
       18
       -
             else if stdenv.system == "i686-cygwin"   then urlBase + "win32.zip"

     

       19
       19
       -
             else throw "Unsupported system: ${stdenv.system}";

     

       17
       17
       +
         urlStr = if stdenv.hostPlatform.system == "x86_64-linux"  then urlBase + "linux64.tar.gz"

     

       18
       18
       +
             else if stdenv.hostPlatform.system == "i686-cygwin"   then urlBase + "win32.zip"

     

       19
       19
       +
             else throw "Unsupported system: ${stdenv.hostPlatform.system}";

     

       20
       20
        
       

     

       21
       21
        
       in

     

       22
       22
        
       

     
···

       47
       47
        
             cp -r ./* $out

     

       48
       48
        
           '';

     

       49
       49
        
       

     

       50
       50
       -
           postFixup = lib.optionalString (stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux") ''

     

       50
       50
       +
           postFixup = lib.optionalString (stdenv.hostPlatform.system == "i686-linux" || stdenv.hostPlatform.system == "x86_64-linux") ''

     

       51
       51
        
             # Patch Binaries

     

       52
       52
        
             patchelf \

     

       53
       53
        
                 --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \

+2 -2

pkgs/applications/editors/music/tuxguitar/default.nix

···

       1
       1
        
       { stdenv, fetchurl, swt, jdk, makeWrapper, alsaLib }:

     

       2
       2
        
       

     

       3
       3
       -
       let metadata = assert stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux";

     

       4
       4
       -
         if stdenv.system == "i686-linux" then

     

       3
       3
       +
       let metadata = assert stdenv.hostPlatform.system == "i686-linux" || stdenv.hostPlatform.system == "x86_64-linux";

     

       4
       4
       +
         if stdenv.hostPlatform.system == "i686-linux" then

     

       5
       5
        
           { arch = "x86"; sha256 = "1qmb51k0538pn7gv4nsvhfv33xik4l4af0qmpllkzrikmj8wvzlb"; }

     

       6
       6
        
         else

     

       7
       7
        
           { arch = "x86_64"; sha256 = "12af47jhlrh9aq5b3d13l7cdhlndgnfpy61gz002hajbq7i00ixh"; };

+1 -1

pkgs/applications/editors/sublime/2/default.nix

···

       6
       6
        
       stdenv.mkDerivation rec {

     

       7
       7
        
         name = "sublimetext-2.0.2";

     

       8
       8
        
         src =

     

       9
       9
       -
           if stdenv.system == "i686-linux" then

     

       9
       9
       +
           if stdenv.hostPlatform.system == "i686-linux" then

     

       10
       10
        
             fetchurl {

     

       11
       11
        
               name = "sublimetext-2.0.2.tar.bz2";

     

       12
       12
        
               url = http://c758482.r82.cf2.rackcdn.com/Sublime%20Text%202.0.2.tar.bz2;

+2 -2

pkgs/applications/editors/sublime/3/common.nix

···

       13
       13
        
           ++ stdenv.lib.optional gksuSupport "/usr/bin/gksudo=${gksu}/bin/gksudo";

     

       14
       14
        
       in let

     

       15
       15
        
         archSha256 =

     

       16
       16
       -
           if stdenv.system == "i686-linux" then

     

       16
       16
       +
           if stdenv.hostPlatform.system == "i686-linux" then

     

       17
       17
        
             x32sha256

     

       18
       18
        
           else

     

       19
       19
        
             x64sha256;

     

       20
       20
        
       

     

       21
       21
        
         arch =

     

       22
       22
       -
           if stdenv.system == "i686-linux" then

     

       22
       22
       +
           if stdenv.hostPlatform.system == "i686-linux" then

     

       23
       23
        
             "x32"

     

       24
       24
        
           else

     

       25
       25
        
             "x64";

+1 -1

pkgs/applications/editors/typora/default.nix

···

       6
       6
        
         version = "0.9.53";

     

       7
       7
        
       

     

       8
       8
        
         src =

     

       9
       9
       -
           if stdenv.system == "x86_64-linux" then

     

       9
       9
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       10
       10
        
             fetchurl {

     

       11
       11
        
               url = "https://www.typora.io/linux/typora_${version}_amd64.deb";

     

       12
       12
        
               sha256 = "02k6x30l4mbjragqbq5rn663xbw3h4bxzgppfxqf5lwydswldklb";

+6 -6

pkgs/applications/editors/vscode/default.nix

···

       9
       9
        
           "i686-linux" = "linux-ia32";

     

       10
       10
        
           "x86_64-linux" = "linux-x64";

     

       11
       11
        
           "x86_64-darwin" = "darwin";

     

       12
       12
       -
         }.${stdenv.system};

     

       12
       12
       +
         }.${stdenv.hostPlatform.system};

     

       13
       13
        
       

     

       14
       14
        
         sha256 = {

     

       15
       15
        
           "i686-linux" = "1g7kqbz6mrf8ngx2bnwpi9fifq5rjznxgsgwjb532z3nh92ypa8n";

     

       16
       16
        
           "x86_64-linux" = "02yldycakn5zxj1ji4nmhdyazqlkjqpzdj3g8j501c3j28pgiwjy";

     

       17
       17
        
           "x86_64-darwin" = "0pnsfkh20mj7pzqw7wlfd98jqc6a1mnsq1iira15n7fafqgj8zpl";

     

       18
       18
       -
         }.${stdenv.system};

     

       18
       18
       +
         }.${stdenv.hostPlatform.system};

     

       19
       19
        
       

     

       20
       20
       -
         archive_fmt = if stdenv.system == "x86_64-darwin" then "zip" else "tar.gz";

     

       20
       20
       +
         archive_fmt = if stdenv.hostPlatform.system == "x86_64-darwin" then "zip" else "tar.gz";

     

       21
       21
        
       

     

       22
       22
        
         rpath = lib.concatStringsSep ":" [

     

       23
       23
        
           atomEnv.libPath

     
···

       48
       48
        
             categories = "GNOME;GTK;Utility;TextEditor;Development;";

     

       49
       49
        
           };

     

       50
       50
        
       

     

       51
       51
       -
           buildInputs = if stdenv.system == "x86_64-darwin"

     

       51
       51
       +
           buildInputs = if stdenv.hostPlatform.system == "x86_64-darwin"

     

       52
       52
        
             then [ unzip libXScrnSaver libsecret ]

     

       53
       53
        
             else [ wrapGAppsHook libXScrnSaver libxkbfile libsecret ];

     

       54
       54
        
       

     

       55
       55
        
           installPhase =

     

       56
       56
       -
             if stdenv.system == "x86_64-darwin" then ''

     

       56
       56
       +
             if stdenv.hostPlatform.system == "x86_64-darwin" then ''

     

       57
       57
        
               mkdir -p $out/lib/vscode $out/bin

     

       58
       58
        
               cp -r ./* $out/lib/vscode

     

       59
       59
        
               ln -s $out/lib/vscode/Contents/Resources/app/bin/code $out/bin

     
···

       72
       72
        
               cp $out/lib/vscode/resources/app/resources/linux/code.png $out/share/pixmaps/code.png

     

       73
       73
        
             '';

     

       74
       74
        
       

     

       75
       75
       -
           postFixup = lib.optionalString (stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux") ''

     

       75
       75
       +
           postFixup = lib.optionalString (stdenv.hostPlatform.system == "i686-linux" || stdenv.hostPlatform.system == "x86_64-linux") ''

     

       76
       76
        
             patchelf \

     

       77
       77
        
               --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \

     

       78
       78
        
               --set-rpath "${rpath}" \

+4 -4

pkgs/applications/graphics/ImageMagick/7.0.nix

···

       7
       7
        
       

     

       8
       8
        
       let

     

       9
       9
        
         arch =

     

       10
       10
       -
           if stdenv.system == "i686-linux" then "i686"

     

       11
       11
       -
           else if stdenv.system == "x86_64-linux" || stdenv.system == "x86_64-darwin" then "x86-64"

     

       12
       12
       -
           else if stdenv.system == "armv7l-linux" then "armv7l"

     

       13
       13
       -
           else if stdenv.system == "aarch64-linux" then "aarch64"

     

       10
       10
       +
           if stdenv.hostPlatform.system == "i686-linux" then "i686"

     

       11
       11
       +
           else if stdenv.hostPlatform.system == "x86_64-linux" || stdenv.hostPlatform.system == "x86_64-darwin" then "x86-64"

     

       12
       12
       +
           else if stdenv.hostPlatform.system == "armv7l-linux" then "armv7l"

     

       13
       13
       +
           else if stdenv.hostPlatform.system == "aarch64-linux" then "aarch64"

     

       14
       14
        
           else throw "ImageMagick is not supported on this platform.";

     

       15
       15
        
       

     

       16
       16
        
         cfg = {

+4 -4

pkgs/applications/graphics/ImageMagick/default.nix

···

       7
       7
        
       

     

       8
       8
        
       let

     

       9
       9
        
         arch =

     

       10
       10
       -
           if stdenv.system == "i686-linux" then "i686"

     

       11
       11
       -
           else if stdenv.system == "x86_64-linux" || stdenv.system == "x86_64-darwin" then "x86-64"

     

       12
       12
       -
           else if stdenv.system == "armv7l-linux" then "armv7l"

     

       13
       13
       -
           else if stdenv.system == "aarch64-linux" then "aarch64"

     

       10
       10
       +
           if stdenv.hostPlatform.system == "i686-linux" then "i686"

     

       11
       11
       +
           else if stdenv.hostPlatform.system == "x86_64-linux" || stdenv.hostPlatform.system == "x86_64-darwin" then "x86-64"

     

       12
       12
       +
           else if stdenv.hostPlatform.system == "armv7l-linux" then "armv7l"

     

       13
       13
       +
           else if stdenv.hostPlatform.system == "aarch64-linux" then "aarch64"

     

       14
       14
        
           else throw "ImageMagick is not supported on this platform.";

     

       15
       15
        
       

     

       16
       16
        
         cfg = {

+2 -2

pkgs/applications/graphics/gcolor2/default.nix

···

       3
       3
        
       let version = "0.4"; in

     

       4
       4
        
       stdenv.mkDerivation {

     

       5
       5
        
         name = "gcolor2-${version}";

     

       6
       6
       -
         arch = if stdenv.system == "x86_64-linux" then "amd64" else "386";

     

       6
       6
       +
         arch = if stdenv.hostPlatform.system == "x86_64-linux" then "amd64" else "386";

     

       7
       7
        
       

     

       8
       8
        
         src = fetchurl {

     

       9
       9
        
           url = "mirror://sourceforge/project/gcolor2/gcolor2/${version}/gcolor2-${version}.tar.bz2";

     
···

       16
       16
        
         '';

     

       17
       17
        
       

     

       18
       18
        
         # from https://github.com/PhantomX/slackbuilds/tree/master/gcolor2/patches

     

       19
       19
       -
         patches = if stdenv.system == "x86_64-linux" then

     

       19
       19
       +
         patches = if stdenv.hostPlatform.system == "x86_64-linux" then

     

       20
       20
        
               [ ./gcolor2-amd64.patch ] else

     

       21
       21
        
               [ ];

     

       22
       22

+3 -3

pkgs/applications/graphics/sane/backends/brscan4/default.nix

···

       12
       12
        
       in stdenv.mkDerivation rec {

     

       13
       13
        
         name = "brscan4-0.4.4-4";

     

       14
       14
        
         src = 

     

       15
       15
       -
           if stdenv.system == "i686-linux" then

     

       15
       15
       +
           if stdenv.hostPlatform.system == "i686-linux" then

     

       16
       16
        
             fetchurl {

     

       17
       17
        
               url = "http://download.brother.com/welcome/dlf006646/${name}.i386.deb";

     

       18
       18
        
               sha256 = "13mhjbzf9nvpdzrc2s98684r7likg76zxs1wlz2h8w59fsqgx4k2";

     

       19
       19
        
             }

     

       20
       20
       -
           else if stdenv.system == "x86_64-linux" then

     

       20
       20
       +
           else if stdenv.hostPlatform.system == "x86_64-linux" then

     

       21
       21
        
             fetchurl {

     

       22
       22
        
               url = "https://download.brother.com/welcome/dlf006645/${name}.amd64.deb";

     

       23
       23
        
               sha256 = "0xy5px96y1saq9l80vwvfn6anr2q42qlxdhm6ci2a0diwib5q9fd";

     

       24
       24
        
             }

     

       25
       25
       -
           else throw "${name} is not supported on ${stdenv.system} (only i686-linux and x86_64 linux are supported)";

     

       25
       25
       +
           else throw "${name} is not supported on ${stdenv.hostPlatform.system} (only i686-linux and x86_64 linux are supported)";

     

       26
       26
        
       

     

       27
       27
        
         unpackPhase = ''

     

       28
       28
        
           ar x $src

+3 -3

pkgs/applications/graphics/unigine-valley/default.nix

···

       17
       17
        
       let

     

       18
       18
        
         version = "1.0";

     

       19
       19
        
       

     

       20
       20
       -
         arch = if stdenv.system == "x86_64-linux" then

     

       20
       20
       +
         arch = if stdenv.hostPlatform.system == "x86_64-linux" then

     

       21
       21
        
           "x64"

     

       22
       22
       -
         else if stdenv.system == "i686-linux" then

     

       22
       22
       +
         else if stdenv.hostPlatform.system == "i686-linux" then

     

       23
       23
        
           "x86"

     

       24
       24
        
         else

     

       25
       25
       -
           throw "Unsupported platform ${stdenv.system}";

     

       25
       25
       +
           throw "Unsupported platform ${stdenv.hostPlatform.system}";

     

       26
       26
        
       

     

       27
       27
        
       in

     

       28
       28
        
         stdenv.mkDerivation rec {

+3 -3

pkgs/applications/misc/1password/default.nix

···

       4
       4
        
         name = "1password-${version}";

     

       5
       5
        
         version = "0.5.3";

     

       6
       6
        
         src =

     

       7
       7
       -
           if stdenv.system == "i686-linux" then

     

       7
       7
       +
           if stdenv.hostPlatform.system == "i686-linux" then

     

       8
       8
        
             fetchzip {

     

       9
       9
        
               url = "https://cache.agilebits.com/dist/1P/op/pkg/v${version}/op_linux_386_v${version}.zip";

     

       10
       10
        
               sha256 = "05s223h1yps4k9kmignl0r5sbh6w7m1hnlmafnf1kiwv7gacvxjc";

     

       11
       11
        
               stripRoot = false;

     

       12
       12
        
             }

     

       13
       13
       -
           else if stdenv.system == "x86_64-linux" then

     

       13
       13
       +
           else if stdenv.hostPlatform.system == "x86_64-linux" then

     

       14
       14
        
             fetchzip {

     

       15
       15
        
               url = "https://cache.agilebits.com/dist/1P/op/pkg/v${version}/op_linux_amd64_v${version}.zip";

     

       16
       16
        
               sha256 = "0p9x1fx0309v8dxxaf88m8x8q15zzqywfmjn6v5wb9v3scp9396v";

     

       17
       17
        
               stripRoot = false;

     

       18
       18
        
             }

     

       19
       19
       -
           else if stdenv.system == "x86_64-darwin" then

     

       19
       19
       +
           else if stdenv.hostPlatform.system == "x86_64-darwin" then

     

       20
       20
        
             fetchzip {

     

       21
       21
        
               url = "https://cache.agilebits.com/dist/1P/op/pkg/v${version}/op_darwin_amd64_v${version}.zip";

     

       22
       22
        
               sha256 = "1z2xp9bn93gr4ha6zx65va1fb58a2xlnnmpv583y96gq3vbnqdcj";

+1 -1

pkgs/applications/misc/adobe-reader/default.nix

···

       1
       1
        
       { stdenv, fetchurl, libX11, cups, zlib, libxml2, pango, atk, gtk2, glib

     

       2
       2
        
       , gdk_pixbuf }:

     

       3
       3
        
       

     

       4
       4
       -
       assert stdenv.system == "i686-linux";

     

       4
       4
       +
       assert stdenv.hostPlatform.system == "i686-linux";

     

       5
       5
        
       

     

       6
       6
        
       let version = "9.5.5"; in

     

       7
       7

+3 -3

pkgs/applications/misc/cura/lulzbot.nix

···

       8
       8
        
         version = "15.02.1-1.03-5064";

     

       9
       9
        
       

     

       10
       10
        
         src =

     

       11
       11
       -
           if stdenv.system == "x86_64-linux" then

     

       11
       11
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       12
       12
        
             fetchurl {

     

       13
       13
        
               url = "https://download.alephobjects.com/ao/aodeb/dists/jessie/main/binary-amd64/cura_${version}_amd64.deb";

     

       14
       14
        
               sha256 = "1gsfidg3gim5pjbl82vkh0cw4ya253m4p7nirm8nr6yjrsirkzxg";

     

       15
       15
        
             }

     

       16
       16
       -
           else if stdenv.system == "i686-linux" then

     

       16
       16
       +
           else if stdenv.hostPlatform.system == "i686-linux" then

     

       17
       17
        
             fetchurl {

     

       18
       18
        
               url = "http://download.alephobjects.com/ao/aodeb/dists/jessie/main/binary-i386/cura_${version}_i386.deb";

     

       19
       19
        
               sha256 = "0xd3df6bxq4rijgvsqvps454jkc1nzhxbdzzj6j2w317ppsbhyc1";

     

       20
       20
        
             }

     

       21
       21
       -
           else throw "${name} is not supported on ${stdenv.system}";

     

       21
       21
       +
           else throw "${name} is not supported on ${stdenv.hostPlatform.system}";

     

       22
       22
        
       

     

       23
       23
        
         python_deps = with py; [ pyopengl pyserial numpy wxPython30 power setuptools ];

     

       24
       24
        
         pythonPath = python_deps;

+3 -3

pkgs/applications/misc/googleearth/default.nix

···

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
        
         arch =

     

       7
       7
       -
           if stdenv.system == "x86_64-linux" then "amd64"

     

       8
       8
       -
           else if stdenv.system == "i686-linux" then "i386"

     

       9
       9
       -
           else throw "Unsupported system ${stdenv.system}";

     

       7
       7
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then "amd64"

     

       8
       8
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "i386"

     

       9
       9
       +
           else throw "Unsupported system ${stdenv.hostPlatform.system}";

     

       10
       10
        
         sha256 =

     

       11
       11
        
           if arch == "amd64"

     

       12
       12
        
           then "0dwnppn5snl5bwkdrgj4cyylnhngi0g66fn2k41j3dvis83x24k6"

+2 -2

pkgs/applications/misc/icesl/default.nix

···

       6
       6
        
         name = "iceSL-${version}";

     

       7
       7
        
         version = "2.1.10";

     

       8
       8
        
       

     

       9
       9
       -
         src =  if stdenv.system == "x86_64-linux" then fetchzip {

     

       9
       9
       +
         src =  if stdenv.hostPlatform.system == "x86_64-linux" then fetchzip {

     

       10
       10
        
           url = "https://gforge.inria.fr/frs/download.php/file/37268/icesl${version}-amd64.zip";

     

       11
       11
        
           sha256 = "0dv3mq6wy46xk9blzzmgbdxpsjdaxid3zadfrysxlhmgl7zb2cn2";

     

       12
       12
       -
         } else if stdenv.system == "i686-linux" then fetchzip {

     

       12
       12
       +
         } else if stdenv.hostPlatform.system == "i686-linux" then fetchzip {

     

       13
       13
        
           url = "https://gforge.inria.fr/frs/download.php/file/37267/icesl${version}-i386.zip";

     

       14
       14
        
           sha256 = "0sl54fsb2gz6dy0bwdscpdq1ab6ph5b7zald3bwzgkqsvna7p1jr";

     

       15
       15
        
         } else throw "Unsupported architecture";

+1 -1

pkgs/applications/misc/kdbplus/default.nix

···

       1
       1
        
       { stdenv, requireFile, unzip, rlwrap, bash }:

     

       2
       2
        
       

     

       3
       3
       -
       assert (stdenv.system == "i686-linux");

     

       3
       3
       +
       assert (stdenv.hostPlatform.system == "i686-linux");

     

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
        
         libPath = stdenv.lib.makeLibraryPath

+1 -1

pkgs/applications/misc/kiwix/default.nix

···

       25
       25
        
           sha256 = "1h9vcbvf8wgds6i2z20y7krpys0mqsqhv1ijyfljanp6vyll9fvi";

     

       26
       26
        
         };

     

       27
       27
        
       

     

       28
       28
       -
         xulrunner = if stdenv.system == "x86_64-linux"

     

       28
       28
       +
         xulrunner = if stdenv.hostPlatform.system == "x86_64-linux"

     

       29
       29
        
                     then { tar = xulrunner64_tar; sdk = xulrunnersdk64_tar; }

     

       30
       30
        
                     else { tar = xulrunner32_tar; sdk = xulrunnersdk32_tar; };

     

       31
       31

+4 -4

pkgs/applications/misc/playonlinux/default.nix

···

       44
       44
        
           ];

     

       45
       45
        
       

     

       46
       46
        
         ld32 =

     

       47
       47
       -
           if stdenv.system == "x86_64-linux" then "${stdenv.cc}/nix-support/dynamic-linker-m32"

     

       48
       48
       -
           else if stdenv.system == "i686-linux" then "${stdenv.cc}/nix-support/dynamic-linker"

     

       49
       49
       -
           else throw "Unsupported platform for PlayOnLinux: ${stdenv.system}";

     

       47
       47
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then "${stdenv.cc}/nix-support/dynamic-linker-m32"

     

       48
       48
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "${stdenv.cc}/nix-support/dynamic-linker"

     

       49
       49
       +
           else throw "Unsupported platform for PlayOnLinux: ${stdenv.hostPlatform.system}";

     

       50
       50
        
         ld64 = "${stdenv.cc}/nix-support/dynamic-linker";

     

       51
       51
        
         libs = pkgs: stdenv.lib.makeLibraryPath [ pkgs.xorg.libX11 ];

     

       52
       52
        
       

     
···

       83
       83
        
       

     

       84
       84
        
           bunzip2 $out/share/playonlinux/bin/check_dd_x86.bz2

     

       85
       85
        
           patchelf --set-interpreter $(cat ${ld32}) --set-rpath ${libs pkgsi686Linux} $out/share/playonlinux/bin/check_dd_x86

     

       86
       86
       -
           ${if stdenv.system == "x86_64-linux" then ''

     

       86
       86
       +
           ${if stdenv.hostPlatform.system == "x86_64-linux" then ''

     

       87
       87
        
             bunzip2 $out/share/playonlinux/bin/check_dd_amd64.bz2

     

       88
       88
        
             patchelf --set-interpreter $(cat ${ld64}) --set-rpath ${libs pkgs} $out/share/playonlinux/bin/check_dd_amd64

     

       89
       89
        
           '' else ''

+1 -1

pkgs/applications/misc/rescuetime/default.nix

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         src =

     

       5
       5
       -
           if stdenv.system == "i686-linux" then fetchurl {

     

       5
       5
       +
           if stdenv.hostPlatform.system == "i686-linux" then fetchurl {

     

       6
       6
        
             name = "rescuetime-installer.deb";

     

       7
       7
        
             url = "https://www.rescuetime.com/installers/rescuetime_current_i386.deb";

     

       8
       8
        
             sha256 = "06q1jwqsrjvlj820dd4vl80jznwafsqshsg0p6si8qx4721blryz";

+1 -1

pkgs/applications/misc/sweethome3d/default.nix

···

       55
       55
        
       

     

       56
       56
        
             makeWrapper ${jre}/bin/java $out/bin/$exec \

     

       57
       57
        
               --prefix XDG_DATA_DIRS : "$XDG_ICON_DIRS:${gtk3.out}/share:${gsettings-desktop-schemas}/share:$out/share:$GSETTINGS_SCHEMAS_PATH" \

     

       58
       58
       -
               --add-flags "-jar $out/share/java/${module}-${version}.jar -cp $out/share/java/Furniture.jar:$out/share/java/Textures.jar:$out/share/java/Help.jar ${if stdenv.system == "x86_64-linux" then "-d64" else "-d32"}"

     

       58
       58
       +
               --add-flags "-jar $out/share/java/${module}-${version}.jar -cp $out/share/java/Furniture.jar:$out/share/java/Textures.jar:$out/share/java/Help.jar -d${toString stdenv.hostPlatform.parsed.cpu.bits}"

     

       59
       59
        
           '';

     

       60
       60
        
       

     

       61
       61
        
           dontStrip = true;

+1 -1

pkgs/applications/misc/sweethome3d/editors.nix

···

       44
       44
        
             cp "${editorItem}/share/applications/"* $out/share/applications

     

       45
       45
        
             makeWrapper ${jre}/bin/java $out/bin/$exec \

     

       46
       46
        
               --prefix XDG_DATA_DIRS : "$XDG_ICON_DIRS:${gtk3.out}/share:${gsettings-desktop-schemas}/share:$out/share:$GSETTINGS_SCHEMAS_PATH" \

     

       47
       47
       -
               --add-flags "-jar $out/share/java/${module}-${version}.jar ${if stdenv.system == "x86_64-linux" then "-d64" else "-d32"}"

     

       47
       47
       +
               --add-flags "-jar $out/share/java/${module}-${version}.jar -d${toString stdenv.hostPlatform.parsed.cpu.bits}"

     

       48
       48
        
           '';

     

       49
       49
        
       

     

       50
       50
        
           dontStrip = true;

+3 -3

pkgs/applications/misc/xmind/default.nix

···

       4
       4
        
         name = "xmind-${version}";

     

       5
       5
        
         version = "7.5-update1";

     

       6
       6
        
       

     

       7
       7
       -
         src = if stdenv.system == "i686-linux" then fetchurl {

     

       7
       7
       +
         src = if stdenv.hostPlatform.system == "i686-linux" then fetchurl {

     

       8
       8
        
           url = "http://dl2.xmind.net/xmind-downloads/${name}-linux_i386.deb";

     

       9
       9
        
           sha256 = "04kr6pw0kwy715bp9wcnqnw1k5wl65xa87lhljrskm291p402jy1";

     

       10
       10
       -
         } else if stdenv.system == "x86_64-linux" then fetchurl {

     

       10
       10
       +
         } else if stdenv.hostPlatform.system == "x86_64-linux" then fetchurl {

     

       11
       11
        
           url = "http://dl2.xmind.net/xmind-downloads/${name}-linux_amd64.deb";

     

       12
       12
        
           sha256 = "1j2ynhk7p3m3vd6c4mjwpnlzqgfj5c4q3zydab3nfwncwx6gaqj9";

     

       13
       13
       -
         } else throw "platform ${stdenv.system} not supported!";

     

       13
       13
       +
         } else throw "platform ${stdenv.hostPlatform.system} not supported!";

     

       14
       14
        
       

     

       15
       15
        
         nativeBuildInputs = [ dpkg makeWrapper ];

     

       16
       16

+3 -3

pkgs/applications/networking/apache-directory-studio/default.nix

···

       21
       21
        
         version = "2.0.0.v20170904-M13";

     

       22
       22
        
       

     

       23
       23
        
         src =

     

       24
       24
       -
           if stdenv.system == "x86_64-linux" then

     

       24
       24
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       25
       25
        
             fetchurl {

     

       26
       26
        
               url = "mirror://apache/directory/studio/${version}/ApacheDirectoryStudio-${version}-linux.gtk.x86_64.tar.gz";

     

       27
       27
        
               sha256 = "1jfnm6m0ijk31r30hhrxxnizk742dm317iny041p29v897rma7aq";

     

       28
       28
        
             }

     

       29
       29
       -
           else if stdenv.system == "i686-linux" then

     

       29
       29
       +
           else if stdenv.hostPlatform.system == "i686-linux" then

     

       30
       30
        
             fetchurl {

     

       31
       31
        
               url = "mirror://apache/directory/studio/${version}/ApacheDirectoryStudio-${version}-linux.gtk.x86.tar.gz";

     

       32
       32
        
               sha256 = "1bxmgram42qyhrqkgp5k8770f5mjjdd4c6xl4gj09smiycm1qa4n";

     

       33
       33
        
             }

     

       34
       34
       -
           else throw "Unsupported system: ${stdenv.system}";

     

       34
       34
       +
           else throw "Unsupported system: ${stdenv.hostPlatform.system}";

     

       35
       35
        
       

     

       36
       36
        
         buildInputs = [ makeWrapper ];

     

       37
       37

+3 -3

pkgs/applications/networking/bittorrentsync/generic.nix

···

       4
       4
        
         arch = {

     

       5
       5
        
           "x86_64-linux" = "x64";

     

       6
       6
        
           "i686-linux" = "i386";

     

       7
       7
       -
         }.${stdenv.system} or throwSystem;

     

       7
       7
       +
         }.${stdenv.hostPlatform.system} or throwSystem;

     

       8
       8
        
         libPath = stdenv.lib.makeLibraryPath [ stdenv.cc.libc ];

     

       9
       9
       -
         throwSystem = throw "Unsupported system: ${stdenv.system}";

     

       9
       9
       +
         throwSystem = throw "Unsupported system: ${stdenv.hostPlatform.system}";

     

       10
       10
        
       in

     

       11
       11
        
       

     

       12
       12
        
       stdenv.mkDerivation rec {

     
···

       20
       20
        
             "https://download-cdn.getsync.com/${version}/linux-${arch}/BitTorrent-Sync_${arch}.tar.gz"

     

       21
       21
        
             "http://syncapp.bittorrent.com/${version}/btsync_${arch}-${version}.tar.gz"

     

       22
       22
        
           ];

     

       23
       23
       -
           sha256 = sha256s.${stdenv.system} or throwSystem;

     

       23
       23
       +
           sha256 = sha256s.${stdenv.hostPlatform.system} or throwSystem;

     

       24
       24
        
         };

     

       25
       25
        
       

     

       26
       26
        
         dontStrip = true; # Don't strip, otherwise patching the rpaths breaks

+1 -1

pkgs/applications/networking/browsers/firefox-bin/default.nix

···

       59
       59
        
           "x86_64-linux" = "linux-x86_64";

     

       60
       60
        
         };

     

       61
       61
        
       

     

       62
       62
       -
         arch = mozillaPlatforms.${stdenv.system};

     

       62
       62
       +
         arch = mozillaPlatforms.${stdenv.hostPlatform.system};

     

       63
       63
        
       

     

       64
       64
        
         isPrefixOf = prefix: string:

     

       65
       65
        
           builtins.substring 0 (builtins.stringLength prefix) string == prefix;

+4 -4

pkgs/applications/networking/browsers/firefox/wrapper.nix

···

       36
       36
        
             jre = cfg.jre or false;

     

       37
       37
        
             icedtea = cfg.icedtea or false;

     

       38
       38
        
             supportsJDK =

     

       39
       39
       -
               stdenv.system == "i686-linux" ||

     

       40
       40
       -
               stdenv.system == "x86_64-linux" ||

     

       41
       41
       -
               stdenv.system == "armv7l-linux" ||

     

       42
       42
       -
               stdenv.system == "aarch64-linux";

     

       39
       39
       +
               stdenv.hostPlatform.system == "i686-linux" ||

     

       40
       40
       +
               stdenv.hostPlatform.system == "x86_64-linux" ||

     

       41
       41
       +
               stdenv.hostPlatform.system == "armv7l-linux" ||

     

       42
       42
       +
               stdenv.hostPlatform.system == "aarch64-linux";

     

       43
       43
        
       

     

       44
       44
        
             plugins =

     

       45
       45
        
               assert !(jre && icedtea);

+3 -3

pkgs/applications/networking/browsers/mozilla-plugins/flashplayer/default.nix

···

       60
       60
        
       

     

       61
       61
        
       let

     

       62
       62
        
         arch =

     

       63
       63
       -
           if stdenv.system == "x86_64-linux" then

     

       63
       63
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       64
       64
        
             "x86_64"

     

       65
       65
       -
           else if stdenv.system == "i686-linux"   then

     

       65
       65
       +
           else if stdenv.hostPlatform.system == "i686-linux"   then

     

       66
       66
        
             "i386"

     

       67
       67
        
           else throw "Flash Player is not supported on this platform";

     

       68
       68
        
         lib_suffix =

     

       69
       69
       -
             if stdenv.system == "x86_64-linux" then

     

       69
       69
       +
             if stdenv.hostPlatform.system == "x86_64-linux" then

     

       70
       70
        
             "64"

     

       71
       71
        
           else

     

       72
       72
        
             "";

+2 -2

pkgs/applications/networking/browsers/mozilla-plugins/google-talk-plugin/default.nix

···

       54
       54
        
         version = "5.41.3.0";

     

       55
       55
        
       

     

       56
       56
        
         src =

     

       57
       57
       -
           if stdenv.system == "x86_64-linux" then

     

       57
       57
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       58
       58
        
             fetchurl {

     

       59
       59
        
               url = "${baseURL}/google-talkplugin_${version}-1_amd64.deb";

     

       60
       60
        
               sha1 = "0bbc3d6997ba22ce712d93e5bc336c894b54fc81";

     

       61
       61
        
             }

     

       62
       62
       -
           else if stdenv.system == "i686-linux" then

     

       62
       62
       +
           else if stdenv.hostPlatform.system == "i686-linux" then

     

       63
       63
        
             fetchurl {

     

       64
       64
        
               url = "${baseURL}/google-talkplugin_${version}-1_i386.deb";

     

       65
       65
        
               sha1 = "6eae0544858f85c68b0cc46d7786e990bd94f139";

+1 -1

pkgs/applications/networking/browsers/mozilla-plugins/trezor/default.nix

···

       8
       8
        
         };

     

       9
       9
        
       

     

       10
       10
        
         src =

     

       11
       11
       -
           if stdenv.system == "x86_64-linux" then

     

       11
       11
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       12
       12
        
             fetchurl {

     

       13
       13
        
               url    = https://mytrezor.com/data/plugin/1.0.5/browser-plugin-trezor_1.0.5_amd64.deb;

     

       14
       14
        
               sha256 = "0097h4v88yca4aayzprrh4pk03xvvj7ncz2mi83chm81gsr2v67z";

+1 -1

pkgs/applications/networking/browsers/tor-browser-bundle-bin/default.nix

···

       125
       125
        
         name = "tor-browser-bundle-bin-${version}";

     

       126
       126
        
         inherit version;

     

       127
       127
        
       

     

       128
       128
       -
         src = srcs."${stdenv.system}" or (throw "unsupported system: ${stdenv.system}");

     

       128
       128
       +
         src = srcs."${stdenv.hostPlatform.system}" or (throw "unsupported system: ${stdenv.hostPlatform.system}");

     

       129
       129
        
       

     

       130
       130
        
         preferLocalBuild = true;

     

       131
       131
        
         allowSubstitutes = false;

+2 -2

pkgs/applications/networking/dropbox/default.nix

···

       2
       2
        
       

     

       3
       3
        
       let platforms = [ "i686-linux" "x86_64-linux" ]; in

     

       4
       4
        
       

     

       5
       5
       -
       assert lib.elem stdenv.system platforms;

     

       5
       5
       +
       assert lib.elem stdenv.hostPlatform.system platforms;

     

       6
       6
        
       

     

       7
       7
        
       # Dropbox client to bootstrap installation.

     

       8
       8
        
       # The client is self-updating, so the actual version may be newer.

     
···

       12
       12
        
         arch = {

     

       13
       13
        
           "x86_64-linux" = "x86_64";

     

       14
       14
        
           "i686-linux"   = "x86";

     

       15
       15
       -
         }.${stdenv.system};

     

       15
       15
       +
         }.${stdenv.hostPlatform.system};

     

       16
       16
        
       

     

       17
       17
        
         installer = "https://clientupdates.dropboxstatic.com/dbx-releng/client/dropbox-lnx.${arch}-${version}.tar.gz";

     

       18
       18
        
       in

+1 -1

pkgs/applications/networking/instant-messengers/franz/default.nix

···

       3
       3
        
       , gnome2, dbus, nss, nspr, alsaLib, cups, expat, udev, libnotify, xdg_utils }:

     

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
       -
         bits = if stdenv.system == "x86_64-linux" then "x64"

     

       6
       6
       +
         bits = if stdenv.hostPlatform.system == "x86_64-linux" then "x64"

     

       7
       7
        
                else "ia32";

     

       8
       8
        
       

     

       9
       9
        
         version = "4.0.4";

+3 -3

pkgs/applications/networking/instant-messengers/mattermost-desktop/default.nix

···

       41
       41
        
           version = "4.1.2";

     

       42
       42
        
       

     

       43
       43
        
           src =

     

       44
       44
       -
             if stdenv.system == "x86_64-linux" then

     

       44
       44
       +
             if stdenv.hostPlatform.system == "x86_64-linux" then

     

       45
       45
        
               fetchurl {

     

       46
       46
        
                 url = "https://releases.mattermost.com/desktop/${version}/${name}-linux-x64.tar.gz";

     

       47
       47
        
                 sha256 = "16dn6870bs1nfl2082ym9gwvmqb3i5sli48qprap80p7riph6k9s";

     

       48
       48
        
               }

     

       49
       49
       -
             else if stdenv.system == "i686-linux" then

     

       49
       49
       +
             else if stdenv.hostPlatform.system == "i686-linux" then

     

       50
       50
        
               fetchurl {

     

       51
       51
        
                 url = "https://releases.mattermost.com/desktop/${version}/${name}-linux-ia32.tar.gz";

     

       52
       52
        
                 sha256 = "145zb1l37fa2slfrrlprlwzcc5km3plxs374yhgix25mlg2afkqr";

     

       53
       53
        
               }

     

       54
       54
        
             else

     

       55
       55
       -
               throw "Mattermost-Desktop is not currently supported on ${stdenv.system}";

     

       55
       55
       +
               throw "Mattermost-Desktop is not currently supported on ${stdenv.hostPlatform.system}";

     

       56
       56
        
       

     

       57
       57
        
           phases = [ "unpackPhase" "installPhase" ];

     

       58
       58
        
           installPhase = ''

+1 -1

pkgs/applications/networking/instant-messengers/rambox/sencha/bare.nix

···

       18
       18
        
         inherit version;

     

       19
       19
        
       

     

       20
       20
        
         name = "sencha-bare-${version}";

     

       21
       21
       -
         src = srcs.${stdenv.system};

     

       21
       21
       +
         src = srcs.${stdenv.hostPlatform.system};

     

       22
       22
        
       

     

       23
       23
        
         nativeBuildInputs = [ gzip which unzip ];

     

       24
       24
        
         buildInputs = [ jdk ];

+2 -2

pkgs/applications/networking/instant-messengers/skypeforlinux/default.nix

···

       53
       53
        
         ] + ":${stdenv.cc.cc.lib}/lib64";

     

       54
       54
        
       

     

       55
       55
        
         src =

     

       56
       56
       -
           if stdenv.system == "x86_64-linux" then

     

       56
       56
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       57
       57
        
             fetchurl {

     

       58
       58
        
               url = "https://repo.skype.com/deb/pool/main/s/skypeforlinux/skypeforlinux_${version}_amd64.deb";

     

       59
       59
        
               sha256 = "1kydf71qbz35dx4674h3nxfx8a88k620217906i54ic4qq2mgy2x";

     

       60
       60
        
             }

     

       61
       61
        
           else

     

       62
       62
       -
             throw "Skype for linux is not supported on ${stdenv.system}";

     

       62
       62
       +
             throw "Skype for linux is not supported on ${stdenv.hostPlatform.system}";

     

       63
       63
        
       

     

       64
       64
        
       in stdenv.mkDerivation {

     

       65
       65
        
         name = "skypeforlinux-${version}";

+2 -2

pkgs/applications/networking/instant-messengers/slack/default.nix

···

       44
       44
        
         ] + ":${stdenv.cc.cc.lib}/lib64";

     

       45
       45
        
       

     

       46
       46
        
         src =

     

       47
       47
       -
           if stdenv.system == "x86_64-linux" then

     

       47
       47
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       48
       48
        
             fetchurl {

     

       49
       49
        
               url = "https://downloads.slack-edge.com/linux_releases/slack-desktop-${version}-amd64.deb";

     

       50
       50
        
               sha256 = "095dpkwvvnwlxsglyg6wi9126wpalzi736b6g6j3bd6d93z9afah";

     

       51
       51
        
             }

     

       52
       52
        
           else

     

       53
       53
       -
             throw "Slack is not supported on ${stdenv.system}";

     

       53
       53
       +
             throw "Slack is not supported on ${stdenv.hostPlatform.system}";

     

       54
       54
        
       

     

       55
       55
        
       in stdenv.mkDerivation {

     

       56
       56
        
         name = "slack-${version}";

+2 -2

pkgs/applications/networking/instant-messengers/wire-desktop/default.nix

···

       44
       44
        
         plat = {

     

       45
       45
        
           "i686-linux" = "i386";

     

       46
       46
        
           "x86_64-linux" = "amd64";

     

       47
       47
       -
         }.${stdenv.system};

     

       47
       47
       +
         }.${stdenv.hostPlatform.system};

     

       48
       48
        
       

     

       49
       49
        
         sha256 = {

     

       50
       50
        
           "i686-linux" = "071ddh2d8wmiybwafwyb97962zj358l0fq7g2r44231653sgybvq";

     

       51
       51
        
           "x86_64-linux" = "0qp9ms94smnm7k47b0n0jdzvnm1b7gj25hyinsfc6lghrb6jqw3r";

     

       52
       52
       -
         }.${stdenv.system};

     

       52
       52
       +
         }.${stdenv.hostPlatform.system};

     

       53
       53
        
       

     

       54
       54
        
       in

     

       55
       55
        
         stdenv.mkDerivation rec {

+2 -2

pkgs/applications/networking/instant-messengers/zoom-us/default.nix

···

       1
       1
       -
       { stdenv, fetchurl, system, makeWrapper, makeDesktopItem, autoPatchelfHook, env

     

       1
       1
       +
       { stdenv, fetchurl, makeWrapper, makeDesktopItem, autoPatchelfHook, env

     

       2
       2
        
       # Dynamic libraries

     

       3
       3
        
       , dbus, glib, libGL, libX11, libXfixes, libuuid, libxcb, qtbase, qtdeclarative

     

       4
       4
        
       , qtimageformats, qtlocation, qtquickcontrols, qtquickcontrols2, qtscript, qtsvg

     
···

       31
       31
        
       in stdenv.mkDerivation {

     

       32
       32
        
         name = "zoom-us-${version}";

     

       33
       33
        
       

     

       34
       34
       -
         src = srcs.${system};

     

       34
       34
       +
         src = srcs.${stdenv.hostPlatform.system};

     

       35
       35
        
       

     

       36
       36
        
         nativeBuildInputs = [ autoPatchelfHook makeWrapper ];

     

       37
       37

+2 -2

pkgs/applications/networking/insync/default.nix

···

       4
       4
        
         name = "insync-${version}";

     

       5
       5
        
         version = "1.4.5.37069";

     

       6
       6
        
         src =

     

       7
       7
       -
           if stdenv.system == "x86_64-linux" then

     

       7
       7
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       8
       8
        
             fetchurl {

     

       9
       9
        
               url = "http://s.insynchq.com/builds/insync-portable_${version}_amd64.tar.bz2";

     

       10
       10
        
               sha256 = "0mkqgpq4isngkj20c0ygmxf4cj975d446svhwvl3cqdrjkjm1ybd";

     

       11
       11
        
             }

     

       12
       12
        
           else

     

       13
       13
       -
             throw "${name} is not supported on ${stdenv.system}";

     

       13
       13
       +
             throw "${name} is not supported on ${stdenv.hostPlatform.system}";

     

       14
       14
        
       

     

       15
       15
        
         buildInputs = [ makeWrapper ];

     

       16
       16

+2 -2

pkgs/applications/networking/mailreaders/nylas-mail-bin/default.nix

···

       33
       33
        
         subVersion = "fec7941";

     

       34
       34
        
       

     

       35
       35
        
         src =

     

       36
       36
       -
           if stdenv.system == "x86_64-linux" then

     

       36
       36
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       37
       37
        
             fetchurl {

     

       38
       38
        
               url = "https://edgehill.s3.amazonaws.com/${version}-${subVersion}/linux-deb/x64/NylasMail.deb";

     

       39
       39
        
               sha256 = "40060aa1dc3b5187b8ed4a07b9de3427e3c5a291df98c2c82395647fa2aa4ada";

     

       40
       40
        
             }

     

       41
       41
        
           else

     

       42
       42
       -
             throw "NylasMail is not supported on ${stdenv.system}";

     

       42
       42
       +
             throw "NylasMail is not supported on ${stdenv.hostPlatform.system}";

     

       43
       43
        
       

     

       44
       44
        
         propagatedBuildInputs = [

     

       45
       45
        
           alsaLib

+1 -1

pkgs/applications/networking/mailreaders/thunderbird-bin/default.nix

···

       47
       47
        
       with (import ./release_sources.nix);

     

       48
       48
        
       

     

       49
       49
        
       let

     

       50
       50
       -
         arch = if stdenv.system == "i686-linux"

     

       50
       50
       +
         arch = if stdenv.hostPlatform.system == "i686-linux"

     

       51
       51
        
           then "linux-i686"

     

       52
       52
        
           else "linux-x86_64";

     

       53
       53

+1 -1

pkgs/applications/networking/p2p/frostwire/default.nix

···

       75
       75
        
           cp ${ { x86_64-darwin = "desktop/lib/native/*.dylib";

     

       76
       76
        
                   x86_64-linux  = "desktop/lib/native/lib{jlibtorrent,SystemUtilities}.so";

     

       77
       77
        
                   i686-linux    = "desktop/lib/native/lib{jlibtorrent,SystemUtilities}X86.so";

     

       78
       78
       -
                 }.${stdenv.system} or (throw "unsupported system ${stdenv.system}")

     

       78
       78
       +
                 }.${stdenv.hostPlatform.system} or (throw "unsupported system ${stdenv.hostPlatform.system}")

     

       79
       79
        
               } $out/lib

     

       80
       80
        
       

     

       81
       81
        
           cp -dpR ${desktopItem}/share $out

+1 -1

pkgs/applications/networking/p2p/soulseekqt/default.nix

···

       37
       37
        
       

     

       38
       38
        
         name = "soulseekqt-${version}";

     

       39
       39
        
         inherit version;

     

       40
       40
       -
         src = srcs."${stdenv.system}" or (throw "unsupported system: ${stdenv.system}");

     

       40
       40
       +
         src = srcs."${stdenv.hostPlatform.system}" or (throw "unsupported system: ${stdenv.hostPlatform.system}");

     

       41
       41
        
       

     

       42
       42
        
         dontBuild = true;

     

       43
       43

+2 -2

pkgs/applications/networking/remote/anydesk/default.nix

···

       6
       6
        
         sha256 = {

     

       7
       7
        
           "x86_64-linux" = "0g19sac4j3m1nf400vn6qcww7prqg2p4k4zsj74i109kk1396aa2";

     

       8
       8
        
           "i686-linux"   = "1dd4ai2pclav9g872xil3x67bxy32gvz9pb3w76383pcsdh5zh45";

     

       9
       9
       -
         }."${stdenv.system}" or (throw "system ${stdenv.system} not supported");

     

       9
       9
       +
         }."${stdenv.hostPlatform.system}" or (throw "system ${stdenv.hostPlatform.system} not supported");

     

       10
       10
        
       

     

       11
       11
        
         arch = {

     

       12
       12
        
           "x86_64-linux" = "amd64";

     

       13
       13
        
           "i686-linux"   = "i686";

     

       14
       14
       -
         }."${stdenv.system}" or (throw "system ${stdenv.system} not supported");

     

       14
       14
       +
         }."${stdenv.hostPlatform.system}" or (throw "system ${stdenv.hostPlatform.system} not supported");

     

       15
       15
        
       

     

       16
       16
        
         description = "Desktop sharing application, providing remote support and online meetings";

     

       17
       17

+2 -2

pkgs/applications/networking/resilio-sync/default.nix

···

       4
       4
        
         arch = {

     

       5
       5
        
           "x86_64-linux" = "x64";

     

       6
       6
        
           "i686-linux" = "i386";

     

       7
       7
       -
         }.${stdenv.system} or (throw "Unsupported system: ${stdenv.system}");

     

       7
       7
       +
         }.${stdenv.hostPlatform.system} or (throw "Unsupported system: ${stdenv.hostPlatform.system}");

     

       8
       8
        
         libPath = stdenv.lib.makeLibraryPath [ stdenv.cc.libc ];

     

       9
       9
        
       

     

       10
       10
        
       in stdenv.mkDerivation rec {

     
···

       16
       16
        
           sha256 = {

     

       17
       17
        
             "x86_64-linux" = "0041axi9carspkfaxvyirfvsa29zz55al01x90nh93nzxvpvywsz";

     

       18
       18
        
             "i686-linux"   = "1ar36lp4f6a1z9i82g3gpak4q4ny09faqxdd59q1pvfzq25ypdhs";

     

       19
       19
       -
           }.${stdenv.system};

     

       19
       19
       +
           }.${stdenv.hostPlatform.system};

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         dontStrip = true; # Don't strip, otherwise patching the rpaths breaks

+9 -9

pkgs/applications/networking/spideroak/default.nix

···

       4
       4
        
       }:

     

       5
       5
        
       

     

       6
       6
        
       let

     

       7
       7
       -
         arch = if stdenv.system == "x86_64-linux" then "x64"

     

       8
       8
       -
           else if stdenv.system == "i686-linux" then "x86"

     

       9
       9
       -
           else throw "Spideroak client for: ${stdenv.system} not supported!";

     

       7
       7
       +
         arch = if stdenv.hostPlatform.system == "x86_64-linux" then "x64"

     

       8
       8
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "x86"

     

       9
       9
       +
           else throw "Spideroak client for: ${stdenv.hostPlatform.system} not supported!";

     

       10
       10
        
       

     

       11
       11
       -
         interpreter = if stdenv.system == "x86_64-linux" then "ld-linux-x86-64.so.2"

     

       12
       12
       -
           else if stdenv.system == "i686-linux" then "ld-linux.so.2"

     

       13
       13
       -
           else throw "Spideroak client for: ${stdenv.system} not supported!";

     

       11
       11
       +
         interpreter = if stdenv.hostPlatform.system == "x86_64-linux" then "ld-linux-x86-64.so.2"

     

       12
       12
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "ld-linux.so.2"

     

       13
       13
       +
           else throw "Spideroak client for: ${stdenv.hostPlatform.system} not supported!";

     

       14
       14
        
       

     

       15
       15
       -
         sha256 = if stdenv.system == "x86_64-linux" then "a88e5a8fe4a565ac500668bd53cf5784752d7c9253304ddce39ee7b01d078533"

     

       16
       16
       -
           else if stdenv.system == "i686-linux" then "668f3b83a974a3877d16c8743c233a427ea0a44ab84b7f9aec19a2995db66c16"

     

       17
       17
       -
           else throw "Spideroak client for: ${stdenv.system} not supported!";

     

       15
       15
       +
         sha256 = if stdenv.hostPlatform.system == "x86_64-linux" then "a88e5a8fe4a565ac500668bd53cf5784752d7c9253304ddce39ee7b01d078533"

     

       16
       16
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "668f3b83a974a3877d16c8743c233a427ea0a44ab84b7f9aec19a2995db66c16"

     

       17
       17
       +
           else throw "Spideroak client for: ${stdenv.hostPlatform.system} not supported!";

     

       18
       18
        
       

     

       19
       19
        
         ldpath = stdenv.lib.makeLibraryPath [

     

       20
       20
        
           fontconfig freetype glib libICE libSM

+2 -2

pkgs/applications/networking/super-productivity/default.nix

···

       44
       44
        
         ] + ":${stdenv.cc.cc.lib}/lib64";

     

       45
       45
        
       

     

       46
       46
        
         src =

     

       47
       47
       -
           if stdenv.system == "x86_64-linux" then

     

       47
       47
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       48
       48
        
             fetchurl {

     

       49
       49
        
               url = "https://github.com/johannesjo/super-productivity/releases/download/v${version}/superProductivity_${version}_amd64.deb";

     

       50
       50
        
               sha256 = "0jfi0lfijnhij9jvkhxgyvq8m1jzaym8n1c7707fv3hjh1h0vxn1";

     

       51
       51
        
             }

     

       52
       52
        
           else

     

       53
       53
       -
             throw "super-productivity is not supported on ${stdenv.system}";

     

       53
       53
       +
             throw "super-productivity is not supported on ${stdenv.hostPlatform.system}";

     

       54
       54
        
       

     

       55
       55
        
       in stdenv.mkDerivation {

     

       56
       56
        
         name = "super-productivity-${version}";

+4 -4

pkgs/applications/office/jameica/default.nix

···

       6
       6
        
         version = "${_version}-${_build}";

     

       7
       7
        
         name = "jameica-${version}";

     

       8
       8
        
       

     

       9
       9
       -
         swtSystem = if stdenv.system == "i686-linux" then "linux"

     

       10
       10
       -
         else if stdenv.system == "x86_64-linux" then "linux64"

     

       11
       11
       -
         else if stdenv.system == "x86_64-darwin" then "macos64"

     

       12
       12
       -
         else throw "Unsupported system: ${stdenv.system}";

     

       9
       9
       +
         swtSystem = if stdenv.hostPlatform.system == "i686-linux" then "linux"

     

       10
       10
       +
         else if stdenv.hostPlatform.system == "x86_64-linux" then "linux64"

     

       11
       11
       +
         else if stdenv.hostPlatform.system == "x86_64-darwin" then "macos64"

     

       12
       12
       +
         else throw "Unsupported system: ${stdenv.hostPlatform.system}";

     

       13
       13
        
       

     

       14
       14
        
         desktopItem = makeDesktopItem {

     

       15
       15
        
           name = "jameica";

+2 -2

pkgs/applications/office/mendeley/default.nix

···

       37
       37
        
       let

     

       38
       38
        
         arch32 = "i686-linux";

     

       39
       39
        
       

     

       40
       40
       -
         arch = if stdenv.system == arch32

     

       40
       40
       +
         arch = if stdenv.hostPlatform.system == arch32

     

       41
       41
        
           then "i386"

     

       42
       42
        
           else "amd64";

     

       43
       43
        
       

     
···

       46
       46
        
         version = "${shortVersion}_${arch}";

     

       47
       47
        
       

     

       48
       48
        
         url = "http://desktop-download.mendeley.com/download/apt/pool/main/m/mendeleydesktop/mendeleydesktop_${version}.deb";

     

       49
       49
       -
         sha256 = if stdenv.system == arch32

     

       49
       49
       +
         sha256 = if stdenv.hostPlatform.system == arch32

     

       50
       50
        
           then "0fcyl5i8xdgb5j0x1643qc0j74d8p11jczvqmgqkqh0wgid1y1ad"

     

       51
       51
        
           else "1dzwa2cnn9xakrhhq159fhh71gw5wlbf017rrikdlia694m8akq6";

     

       52
       52

+2 -2

pkgs/applications/office/moneyplex/default.nix

···

       21
       21
        
         name = "moneyplex-${version}";

     

       22
       22
        
         version = "16.0.22424";

     

       23
       23
        
       

     

       24
       24
       -
         src = fetchurl (if stdenv.system == "i686-linux" then src_i686

     

       25
       25
       -
                         else if stdenv.system == "x86_64-linux" then src_x86_64

     

       24
       24
       +
         src = fetchurl (if stdenv.hostPlatform.system == "i686-linux" then src_i686

     

       25
       25
       +
                         else if stdenv.hostPlatform.system == "x86_64-linux" then src_x86_64

     

       26
       26
        
                         else throw "moneyplex requires i686-linux or x86_64-linux");

     

       27
       27
        
       

     

       28
       28

+1 -1

pkgs/applications/office/wpsoffice/default.nix

···

       3
       3
        
       , zlib, libpng12, libICE, libXrender, cups }:

     

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
       -
         bits = if stdenv.system == "x86_64-linux" then "x86_64"

     

       6
       6
       +
         bits = if stdenv.hostPlatform.system == "x86_64-linux" then "x86_64"

     

       7
       7
        
                else "x86";

     

       8
       8
        
       

     

       9
       9
        
         version = "10.1.0.5672";

+3 -3

pkgs/applications/science/electronics/eagle/eagle7.nix

···

       17
       17
        
         version = "7.7.0";

     

       18
       18
        
       

     

       19
       19
        
         src =

     

       20
       20
       -
           if stdenv.system == "i686-linux" then

     

       20
       20
       +
           if stdenv.hostPlatform.system == "i686-linux" then

     

       21
       21
        
             fetchurl {

     

       22
       22
        
               url = "ftp://ftp.cadsoft.de/eagle/program/7.7/eagle-lin32-${version}.run";

     

       23
       23
        
               sha256 = "16fa66p77xigc7zvzfm7737mllrcs6nrgk2p7wvkjw3p9lvbz7z1";

     

       24
       24
        
             }

     

       25
       25
       -
           else if stdenv.system == "x86_64-linux" then

     

       25
       25
       +
           else if stdenv.hostPlatform.system == "x86_64-linux" then

     

       26
       26
        
             fetchurl {

     

       27
       27
        
               url = "ftp://ftp.cadsoft.de/eagle/program/7.7/eagle-lin64-${version}.run";

     

       28
       28
        
               sha256 = "18dcn6wqph1sqh0ah98qzfi05wip8a8ifbkaq79iskbrsi8iqnrg";

     

       29
       29
        
             }

     

       30
       30
        
           else

     

       31
       31
       -
             throw "Unsupported system: ${stdenv.system}";

     

       31
       31
       +
             throw "Unsupported system: ${stdenv.hostPlatform.system}";

     

       32
       32
        
       

     

       33
       33
        
         desktopItem = makeDesktopItem {

     

       34
       34
        
           name = "eagle";

+1 -1

pkgs/applications/science/logic/isabelle/default.nix

···

       48
       48
        
             rm -rf $comp/x86*

     

       49
       49
        
           done

     

       50
       50
        
           '' + (if ! stdenv.isLinux then "" else ''

     

       51
       51
       -
           arch=${if stdenv.system == "x86_64-linux" then "x86_64-linux" else "x86-linux"}

     

       51
       51
       +
           arch=${if stdenv.hostPlatform.system == "x86_64-linux" then "x86_64-linux" else "x86-linux"}

     

       52
       52
        
           for f in contrib/*/$arch/{bash_process,epclextract,eprover,nunchaku,SPASS}; do

     

       53
       53
        
             patchelf --set-interpreter $(cat ${stdenv.cc}/nix-support/dynamic-linker) "$f"

     

       54
       54
        
           done

+1 -1

pkgs/applications/science/logic/saw-tools/default.nix

···

       12
       12
        
         url = "https://github.com/GaloisInc/saw-script/releases/download";

     

       13
       13
        
       

     

       14
       14
        
         saw-bin =

     

       15
       15
       -
           if stdenv.system == "i686-linux"

     

       15
       15
       +
           if stdenv.hostPlatform.system == "i686-linux"

     

       16
       16
        
           then fetchurl {

     

       17
       17
        
             url    = url + "/v0.1.1-dev/saw-0.1.1-dev-2015-07-31-CentOS6-32.tar.gz";

     

       18
       18
        
             sha256 = "126iag5nnvndi78c921z7vjrjfwcspn1hlxwwhzmqm4rvbhhr9v9";

+2 -2

pkgs/applications/science/math/mathematica/10.nix

···

       18
       18
        
       

     

       19
       19
        
       let

     

       20
       20
        
         platform =

     

       21
       21
       -
           if stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux" then

     

       21
       21
       +
           if stdenv.hostPlatform.system == "i686-linux" || stdenv.hostPlatform.system == "x86_64-linux" then

     

       22
       22
        
             "Linux"

     

       23
       23
        
           else

     

       24
       24
        
             throw "Mathematica requires i686-linux or x86_64 linux";

     
···

       70
       70
        
         ]);

     

       71
       71
        
       

     

       72
       72
        
         ldpath = stdenv.lib.makeLibraryPath buildInputs

     

       73
       73
       -
           + stdenv.lib.optionalString (stdenv.system == "x86_64-linux")

     

       73
       73
       +
           + stdenv.lib.optionalString (stdenv.hostPlatform.system == "x86_64-linux")

     

       74
       74
        
             (":" + stdenv.lib.makeSearchPathOutput "lib" "lib64" buildInputs);

     

       75
       75
        
       

     

       76
       76
        
         phases = "unpackPhase installPhase fixupPhase";

+2 -2

pkgs/applications/science/math/mathematica/9.nix

···

       16
       16
        
       

     

       17
       17
        
       let

     

       18
       18
        
         platform =

     

       19
       19
       -
           if stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux" then

     

       19
       19
       +
           if stdenv.hostPlatform.system == "i686-linux" || stdenv.hostPlatform.system == "x86_64-linux" then

     

       20
       20
        
             "Linux"

     

       21
       21
        
           else

     

       22
       22
        
             throw "Mathematica requires i686-linux or x86_64 linux";

     
···

       60
       60
        
         ]);

     

       61
       61
        
       

     

       62
       62
        
         ldpath = stdenv.lib.makeLibraryPath buildInputs

     

       63
       63
       -
           + stdenv.lib.optionalString (stdenv.system == "x86_64-linux")

     

       63
       63
       +
           + stdenv.lib.optionalString (stdenv.hostPlatform.system == "x86_64-linux")

     

       64
       64
        
             (":" + stdenv.lib.makeSearchPathOutput "lib" "lib64" buildInputs);

     

       65
       65
        
       

     

       66
       66
        
         phases = "unpackPhase installPhase fixupPhase";

+1 -1

pkgs/applications/science/math/mathematica/default.nix

···

       69
       69
        
         ]);

     

       70
       70
        
       

     

       71
       71
        
         ldpath = stdenv.lib.makeLibraryPath buildInputs

     

       72
       72
       -
           + stdenv.lib.optionalString (stdenv.system == "x86_64-linux")

     

       72
       72
       +
           + stdenv.lib.optionalString (stdenv.hostPlatform.system == "x86_64-linux")

     

       73
       73
        
             (":" + stdenv.lib.makeSearchPathOutput "lib" "lib64" buildInputs);

     

       74
       74
        
       

     

       75
       75
        
         phases = "unpackPhase installPhase fixupPhase";

+4 -4

pkgs/applications/science/math/scilab-bin/default.nix

···

       10
       10
        
         badArch = throw "${name} requires i686-linux or x86_64-linux";

     

       11
       11
        
       

     

       12
       12
        
         architecture =

     

       13
       13
       -
           if stdenv.system == "i686-linux" then

     

       13
       13
       +
           if stdenv.hostPlatform.system == "i686-linux" then

     

       14
       14
        
             "i686"

     

       15
       15
       -
           else if stdenv.system == "x86_64-linux" then

     

       15
       15
       +
           else if stdenv.hostPlatform.system == "x86_64-linux" then

     

       16
       16
        
             "x86_64"

     

       17
       17
        
           else

     

       18
       18
        
             badArch;

     
···

       23
       23
        
         src = fetchurl {

     

       24
       24
        
           url = "https://www.scilab.org/download/${ver}/scilab-${ver}.bin.linux-${architecture}.tar.gz";

     

       25
       25
        
           sha256 =

     

       26
       26
       -
             if stdenv.system == "i686-linux" then

     

       26
       26
       +
             if stdenv.hostPlatform.system == "i686-linux" then

     

       27
       27
        
               "0fgjc2ak3b2qi6yin3fy50qwk2bcj0zbz1h4lyyic9n1n1qcliib"

     

       28
       28
       -
             else if stdenv.system == "x86_64-linux" then

     

       28
       28
       +
             else if stdenv.hostPlatform.system == "x86_64-linux" then

     

       29
       29
        
               "1scswlznc14vyzg0gqa1q9gcpwx05kz1sbn563463mzkdp7nd35d"

     

       30
       30
        
             else

     

       31
       31
        
               badArch;

+1 -1

pkgs/applications/search/recoll/default.nix

···

       5
       5
        
       , ghostscript, gawk, gnugrep, gnused, gnutar, gzip, libiconv, zlib

     

       6
       6
        
       , withGui ? true }:

     

       7
       7
        
       

     

       8
       8
       -
       assert stdenv.system != "powerpc-linux";

     

       8
       8
       +
       assert stdenv.hostPlatform.system != "powerpc-linux";

     

       9
       9
        
       

     

       10
       10
        
       stdenv.mkDerivation rec {

     

       11
       11
        
         ver = "1.23.7";

+2 -2

pkgs/applications/video/lightworks/default.nix

···

       23
       23
        
           name = "lightworks-${version}";

     

       24
       24
        
           

     

       25
       25
        
           src =

     

       26
       26
       -
             if stdenv.system == "x86_64-linux" then

     

       26
       26
       +
             if stdenv.hostPlatform.system == "x86_64-linux" then

     

       27
       27
        
               fetchurl {

     

       28
       28
        
                 url = "http://downloads.lwks.com/v14/lwks-14.0.0-amd64.deb";

     

       29
       29
        
                 sha256 = "66eb9f9678d979db76199f1c99a71df0ddc017bb47dfda976b508849ab305033";

     

       30
       30
        
               }

     

       31
       31
       -
             else throw "${name} is not supported on ${stdenv.system}";

     

       31
       31
       +
             else throw "${name} is not supported on ${stdenv.hostPlatform.system}";

     

       32
       32
        
       

     

       33
       33
        
           buildInputs = [ dpkg makeWrapper ];

     

       34
       34

+3 -3

pkgs/applications/video/mplayer/default.nix

···

       60
       60
        
           let

     

       61
       61
        
             dir = http://www.mplayerhq.hu/MPlayer/releases/codecs/;

     

       62
       62
        
           in

     

       63
       63
       -
           if stdenv.system == "i686-linux" then fetchurl {

     

       63
       63
       +
           if stdenv.hostPlatform.system == "i686-linux" then fetchurl {

     

       64
       64
        
             url = "${dir}/essential-20071007.tar.bz2";

     

       65
       65
        
             sha256 = "18vls12n12rjw0mzw4pkp9vpcfmd1c21rzha19d7zil4hn7fs2ic";

     

       66
       66
       -
           } else if stdenv.system == "x86_64-linux" then fetchurl {

     

       66
       66
       +
           } else if stdenv.hostPlatform.system == "x86_64-linux" then fetchurl {

     

       67
       67
        
             url = "${dir}/essential-amd64-20071007.tar.bz2";

     

       68
       68
        
             sha256 = "13xf5b92w1ra5hw00ck151lypbmnylrnznq9hhb0sj36z5wz290x";

     

       69
       69
       -
           } else if stdenv.system == "powerpc-linux" then fetchurl {

     

       69
       69
       +
           } else if stdenv.hostPlatform.system == "powerpc-linux" then fetchurl {

     

       70
       70
        
             url = "${dir}/essential-ppc-20071007.tar.bz2";

     

       71
       71
        
             sha256 = "18mlj8dp4wnz42xbhdk1jlz2ygra6fbln9wyrcyvynxh96g1871z";

     

       72
       72
        
           } else null;

+2 -2

pkgs/applications/video/webtorrent_desktop/default.nix

···

       42
       42
        
           version = "0.20.0";

     

       43
       43
        
       

     

       44
       44
        
           src =

     

       45
       45
       -
             if stdenv.system == "x86_64-linux" then

     

       45
       45
       +
             if stdenv.hostPlatform.system == "x86_64-linux" then

     

       46
       46
        
               fetchurl {

     

       47
       47
        
                 url = "https://github.com/webtorrent/webtorrent-desktop/releases/download/v0.20.0/webtorrent-desktop_${version}-1_amd64.deb";

     

       48
       48
        
                 sha256 = "1kkrnbimiip5pn2nwpln35bbdda9gc3cgrjwphq4fqasbjf2781k";

     

       49
       49
        
               }

     

       50
       50
        
               else

     

       51
       51
       -
                 throw "Webtorrent is not currently supported on ${stdenv.system}";

     

       51
       51
       +
                 throw "Webtorrent is not currently supported on ${stdenv.hostPlatform.system}";

     

       52
       52
        
           phases = [ "unpackPhase" "installPhase" ];

     

       53
       53
        
           nativeBuildInputs = [ dpkg ];

     

       54
       54
        
           unpackPhase = "dpkg-deb -x $src .";

+1 -1

pkgs/applications/virtualization/qemu/default.nix

···

       22
       22
        
       

     

       23
       23
        
       with stdenv.lib;

     

       24
       24
        
       let

     

       25
       25
       -
         audio = optionalString (hasSuffix "linux" stdenv.system) "alsa,"

     

       25
       25
       +
         audio = optionalString (hasSuffix "linux" stdenv.hostPlatform.system) "alsa,"

     

       26
       26
        
           + optionalString pulseSupport "pa,"

     

       27
       27
        
           + optionalString sdlSupport "sdl,";

     

       28
       28

+8 -8

pkgs/applications/virtualization/virtualbox/guest-additions/default.nix

···

       44
       44
        
         '';

     

       45
       45
        
       

     

       46
       46
        
         buildCommand = with xorg; ''

     

       47
       47
       -
           ${if stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux" then ''

     

       47
       47
       +
           ${if stdenv.hostPlatform.system == "i686-linux" || stdenv.hostPlatform.system == "x86_64-linux" then ''

     

       48
       48
        
               isoinfo -J -i $src -x /VBoxLinuxAdditions.run > ./VBoxLinuxAdditions.run

     

       49
       49
        
               chmod 755 ./VBoxLinuxAdditions.run

     

       50
       50
        
               ./VBoxLinuxAdditions.run --noexec --keep

     

       51
       51
        
             ''

     

       52
       52
       -
             else throw ("Architecture: "+stdenv.system+" not supported for VirtualBox guest additions")

     

       52
       52
       +
             else throw ("Architecture: "+stdenv.hostPlatform.system+" not supported for VirtualBox guest additions")

     

       53
       53
        
           }

     

       54
       54
        
       

     

       55
       55
        
           # Unpack files

     

       56
       56
        
           cd install

     

       57
       57
       -
           ${if stdenv.system == "i686-linux" then ''

     

       57
       57
       +
           ${if stdenv.hostPlatform.system == "i686-linux" then ''

     

       58
       58
        
               tar xfvj VBoxGuestAdditions-x86.tar.bz2

     

       59
       59
        
             ''

     

       60
       60
       -
             else if stdenv.system == "x86_64-linux" then ''

     

       60
       60
       +
             else if stdenv.hostPlatform.system == "x86_64-linux" then ''

     

       61
       61
        
               tar xfvj VBoxGuestAdditions-amd64.tar.bz2

     

       62
       62
        
             ''

     

       63
       63
       -
             else throw ("Architecture: "+stdenv.system+" not supported for VirtualBox guest additions")

     

       63
       63
       +
             else throw ("Architecture: "+stdenv.hostPlatform.system+" not supported for VirtualBox guest additions")

     

       64
       64
        
           }

     

       65
       65
        
       

     

       66
       66
        
           cd ../

     
···

       81
       81
        
           # Change the interpreter for various binaries

     

       82
       82
        
           for i in sbin/VBoxService bin/{VBoxClient,VBoxControl} other/mount.vboxsf

     

       83
       83
        
           do

     

       84
       84
       -
               ${if stdenv.system == "i686-linux" then ''

     

       84
       84
       +
               ${if stdenv.hostPlatform.system == "i686-linux" then ''

     

       85
       85
        
                 patchelf --set-interpreter ${stdenv.glibc.out}/lib/ld-linux.so.2 $i

     

       86
       86
        
               ''

     

       87
       87
       -
               else if stdenv.system == "x86_64-linux" then ''

     

       87
       87
       +
               else if stdenv.hostPlatform.system == "x86_64-linux" then ''

     

       88
       88
        
                 patchelf --set-interpreter ${stdenv.glibc.out}/lib/ld-linux-x86-64.so.2 $i

     

       89
       89
        
               ''

     

       90
       90
       -
               else throw ("Architecture: "+stdenv.system+" not supported for VirtualBox guest additions")

     

       90
       90
       +
               else throw ("Architecture: "+stdenv.hostPlatform.system+" not supported for VirtualBox guest additions")

     

       91
       91
        
               }

     

       92
       92
        
               patchelf --set-rpath ${lib.makeLibraryPath [ stdenv.cc.cc dbus libX11 libXt libXext libXmu libXfixes libXrandr libXcursor ]} $i

     

       93
       93
        
           done

+2 -2

pkgs/applications/window-managers/i3/default.nix

···

       36
       36
        
         # they shouldn't, and then even once that's fixed have some

     

       37
       37
        
         # perl-related errors later on. For more, see

     

       38
       38
        
         # https://github.com/NixOS/nixpkgs/issues/7957

     

       39
       39
       -
         doCheck = false; # stdenv.system == "x86_64-linux";

     

       39
       39
       +
         doCheck = false; # stdenv.hostPlatform.system == "x86_64-linux";

     

       40
       40
        
       

     

       41
       41
       -
         checkPhase = stdenv.lib.optionalString (stdenv.system == "x86_64-linux")

     

       41
       41
       +
         checkPhase = stdenv.lib.optionalString (stdenv.hostPlatform.system == "x86_64-linux")

     

       42
       42
        
         ''

     

       43
       43
        
           (cd testcases && xvfb-run ./complete-run.pl -p 1 --keep-xserver-output)

     

       44
       44
        
           ! grep -q '^not ok' testcases/latest/complete-run.log

+2 -2

pkgs/build-support/build-fhs-userenv/env.nix

···

       1
       1
       -
       { stdenv, buildEnv, writeText, pkgs, pkgsi686Linux, system }:

     

       1
       1
       +
       { stdenv, buildEnv, writeText, pkgs, pkgsi686Linux }:

     

       2
       2
        
       

     

       3
       3
        
       { name, profile ? ""

     

       4
       4
        
       , targetPkgs ? pkgs: [], multiPkgs ? pkgs: []

     
···

       22
       22
        
       # /lib will link to /lib32

     

       23
       23
        
       

     

       24
       24
        
       let

     

       25
       25
       -
         is64Bit = system == "x86_64-linux";

     

       25
       25
       +
         is64Bit = stdenv.hostPlatform.parsed.cpu.bits == 64;

     

       26
       26
        
         isMultiBuild  = multiPkgs != null && is64Bit;

     

       27
       27
        
         isTargetBuild = !isMultiBuild;

     

       28
       28

+1 -1

pkgs/build-support/release/nix-build.nix

···

       148
       148
        
           postPhases = postPhases ++ ["finalPhase"];

     

       149
       149
        
       

     

       150
       150
        
           meta = (if args ? meta then args.meta else {}) // {

     

       151
       151
       -
             description = if doCoverageAnalysis then "Coverage analysis" else "Nix package for ${stdenv.system}";

     

       151
       151
       +
             description = if doCoverageAnalysis then "Coverage analysis" else "Nix package for ${stdenv.hostPlatform.system}";

     

       152
       152
        
           };

     

       153
       153
        
       

     

       154
       154
        
         }

+1 -1

pkgs/build-support/vm/windows/controller/default.nix

···

       157
       157
        
           "-net vde,vlan=0,sock=$QEMU_VDE_SOCKET"

     

       158
       158
        
         ]);

     

       159
       159
        
       

     

       160
       160
       -
         maybeKvm64 = optional (stdenv.system == "x86_64-linux") "-cpu kvm64";

     

       160
       160
       +
         maybeKvm64 = optional (stdenv.hostPlatform.system == "x86_64-linux") "-cpu kvm64";

     

       161
       161
        
       

     

       162
       162
        
         cygwinQemuArgs = concatStringsSep " " (maybeKvm64 ++ [

     

       163
       163
        
           "-monitor unix:$MONITOR_SOCKET,server,nowait"

+1 -1

pkgs/build-support/vm/windows/cygwin-iso/default.nix

···

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
         cygwinCross = (import ../../../../.. {

     

       20
       20
       -
           inherit (stdenv) system;

     

       20
       20
       +
           localSystem = stdenv.hostPlatform;

     

       21
       21
        
           crossSystem = {

     

       22
       22
        
             libc = "msvcrt";

     

       23
       23
        
             platform = {};

+11 -7

pkgs/development/arduino/arduino-core/default.nix

···

       13
       13
        
       # xdotool script; the cause of this hang is not yet known.

     

       14
       14
        
       # TODO: There is a fair chance that Teensyduino works with arm-linux, but it

     

       15
       15
        
       # has not yet been tested.

     

       16
       16
       -
       if withTeensyduino && (stdenv.system != "x86_64-linux") then throw

     

       16
       16
       +
       if withTeensyduino && (stdenv.hostPlatform.system != "x86_64-linux") then throw

     

       17
       17
        
         "Teensyduino is only supported on x86_64-linux at this time (patches welcome)."

     

       18
       18
        
       else

     

       19
       19
        
       let

     

       20
       20
       -
         externalDownloads = import ./downloads.nix {inherit fetchurl; inherit (lib) optionalAttrs; inherit (stdenv) system;};

     

       20
       20
       +
         externalDownloads = import ./downloads.nix {

     

       21
       21
       +
           inherit fetchurl;

     

       22
       22
       +
           inherit (lib) optionalAttrs;

     

       23
       23
       +
           inherit (stdenv.hostPlatform) system;

     

       24
       24
       +
         };

     

       21
       25
        
         # Some .so-files are later copied from .jar-s to $HOME, so patch them beforehand

     

       22
       26
        
         patchelfInJars =

     

       23
       23
       -
              lib.optional (stdenv.system == "x86_64-linux") {jar = "share/arduino/lib/jssc-2.8.0-arduino1.jar"; file = "libs/linux/libjSSC-2.8_x86_64.so";}

     

       24
       24
       -
           ++ lib.optional (stdenv.system == "i686-linux") {jar = "share/arduino/lib/jssc-2.8.0-arduino1.jar"; file = "libs/linux/libjSSC-2.8_x86.so";}

     

       27
       27
       +
              lib.optional (stdenv.hostPlatform.system == "x86_64-linux") {jar = "share/arduino/lib/jssc-2.8.0-arduino1.jar"; file = "libs/linux/libjSSC-2.8_x86_64.so";}

     

       28
       28
       +
           ++ lib.optional (stdenv.hostPlatform.system == "i686-linux") {jar = "share/arduino/lib/jssc-2.8.0-arduino1.jar"; file = "libs/linux/libjSSC-2.8_x86.so";}

     

       25
       29
        
         ;

     

       26
       30
        
         # abiVersion 6 is default, but we need 5 for `avrdude_bin` executable

     

       27
       31
        
         ncurses5 = ncurses.override { abiVersion = "5"; };

     
···

       46
       50
        
           zlib

     

       47
       51
        
         ];

     

       48
       52
        
         teensy_architecture =

     

       49
       49
       -
             lib.optionalString (stdenv.system == "x86_64-linux") "linux64"

     

       50
       50
       -
             + lib.optionalString (stdenv.system == "i686-linux") "linux32"

     

       51
       51
       -
             + lib.optionalString (stdenv.system == "arm-linux") "linuxarm";

     

       53
       53
       +
             lib.optionalString (stdenv.hostPlatform.system == "x86_64-linux") "linux64"

     

       54
       54
       +
             + lib.optionalString (stdenv.hostPlatform.system == "i686-linux") "linux32"

     

       55
       55
       +
             + lib.optionalString (stdenv.hostPlatform.system == "arm-linux") "linuxarm";

     

       52
       56
        
       

     

       53
       57
        
         flavor = (if withTeensyduino then "teensyduino" else "arduino")

     

       54
       58
        
                    + stdenv.lib.optionalString (!withGui) "-core";

+1 -1

pkgs/development/compilers/ccl/default.nix

···

       29
       29
        
           };

     

       30
       30
        
           armv6l-linux = armv7l-linux;

     

       31
       31
        
         };

     

       32
       32
       -
         cfg = options."${stdenv.system}" or (throw "missing source url for platform ${stdenv.system}");

     

       32
       32
       +
         cfg = options."${stdenv.hostPlatform.system}" or (throw "missing source url for platform ${stdenv.hostPlatform.system}");

     

       33
       33
        
       in

     

       34
       34
        
       

     

       35
       35
        
       stdenv.mkDerivation rec {

+2 -2

pkgs/development/compilers/clean/default.nix

···

       4
       4
        
         name = "clean-2.4";

     

       5
       5
        
       

     

       6
       6
        
         src =

     

       7
       7
       -
           if stdenv.system == "i686-linux" then (fetchurl {

     

       7
       7
       +
           if stdenv.hostPlatform.system == "i686-linux" then (fetchurl {

     

       8
       8
        
             url = "http://clean.cs.ru.nl/download/Clean24/linux/clean2.4_boot.tar.gz";

     

       9
       9
        
             sha256 = "1w8vvmkwzq8g51639r62apcy75sj69nm08082a34xvqm9ymfgkq5";

     

       10
       10
        
           })

     

       11
       11
       -
           else if stdenv.system == "x86_64-linux" then (fetchurl {

     

       11
       11
       +
           else if stdenv.hostPlatform.system == "x86_64-linux" then (fetchurl {

     

       12
       12
        
               url = "https://clean.cs.ru.nl/download/Clean24/linux/clean2.4_64_boot.tar.gz";

     

       13
       13
        
               sha256 = "08gsa1pjl5wyzh4ah8ccfx8a7mdcn6ycsn1lzkrr9adygv1gmm7r";

     

       14
       14
        
           })

+1 -1

pkgs/development/compilers/cmucl/binary.nix

···

       1
       1
        
       {stdenv, fetchurl}:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         inherit (stdenv) system;

     

       4
       4
       +
         inherit (stdenv.hostPlatform) system;

     

       5
       5
        
         version = "21b";

     

       6
       6
        
         downloadUrl = arch:

     

       7
       7
        
           "http://common-lisp.net/project/cmucl/downloads/release/" +

+2 -2

pkgs/development/compilers/crystal/default.nix

···

       15
       15
        
           "x86_64-linux" = "linux-x86_64";

     

       16
       16
        
           "i686-linux" = "linux-i686";

     

       17
       17
        
           "x86_64-darwin" = "darwin-x86_64";

     

       18
       18
       -
         }."${stdenv.system}" or (throw "system ${stdenv.system} not supported");

     

       18
       18
       +
         }."${stdenv.hostPlatform.system}" or (throw "system ${stdenv.hostPlatform.system} not supported");

     

       19
       19
        
         in fetchurl {

     

       20
       20
        
           url = "https://github.com/crystal-lang/crystal/releases/download/0.26.0/${prebuiltName}-${arch}.tar.gz";

     

       21
       21
        
           sha256 = {

     

       22
       22
        
             "x86_64-linux" = "1xban102yiiwmlklxvn3xp3q546bp8hlxxpakayajkhhnpl6yv45";

     

       23
       23
        
             "i686-linux" = "1igspf1lrv7wpmz0pfrkbx8m1ykvnv4zhic53cav4nicppm2v0ic";

     

       24
       24
        
             "x86_64-darwin" = "0hzc65ccajr0yhmvi5vbdgbzbp1gbjy56da24ds3zwwkam1ddk0k";

     

       25
       25
       -
           }."${stdenv.system}";

     

       25
       25
       +
           }."${stdenv.hostPlatform.system}";

     

       26
       26
        
         };

     

       27
       27
        
       

     

       28
       28
        
         unpackPhase = ''

+3 -3

pkgs/development/compilers/fpc/binary.nix

···

       4
       4
        
         name = "fpc-2.6.0-binary";

     

       5
       5
        
       

     

       6
       6
        
         src =

     

       7
       7
       -
           if stdenv.system == "i686-linux" then

     

       7
       7
       +
           if stdenv.hostPlatform.system == "i686-linux" then

     

       8
       8
        
             fetchurl {

     

       9
       9
        
               url = "mirror://sourceforge/project/freepascal/Linux/2.6.0/fpc-2.6.0.i386-linux.tar";

     

       10
       10
        
               sha256 = "08yklvrfxvk59bxsd4rh1i6s3cjn0q06dzjs94h9fbq3n1qd5zdf";

     

       11
       11
        
             }

     

       12
       12
       -
           else if stdenv.system == "x86_64-linux" then

     

       12
       12
       +
           else if stdenv.hostPlatform.system == "x86_64-linux" then

     

       13
       13
        
             fetchurl {

     

       14
       14
        
               url = "mirror://sourceforge/project/freepascal/Linux/2.6.0/fpc-2.6.0.x86_64-linux.tar";

     

       15
       15
        
               sha256 = "0k9vi75k39y735fng4jc2vppdywp82j4qhzn7x4r6qjkad64d8lx";

     

       16
       16
        
             }

     

       17
       17
       -
           else throw "Not supported on ${stdenv.system}.";

     

       17
       17
       +
           else throw "Not supported on ${stdenv.hostPlatform.system}.";

     

       18
       18
        
       

     

       19
       19
        
         builder = ./binary-builder.sh;

     

       20
       20

+1 -1

pkgs/development/compilers/fpc/default.nix

···

       14
       14
        
         buildInputs = [ startFPC gawk ];

     

       15
       15
        
       

     

       16
       16
        
         preConfigure =

     

       17
       17
       -
           if stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux" then ''

     

       17
       17
       +
           if stdenv.hostPlatform.system == "i686-linux" || stdenv.hostPlatform.system == "x86_64-linux" then ''

     

       18
       18
        
             sed -e "s@'/lib/ld-linux[^']*'@'''@" -i fpcsrc/compiler/systems/t_linux.pas

     

       19
       19
        
             sed -e "s@'/lib64/ld-linux[^']*'@'''@" -i fpcsrc/compiler/systems/t_linux.pas

     

       20
       20
        
           '' else "";

+1 -1

pkgs/development/compilers/ghcjs-ng/default.nix

···

       59
       59
        
         };

     

       60
       60
        
       

     

       61
       61
        
         bootGhcjs = haskellLib.justStaticExecutables passthru.bootPkgs.ghcjs;

     

       62
       62
       -
         libexec = "${bootGhcjs}/libexec/${builtins.replaceStrings ["darwin" "i686"] ["osx" "i386"] stdenv.system}-${passthru.bootPkgs.ghc.name}/${bootGhcjs.name}";

     

       62
       62
       +
         libexec = "${bootGhcjs}/libexec/${builtins.replaceStrings ["darwin" "i686"] ["osx" "i386"] stdenv.buildPlatform.system}-${passthru.bootPkgs.ghc.name}/${bootGhcjs.name}";

     

       63
       63
        
       

     

       64
       64
        
       in stdenv.mkDerivation {

     

       65
       65
        
           name = bootGhcjs.name;

+3 -3

pkgs/development/compilers/go/1.10.nix

···

       134
       134
        
       

     

       135
       135
        
         GOOS = if stdenv.isDarwin then "darwin" else "linux";

     

       136
       136
        
         GOARCH = if stdenv.isDarwin then "amd64"

     

       137
       137
       -
                  else if stdenv.system == "i686-linux" then "386"

     

       138
       138
       -
                  else if stdenv.system == "x86_64-linux" then "amd64"

     

       137
       137
       +
                  else if stdenv.hostPlatform.system == "i686-linux" then "386"

     

       138
       138
       +
                  else if stdenv.hostPlatform.system == "x86_64-linux" then "amd64"

     

       139
       139
        
                  else if stdenv.isAarch32 then "arm"

     

       140
       140
        
                  else if stdenv.isAarch64 then "arm64"

     

       141
       141
        
                  else throw "Unsupported system";

     

       142
       142
       -
         GOARM = optionalString (stdenv.system == "armv5tel-linux") "5";

     

       142
       142
       +
         GOARM = optionalString (stdenv.hostPlatform.system == "armv5tel-linux") "5";

     

       143
       143
        
         GO386 = 387; # from Arch: don't assume sse2 on i686

     

       144
       144
        
         CGO_ENABLED = 1;

     

       145
       145
        
         GOROOT_BOOTSTRAP = "${goBootstrap}/share/go";

+5 -5

pkgs/development/compilers/go/1.11.nix

···

       134
       134
        
       

     

       135
       135
        
         GOOS = if stdenv.isDarwin then "darwin" else "linux";

     

       136
       136
        
         GOARCH = if stdenv.isDarwin then "amd64"

     

       137
       137
       -
                  else if stdenv.system == "i686-linux" then "386"

     

       138
       138
       -
                  else if stdenv.system == "x86_64-linux" then "amd64"

     

       139
       139
       -
                  else if stdenv.isAarch32 then "arm"

     

       140
       140
       -
                  else if stdenv.isAarch64 then "arm64"

     

       137
       137
       +
                  else if stdenv.targetPlatform.isi686 then "386"

     

       138
       138
       +
                  else if stdenv.targetPlatform.isx86_64 then "amd64"

     

       139
       139
       +
                  else if stdenv.targetPlatform.isAarch32 then "arm"

     

       140
       140
       +
                  else if stdenv.targetPlatform.isAarch64 then "arm64"

     

       141
       141
        
                  else throw "Unsupported system";

     

       142
       142
       -
         GOARM = optionalString (stdenv.system == "armv5tel-linux") "5";

     

       142
       142
       +
         GOARM = stdenv.targetPlatform.parsed.cpu.version or "";

     

       143
       143
        
         GO386 = 387; # from Arch: don't assume sse2 on i686

     

       144
       144
        
         CGO_ENABLED = 1;

     

       145
       145
        
         GOROOT_BOOTSTRAP = "${goBootstrap}/share/go";

+3 -3

pkgs/development/compilers/go/1.4.nix

···

       128
       128
        
       

     

       129
       129
        
         GOOS = if stdenv.isDarwin then "darwin" else "linux";

     

       130
       130
        
         GOARCH = if stdenv.isDarwin then "amd64"

     

       131
       131
       -
                  else if stdenv.system == "i686-linux" then "386"

     

       132
       132
       -
                  else if stdenv.system == "x86_64-linux" then "amd64"

     

       131
       131
       +
                  else if stdenv.hostPlatform.system == "i686-linux" then "386"

     

       132
       132
       +
                  else if stdenv.hostPlatform.system == "x86_64-linux" then "amd64"

     

       133
       133
        
                  else if stdenv.isAarch32 then "arm"

     

       134
       134
        
                  else throw "Unsupported system";

     

       135
       135
       -
         GOARM = stdenv.lib.optionalString (stdenv.system == "armv5tel-linux") "5";

     

       135
       135
       +
         GOARM = stdenv.lib.optionalString (stdenv.hostPlatform.system == "armv5tel-linux") "5";

     

       136
       136
        
         GO386 = 387; # from Arch: don't assume sse2 on i686

     

       137
       137
        
         CGO_ENABLED = 0;

     

       138
       138

+3 -3

pkgs/development/compilers/go/1.9.nix

···

       134
       134
        
       

     

       135
       135
        
         GOOS = if stdenv.isDarwin then "darwin" else "linux";

     

       136
       136
        
         GOARCH = if stdenv.isDarwin then "amd64"

     

       137
       137
       -
                  else if stdenv.system == "i686-linux" then "386"

     

       138
       138
       -
                  else if stdenv.system == "x86_64-linux" then "amd64"

     

       137
       137
       +
                  else if stdenv.hostPlatform.system == "i686-linux" then "386"

     

       138
       138
       +
                  else if stdenv.hostPlatform.system == "x86_64-linux" then "amd64"

     

       139
       139
        
                  else if stdenv.isAarch32 then "arm"

     

       140
       140
        
                  else if stdenv.isAarch64 then "arm64"

     

       141
       141
        
                  else throw "Unsupported system";

     

       142
       142
       -
         GOARM = optionalString (stdenv.system == "armv5tel-linux") "5";

     

       142
       142
       +
         GOARM = optionalString (stdenv.hostPlatform.system == "armv5tel-linux") "5";

     

       143
       143
        
         GO386 = 387; # from Arch: don't assume sse2 on i686

     

       144
       144
        
         CGO_ENABLED = 1;

     

       145
       145
        
         GOROOT_BOOTSTRAP = "${goBootstrap}/share/go";

+2 -2

pkgs/development/compilers/jetbrains-jdk/default.nix

···

       10
       10
        
         version = "152b1248.6";

     

       11
       11
        
         name = pname + "-" + version;

     

       12
       12
        
       

     

       13
       13
       -
         src = if stdenv.system == "x86_64-linux" then

     

       13
       13
       +
         src = if stdenv.hostPlatform.system == "x86_64-linux" then

     

       14
       14
        
           fetchurl {

     

       15
       15
        
             url = "https://bintray.com/jetbrains/intellij-jdk/download_file?file_path=jbsdk8u${version}_linux_x64.tar.gz";

     

       16
       16
        
             sha256 = "12l81g8zhaymh4rzyfl9nyzmpkgzc7wrphm3j4plxx129yn9i7d7";

     

       17
       17
        
           }

     

       18
       18
        
         else

     

       19
       19
       -
           throw "unsupported system: ${stdenv.system}";

     

       19
       19
       +
           throw "unsupported system: ${stdenv.hostPlatform.system}";

     

       20
       20
        
       

     

       21
       21
        
         nativeBuildInputs = [ file ];

     

       22
       22

+1 -1

pkgs/development/compilers/julia/default.nix

···

       101
       101
        
       

     

       102
       102
        
         makeFlags =

     

       103
       103
        
           let

     

       104
       104
       -
             arch = head (splitString "-" stdenv.system);

     

       104
       104
       +
             arch = head (splitString "-" stdenv.hostPlatform.system);

     

       105
       105
        
             march = { "x86_64" = "x86-64"; "i686" = "pentium4"; }."${arch}"

     

       106
       106
        
                     or (throw "unsupported architecture: ${arch}");

     

       107
       107
        
             # Julia requires Pentium 4 (SSE2) or better

+3 -3

pkgs/development/compilers/mlton/default.nix

···

       14
       14
        
         name = "mlton-${version}";

     

       15
       15
        
       

     

       16
       16
        
         binSrc =

     

       17
       17
       -
           if stdenv.system == "i686-linux" then (fetchurl {

     

       17
       17
       +
           if stdenv.hostPlatform.system == "i686-linux" then (fetchurl {

     

       18
       18
        
             url = "mirror://sourceforge/project/mlton/mlton/${version}/${name}-1.x86-linux.tgz";

     

       19
       19
        
             sha256 = "1kxjjmnw4xk2d9hpvz43w9dvyhb3025k4zvjx785c33nrwkrdn4j";

     

       20
       20
        
           })

     

       21
       21
       -
           else if stdenv.system == "x86_64-linux" then (fetchurl {

     

       21
       21
       +
           else if stdenv.hostPlatform.system == "x86_64-linux" then (fetchurl {

     

       22
       22
        
               url = "mirror://sourceforge/project/mlton/mlton/${version}/${name}-1.amd64-linux.tgz";

     

       23
       23
        
               sha256 = "0fyhwxb4nmpirjbjcvk9f6w67gmn2gkz7xcgz0xbfih9kc015ygn";

     

       24
       24
        
           })

     

       25
       25
       -
           else if stdenv.system == "x86_64-darwin" then (fetchurl {

     

       25
       25
       +
           else if stdenv.hostPlatform.system == "x86_64-darwin" then (fetchurl {

     

       26
       26
        
               url = "mirror://sourceforge/project/mlton/mlton/${version}/${name}-1.amd64-darwin.gmp-macports.tgz";

     

       27
       27
        
               sha256 = "044wnh9hhg6if886xy805683k0as347xd37r0r1yi4x7qlxzzgx9";

     

       28
       28
        
           })

+1 -1

pkgs/development/compilers/mozart/binary.nix

···

       20
       20
        
       

     

       21
       21
        
         preferLocalBuild = true;

     

       22
       22
        
       

     

       23
       23
       -
         src = binaries."${stdenv.system}" or (throw "unsupported system: ${stdenv.system}");

     

       23
       23
       +
         src = binaries."${stdenv.hostPlatform.system}" or (throw "unsupported system: ${stdenv.hostPlatform.system}");

     

       24
       24
        
       

     

       25
       25
        
         libPath = stdenv.lib.makeLibraryPath

     

       26
       26
        
           [ stdenv.cc.cc

+3 -3

pkgs/development/compilers/nvidia-cg-toolkit/default.nix

···

       10
       10
        
         name = "nvidia-cg-toolkit-${version}";

     

       11
       11
        
       

     

       12
       12
        
         src =

     

       13
       13
       -
           if stdenv.system == "x86_64-linux" then

     

       13
       13
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       14
       14
        
             fetchurl {

     

       15
       15
        
               url = "https://developer.download.nvidia.com/cg/Cg_${version}/Cg-${version}_${date}_x86_64.tgz";

     

       16
       16
        
               sha256 = "e8ff01e6cc38d1b3fd56a083f5860737dbd2f319a39037528fb1a74a89ae9878";

     

       17
       17
        
             }

     

       18
       18
       -
           else if stdenv.system == "i686-linux" then

     

       18
       18
       +
           else if stdenv.hostPlatform.system == "i686-linux" then

     

       19
       19
        
             fetchurl {

     

       20
       20
        
               url = "http://developer.download.nvidia.com/cg/Cg_${version}/Cg-${version}_${date}_x86.tgz";

     

       21
       21
        
               sha256 = "cef3591e436f528852db0e8c145d3842f920e0c89bcfb219c466797cb7b18879";

     

       22
       22
        
             }

     

       23
       23
       -
           else throw "nvidia-cg-toolkit does not support platform ${stdenv.system}";

     

       23
       23
       +
           else throw "nvidia-cg-toolkit does not support platform ${stdenv.hostPlatform.system}";

     

       24
       24
        
       

     

       25
       25
        
         installPhase = ''

     

       26
       26
        
           for b in cgc cgfxcat cginfo

+3 -3

pkgs/development/compilers/opendylan/bin.nix

···

       5
       5
        
       stdenv.mkDerivation {

     

       6
       6
        
         name = "opendylan-2013.2";

     

       7
       7
        
       

     

       8
       8
       -
         src = if stdenv.system == "x86_64-linux" then fetchurl {

     

       8
       8
       +
         src = if stdenv.hostPlatform.system == "x86_64-linux" then fetchurl {

     

       9
       9
        
             url = https://opendylan.org/downloads/opendylan/2013.2/opendylan-2013.2-x86_64-linux.tar.bz2;

     

       10
       10
        
             sha256 = "035brbw3hm7zrs593q4zc42yglj1gmmkw3b1r7zzlw3ks4i2lg7h";

     

       11
       11
        
           }

     

       12
       12
       -
           else if stdenv.system == "i686-linux" then fetchurl {

     

       12
       12
       +
           else if stdenv.hostPlatform.system == "i686-linux" then fetchurl {

     

       13
       13
        
             url = https://opendylan.org/downloads/opendylan/2013.2/opendylan-2013.2-x86-linux.tar.bz2;

     

       14
       14
        
             sha256 = "0c61ihvblcsjrw6ncr8x8ylhskcrqs8pajs4mg5di36cvqw12nq5";

     

       15
       15
        
           }

     

       16
       16
       -
           else throw "platform ${stdenv.system} not supported.";

     

       16
       16
       +
           else throw "platform ${stdenv.hostPlatform.system} not supported.";

     

       17
       17
        
       

     

       18
       18
        
         buildInputs = [ patchelf boehmgc gnused makeWrapper ];

     

       19
       19

+3 -3

pkgs/development/compilers/opendylan/default.nix

···

       11
       11
        
           fetchSubmodules = true;

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       -
         buildInputs = (if stdenv.system == "i686-linux" then [ mps ] else [ boehmgc ]) ++ [

     

       14
       14
       +
         buildInputs = (if stdenv.hostPlatform.system == "i686-linux" then [ mps ] else [ boehmgc ]) ++ [

     

       15
       15
        
           opendylan-bootstrap boehmgc gnused autoconf automake perl makeWrapper

     

       16
       16
        
         ];

     

       17
       17
        
       

     

       18
       18
       -
         preConfigure = if stdenv.system == "i686-linux" then ''

     

       18
       18
       +
         preConfigure = if stdenv.hostPlatform.system == "i686-linux" then ''

     

       19
       19
        
           mkdir -p $TMPDIR/mps

     

       20
       20
        
           tar --strip-components=1 -xf ${mps.src} -C $TMPDIR/mps

     

       21
       21
        
           ./autogen.sh

     
···

       25
       25
        
         '';

     

       26
       26
        
       

     

       27
       27
        
         configureFlags = [

     

       28
       28
       -
           (if stdenv.system == "i686-linux" then "--with-mps=$(TMPDIR)/mps" else "--with-gc=${boehmgc.out}")

     

       28
       28
       +
           (if stdenv.hostPlatform.system == "i686-linux" then "--with-mps=$(TMPDIR)/mps" else "--with-gc=${boehmgc.out}")

     

       29
       29
        
         ];

     

       30
       30
        
         buildPhase = "make 3-stage-bootstrap";

     

       31
       31

+1 -1

pkgs/development/compilers/openjdk/10.nix

···

       13
       13
        
          * The JRE libraries are in directories that depend on the CPU.

     

       14
       14
        
          */

     

       15
       15
        
         architecture =

     

       16
       16
       -
           if stdenv.system == "i686-linux" then

     

       16
       16
       +
           if stdenv.hostPlatform.system == "i686-linux" then

     

       17
       17
        
             "i386"

     

       18
       18
        
           else "amd64";

     

       19
       19

+3 -3

pkgs/development/compilers/oraclejdk/jdk-linux-base.nix

···

       46
       46
        
           x86_64-linux  = "amd64";

     

       47
       47
        
           armv7l-linux  = "arm";

     

       48
       48
        
           aarch64-linux = "aarch64";

     

       49
       49
       -
         }.${stdenv.system};

     

       49
       49
       +
         }.${stdenv.hostPlatform.system};

     

       50
       50
        
       

     

       51
       51
        
         jce =

     

       52
       52
        
           if installjce then

     
···

       77
       77
        
             x86_64-linux  = "jdk-${productVersion}u${patchVersion}-linux-x64.tar.gz";

     

       78
       78
        
             armv7l-linux  = "jdk-${productVersion}u${patchVersion}-linux-arm32-vfp-hflt.tar.gz";

     

       79
       79
        
             aarch64-linux = "jdk-${productVersion}u${patchVersion}-linux-arm64-vfp-hflt.tar.gz";

     

       80
       80
       -
           }.${stdenv.system};

     

       80
       80
       +
           }.${stdenv.hostPlatform.system};

     

       81
       81
        
           url = downloadUrl;

     

       82
       82
       -
           sha256 = sha256.${stdenv.system};

     

       82
       82
       +
           sha256 = sha256.${stdenv.hostPlatform.system};

     

       83
       83
        
         };

     

       84
       84
        
       

     

       85
       85
        
         nativeBuildInputs = [ file ]

+1 -1

pkgs/development/compilers/orc/default.nix

···

       16
       16
        
         '';

     

       17
       17
        
       

     

       18
       18
        
         # https://bugzilla.gnome.org/show_bug.cgi?id=728129#c15

     

       19
       19
       -
         doCheck = stdenv.system != "i686-linux"; # not sure about cross-compiling

     

       19
       19
       +
         doCheck = stdenv.hostPlatform.system != "i686-linux"; # not sure about cross-compiling

     

       20
       20
        
       

     

       21
       21
        
         meta = with stdenv.lib; {

     

       22
       22
        
           description = "The Oil Runtime Compiler";

+2 -2

pkgs/development/compilers/picat/default.nix

···

       8
       8
        
           sha256 = "0wvl95gf4pjs93632g4wi0mw1glzzhjp9g4xg93ll2zxggbxibli";

     

       9
       9
        
         };

     

       10
       10
        
       

     

       11
       11
       -
         ARCH = if stdenv.system == "i686-linux" then "linux32"

     

       12
       12
       -
                else if stdenv.system == "x86_64-linux" then "linux64"

     

       11
       11
       +
         ARCH = if stdenv.hostPlatform.system == "i686-linux" then "linux32"

     

       12
       12
       +
                else if stdenv.hostPlatform.system == "x86_64-linux" then "linux64"

     

       13
       13
        
                else throw "Unsupported system";

     

       14
       14
        
       

     

       15
       15
        
         hardeningDisable = [ "format" ];

+7 -7

pkgs/development/compilers/rust/bootstrap.nix

···

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
        
         platform =

     

       19
       19
       -
           if stdenv.system == "i686-linux"

     

       19
       19
       +
           if stdenv.hostPlatform.system == "i686-linux"

     

       20
       20
        
           then "i686-unknown-linux-gnu"

     

       21
       21
       -
           else if stdenv.system == "x86_64-linux"

     

       21
       21
       +
           else if stdenv.hostPlatform.system == "x86_64-linux"

     

       22
       22
        
           then "x86_64-unknown-linux-gnu"

     

       23
       23
       -
           else if stdenv.system == "armv7l-linux"

     

       23
       23
       +
           else if stdenv.hostPlatform.system == "armv7l-linux"

     

       24
       24
        
           then "armv7-unknown-linux-gnueabihf"

     

       25
       25
       -
           else if stdenv.system == "aarch64-linux"

     

       25
       25
       +
           else if stdenv.hostPlatform.system == "aarch64-linux"

     

       26
       26
        
           then "aarch64-unknown-linux-gnu"

     

       27
       27
       -
           else if stdenv.system == "i686-darwin"

     

       27
       27
       +
           else if stdenv.hostPlatform.system == "i686-darwin"

     

       28
       28
        
           then "i686-apple-darwin"

     

       29
       29
       -
           else if stdenv.system == "x86_64-darwin"

     

       29
       29
       +
           else if stdenv.hostPlatform.system == "x86_64-darwin"

     

       30
       30
        
           then "x86_64-apple-darwin"

     

       31
       31
       -
           else throw "missing bootstrap url for platform ${stdenv.system}";

     

       31
       31
       +
           else throw "missing bootstrap url for platform ${stdenv.hostPlatform.system}";

     

       32
       32
        
       

     

       33
       33
        
         src = fetchurl {

     

       34
       34
        
            url = "https://static.rust-lang.org/dist/rust-${version}-${platform}.tar.gz";

+2 -2

pkgs/development/compilers/sbcl/bootstrap.nix

···

       39
       39
        
             sha256 = "05c12fmac4ha72k1ckl6i780rckd7jh4g5s5hiic7fjxnf1kx8d0";

     

       40
       40
        
           };

     

       41
       41
        
         };

     

       42
       42
       -
         cfg = options.${stdenv.system};

     

       42
       42
       +
         cfg = options.${stdenv.hostPlatform.system};

     

       43
       43
        
       in

     

       44
       44
       -
       assert builtins.hasAttr stdenv.system options;

     

       44
       44
       +
       assert builtins.hasAttr stdenv.hostPlatform.system options;

     

       45
       45
        
       stdenv.mkDerivation rec {

     

       46
       46
        
         name    = "sbcl-bootstrap-${version}";

     

       47
       47
        
         version = cfg.version;

+1 -1

pkgs/development/compilers/sbcl/default.nix

···

       1
       1
        
       { stdenv, fetchurl, writeText, sbclBootstrap

     

       2
       2
        
       , sbclBootstrapHost ? "${sbclBootstrap}/bin/sbcl --disable-debugger --no-userinit --no-sysinit"

     

       3
       3
       -
       , threadSupport ? (stdenv.isi686 || stdenv.isx86_64 || "aarch64-linux" == stdenv.system)

     

       3
       3
       +
       , threadSupport ? (stdenv.isi686 || stdenv.isx86_64 || "aarch64-linux" == stdenv.hostPlatform.system)

     

       4
       4
        
         # Meant for sbcl used for creating binaries portable to non-NixOS via save-lisp-and-die.

     

       5
       5
        
         # Note that the created binaries still need `patchelf --set-interpreter ...`

     

       6
       6
        
         # to get rid of ${glibc} dependency.

+1 -1

pkgs/development/interpreters/dart/default.nix

···

       45
       45
        
           unzip

     

       46
       46
        
         ];

     

       47
       47
        
       

     

       48
       48
       -
         src = sources."${version}-${stdenv.system}" or (throw "unsupported version/system: ${version}/${stdenv.system}");

     

       48
       48
       +
         src = sources."${version}-${stdenv.hostPlatform.system}" or (throw "unsupported version/system: ${version}/${stdenv.hostPlatform.system}");

     

       49
       49
        
       

     

       50
       50
        
         installPhase = ''

     

       51
       51
        
           mkdir -p $out

+1 -1

pkgs/development/interpreters/spidermonkey/1.8.5.nix

···

       43
       43
        
         # of polkit, which is what matters most, it does not override the allocator

     

       44
       44
        
         # so the failure of that test does not matter much.

     

       45
       45
        
         configureFlags = [ "--enable-threadsafe" "--with-system-nspr" ] ++

     

       46
       46
       -
           stdenv.lib.optionals (stdenv.system == "armv5tel-linux") [

     

       46
       46
       +
           stdenv.lib.optionals (stdenv.hostPlatform.system == "armv5tel-linux") [

     

       47
       47
        
               "--with-cpu-arch=armv5t" 

     

       48
       48
        
               "--disable-tracejit" ];

     

       49
       49

+1 -1

pkgs/development/libraries/apr/default.nix

···

       26
       26
        
         configureFlags =

     

       27
       27
        
           # Including the Windows headers breaks unistd.h.

     

       28
       28
        
           # Based on ftp://sourceware.org/pub/cygwin/release/libapr1/libapr1-1.3.8-2-src.tar.bz2

     

       29
       29
       -
           stdenv.lib.optional (stdenv.system == "i686-cygwin") "ac_cv_header_windows_h=no";

     

       29
       29
       +
           stdenv.lib.optional (stdenv.hostPlatform.system == "i686-cygwin") "ac_cv_header_windows_h=no";

     

       30
       30
        
       

     

       31
       31
        
         enableParallelBuilding = true;

     

       32
       32

+2 -2

pkgs/development/libraries/audio/libbass/default.nix

···

       41
       41
        
           dontBuild = true;

     

       42
       42
        
           installPhase =

     

       43
       43
        
             let so =

     

       44
       44
       -
                   if bass.so ? ${stdenv.system} then bass.so.${stdenv.system}

     

       45
       45
       -
                   else throw "${name} not packaged for ${stdenv.system} (yet).";

     

       44
       44
       +
                   if bass.so ? ${stdenv.hostPlatform.system} then bass.so.${stdenv.hostPlatform.system}

     

       45
       45
       +
                   else throw "${name} not packaged for ${stdenv.hostPlatform.system} (yet).";

     

       46
       46
        
             in ''

     

       47
       47
        
               mkdir -p $out/{lib,include}

     

       48
       48
        
               install -m644 -t $out/lib/ ${so}

+1 -1

pkgs/development/libraries/bootil/default.nix

···

       28
       28
        
         platform =

     

       29
       29
        
           if stdenv.isLinux then "linux"

     

       30
       30
        
           else if stdenv.isDarwin then "macosx"

     

       31
       31
       -
           else throw "unrecognized system ${stdenv.system}";

     

       31
       31
       +
           else throw "unrecognized system ${stdenv.hostPlatform.system}";

     

       32
       32
        
       

     

       33
       33
        
         buildInputs = [ premake4 ];

     

       34
       34

+4 -3

pkgs/development/libraries/crypto++/default.nix

···

       12
       12
        
           sha256 = "1yk7jyf4va9425cg05llskpls2jm7n3jwy2hj5jm74zkr4mwpvl7";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
       -
         patches = with stdenv;

     

       16
       16
       -
           lib.optional (system != "i686-cygwin") ./dll.patch

     

       17
       17
       -
           ++ lib.optional isDarwin ./GNUmakefile-darwin.patch;

     

       15
       15
       +
         patches = stdenv.lib.concatLists [

     

       16
       16
       +
           (stdenv.lib.optional (stdenv.hostPlatform.system != "i686-cygwin") ./dll.patch)

     

       17
       17
       +
           (stdenv.lib.optional stdenv.hostPlatform.isDarwin ./GNUmakefile-darwin.patch)

     

       18
       18
       +
         ];

     

       18
       19
        
       

     

       19
       20
        
       

     

       20
       21
        
         configurePhase = let

+4 -1

pkgs/development/libraries/gpgme/default.nix

···

       7
       7
        
       , withPython ? false, swig2 ? null, python ? null

     

       8
       8
        
       }:

     

       9
       9
        
       

     

       10
       10
       -
       let inherit (stdenv) lib system; in

     

       10
       10
       +
       let

     

       11
       11
       +
         inherit (stdenv) lib;

     

       12
       12
       +
         inherit (stdenv.hostPlatform) system;

     

       13
       13
       +
       in

     

       11
       14
        
       

     

       12
       15
        
       stdenv.mkDerivation rec {

     

       13
       16
        
         name = "gpgme-${version}";

+1 -1

pkgs/development/libraries/gsl/default.nix

···

       14
       14
        
         ];

     

       15
       15
        
       

     

       16
       16
        
         # https://lists.gnu.org/archive/html/bug-gsl/2015-11/msg00012.html

     

       17
       17
       -
         doCheck = stdenv.system != "i686-linux" && stdenv.system != "aarch64-linux";

     

       17
       17
       +
         doCheck = stdenv.hostPlatform.system != "i686-linux" && stdenv.hostPlatform.system != "aarch64-linux";

     

       18
       18
        
       

     

       19
       19
        
         meta = {

     

       20
       20
        
           description = "The GNU Scientific Library, a large numerical library";

+1 -1

pkgs/development/libraries/java/jzmq/default.nix

···

       15
       15
        
         buildInputs = [ zeromq3 jdk ];

     

       16
       16
        
       

     

       17
       17
        
         preConfigure = ''

     

       18
       18
       -
           ${if stdenv.system == "x86_64-darwin" then

     

       18
       18
       +
           ${if stdenv.hostPlatform.system == "x86_64-darwin" then

     

       19
       19
        
             '' sed -i -e 's~/Headers~/include~' -e 's~_JNI_INC_SUBDIRS=\".*\"~_JNI_INC_SUBDIRS=\"darwin\"~' configure

     

       20
       20
        
             '' else ""}

     

       21
       21
        
         '';

+1 -1

pkgs/development/libraries/java/swt/default.nix

···

       16
       16
        
               sha256 = "00k1mfbncvyh8klgmk0891w8jwnd5niqb16j1j8yacrm2smmlb05"; };

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
       -
         metadata = assert platformMap ? ${stdenv.system}; platformMap.${stdenv.system};

     

       19
       19
       +
         metadata = assert platformMap ? ${stdenv.hostPlatform.system}; platformMap.${stdenv.hostPlatform.system};

     

       20
       20
        
       

     

       21
       21
        
       in stdenv.mkDerivation rec {

     

       22
       22
        
         version = "4.5";

+6 -6

pkgs/development/libraries/libspotify/default.nix

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         version = "12.1.51";

     

       5
       5
       -
         isLinux = (stdenv.system == "x86_64-linux" || stdenv.system == "i686-linux");

     

       5
       5
       +
         isLinux = (stdenv.hostPlatform.system == "x86_64-linux" || stdenv.hostPlatform.system == "i686-linux");

     

       6
       6
        
       in

     

       7
       7
        
       

     

       8
       8
       -
       if (stdenv.system != "x86_64-linux" && stdenv.system != "x86_64-darwin" && stdenv.system != "i686-linux")

     

       8
       8
       +
       if (stdenv.hostPlatform.system != "x86_64-linux" && stdenv.hostPlatform.system != "x86_64-darwin" && stdenv.hostPlatform.system != "i686-linux")

     

       9
       9
        
       then throw "Check https://developer.spotify.com/technologies/libspotify/ for a tarball for your system and add it here"

     

       10
       10
        
       else stdenv.mkDerivation {

     

       11
       11
        
         name = "libspotify-${version}";

     

       12
       12
        
       

     

       13
       13
        
         src =

     

       14
       14
       -
           if stdenv.system == "x86_64-linux" then

     

       14
       14
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       15
       15
        
             fetchurl {

     

       16
       16
        
               url    = "https://developer.spotify.com/download/libspotify/libspotify-${version}-Linux-x86_64-release.tar.gz";

     

       17
       17
        
               sha256 = "0n0h94i4xg46hfba95n3ypah93crwb80bhgsg00f6sms683lx8a3";

     

       18
       18
        
             }

     

       19
       19
       -
           else if stdenv.system == "x86_64-darwin" then

     

       19
       19
       +
           else if stdenv.hostPlatform.system == "x86_64-darwin" then

     

       20
       20
        
             fetchurl {

     

       21
       21
        
               url    = "https://developer.spotify.com/download/libspotify/libspotify-${version}-Darwin-universal.zip";

     

       22
       22
        
               sha256 = "1gcgrc8arim3hnszcc886lmcdb4iigc08abkaa02l6gng43ky1c0";

     

       23
       23
        
             }

     

       24
       24
       -
           else if stdenv.system == "i686-linux" then

     

       24
       24
       +
           else if stdenv.hostPlatform.system == "i686-linux" then

     

       25
       25
        
             fetchurl {

     

       26
       26
        
               url    = "https://developer.spotify.com/download/libspotify/libspotify-${version}-Linux-i686-release.tar.gz";

     

       27
       27
        
               sha256 = "1bjmn64gbr4p9irq426yap4ipq9rb84zsyhjjr7frmmw22xb86ll";

     
···

       46
       46
        
       

     

       47
       47
        
       

     

       48
       48
        
         # darwin-specific

     

       49
       49
       -
         buildInputs = stdenv.lib.optional (stdenv.system == "x86_64-darwin") unzip;

     

       49
       49
       +
         buildInputs = stdenv.lib.optional (stdenv.hostPlatform.system == "x86_64-darwin") unzip;

     

       50
       50
        
       

     

       51
       51
        
         # linux-specific

     

       52
       52
        
         installFlags = stdenv.lib.optionalString (isLinux)

+1 -1

pkgs/development/libraries/live555/default.nix

···

       28
       28
        
             i686-linux = "linux";

     

       29
       29
        
             x86_64-linux = "linux-64bit";

     

       30
       30
        
             aarch64-linux = "linux-64bit";

     

       31
       31
       -
           }.${stdenv.system}}

     

       31
       31
       +
           }.${stdenv.hostPlatform.system}}

     

       32
       32
        
         '';

     

       33
       33
        
       

     

       34
       34
        
         installPhase = ''

+1 -1

pkgs/development/libraries/mesa/default.nix

···

       23
       23
        
       

     

       24
       24
        
       with stdenv.lib;

     

       25
       25
        
       

     

       26
       26
       -
       if ! lists.elem stdenv.system platforms.mesaPlatforms then

     

       26
       26
       +
       if ! lists.elem stdenv.hostPlatform.system platforms.mesaPlatforms then

     

       27
       27
        
         throw "unsupported platform for Mesa"

     

       28
       28
        
       else

     

       29
       29

+2 -2

pkgs/development/libraries/nettle/generic.nix

···

       16
       16
        
         nativeBuildInputs = [ gnum4 ];

     

       17
       17
        
         propagatedBuildInputs = [ gmp ];

     

       18
       18
        
       

     

       19
       19
       -
         doCheck = (stdenv.system != "i686-cygwin" && !stdenv.isDarwin);

     

       19
       19
       +
         doCheck = (stdenv.hostPlatform.system != "i686-cygwin" && !stdenv.isDarwin);

     

       20
       20
        
       

     

       21
       21
        
         enableParallelBuilding = true;

     

       22
       22
        
       

     

       23
       23
       -
         patches = stdenv.lib.optional (stdenv.system == "i686-cygwin")

     

       23
       23
       +
         patches = stdenv.lib.optional (stdenv.hostPlatform.system == "i686-cygwin")

     

       24
       24
        
                     ./cygwin.patch;

     

       25
       25
        
       

     

       26
       26
        
         meta = with stdenv.lib; {

+3 -3

pkgs/development/libraries/opencv/3.x.nix

···

       63
       63
        
             sha256 = "1ys9mshfpm8iy8h4ml792gnqrq959dsrcv26axx14niivxyjbji8";

     

       64
       64
        
           } + "/ippicv";

     

       65
       65
        
           files = let name = platform : "ippicv_2017u3_${platform}_general_20180518.tgz"; in

     

       66
       66
       -
             if stdenv.system == "x86_64-linux" then

     

       66
       66
       +
             if stdenv.hostPlatform.system == "x86_64-linux" then

     

       67
       67
        
             { ${name "lnx_intel64"} = "b7cc351267db2d34b9efa1cd22ff0572"; }

     

       68
       68
       -
             else if stdenv.system == "i686-linux" then

     

       68
       68
       +
             else if stdenv.hostPlatform.system == "i686-linux" then

     

       69
       69
        
             { ${name "lnx_ia32"}    = "ea72de74dae3c604eb6348395366e78e"; }

     

       70
       70
       -
             else if stdenv.system == "x86_64-darwin" then

     

       70
       70
       +
             else if stdenv.hostPlatform.system == "x86_64-darwin" then

     

       71
       71
        
             { ${name "mac_intel64"} = "3ae52b9be0fe73dd45bc5e9429cd3732"; }

     

       72
       72
        
             else

     

       73
       73
        
             throw "ICV is not available for this platform (or not yet supported by this package)";

+3 -3

pkgs/development/libraries/oracle-instantclient/default.nix

···

       14
       14
        
           sha256 = hash;

     

       15
       15
        
         });

     

       16
       16
        
       

     

       17
       17
       -
         throwSystem = throw "Unsupported system: ${stdenv.system}";

     

       17
       17
       +
         throwSystem = throw "Unsupported system: ${stdenv.hostPlatform.system}";

     

       18
       18
        
       

     

       19
       19
        
         arch = {

     

       20
       20
        
           "x86_64-linux" = "linux.x64";

     

       21
       21
        
           "x86_64-darwin" = "macos.x64";

     

       22
       22
       -
         }."${stdenv.system}" or throwSystem;

     

       22
       22
       +
         }."${stdenv.hostPlatform.system}" or throwSystem;

     

       23
       23
        
       

     

       24
       24
        
         srcs = {

     

       25
       25
        
           "x86_64-linux" = [

     
···

       32
       32
        
             (requireSource "sdk" arch version "2" "e0befca9c4e71ebc9f444957ffa70f01aeeec5976ea27c40406471b04c34848b")

     

       33
       33
        
             (requireSource "sqlplus" arch version "2" "d147cbb5b2a954fdcb4b642df4f0bd1153fd56e0f56e7fa301601b4f7e2abe0e") ]

     

       34
       34
        
             ++ optional odbcSupport (requireSource "odbc" arch version "2" "1805c1ab6c8c5e8df7bdcc35d7f2b94c329ecf4dff9bde55d5f9b159ecd8b64e");

     

       35
       35
       -
         }."${stdenv.system}" or throwSystem;

     

       35
       35
       +
         }."${stdenv.hostPlatform.system}" or throwSystem;

     

       36
       36
        
       

     

       37
       37
        
         extLib = stdenv.hostPlatform.extensions.sharedLibrary;

     

       38
       38
        
       in stdenv.mkDerivation rec {

+1 -1

pkgs/development/libraries/physics/geant4/fetch.nix

···

       1
       1
        
       { stdenv, fetchurl }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         fetch = { version, src ? builtins.getAttr stdenv.system sources, sources ? null }:

     

       4
       4
       +
         fetch = { version, src ? builtins.getAttr stdenv.hostPlatform.system sources, sources ? null }:

     

       5
       5
        
         {

     

       6
       6
        
           inherit version src;

     

       7
       7
        
         };

+3 -3

pkgs/development/libraries/science/math/openblas/default.nix

···

       67
       67
        
       

     

       68
       68
        
       let

     

       69
       69
        
         config =

     

       70
       70
       -
           configs.${stdenv.system}

     

       71
       71
       -
           or (throw "unsupported system: ${stdenv.system}");

     

       70
       70
       +
           configs.${stdenv.hostPlatform.system}

     

       71
       71
       +
           or (throw "unsupported system: ${stdenv.hostPlatform.system}");

     

       72
       72
        
       in

     

       73
       73
        
       

     

       74
       74
        
       let

     

       75
       75
        
         blas64 =

     

       76
       76
        
           if blas64_ != null

     

       77
       77
        
             then blas64_

     

       78
       78
       -
             else hasPrefix "x86_64" stdenv.system;

     

       78
       78
       +
             else hasPrefix "x86_64" stdenv.hostPlatform.system;

     

       79
       79
        
       in

     

       80
       80
        
       stdenv.mkDerivation rec {

     

       81
       81
        
         name = "openblas-${version}";

+2 -2

pkgs/development/libraries/scmccid/default.nix

···

       5
       5
        
       stdenv.mkDerivation rec {

     

       6
       6
        
         name = "scmccid-5.0.11";

     

       7
       7
        
       

     

       8
       8
       -
         src = if stdenv.system == "i686-linux" then (fetchurl {

     

       8
       8
       +
         src = if stdenv.hostPlatform.system == "i686-linux" then (fetchurl {

     

       9
       9
        
             url = "http://www.scmmicro.com/support/download/scmccid_5.0.11_linux.tar.gz";

     

       10
       10
        
             sha256 = "1r5wkarhzl09ncgj55baizf573czw0nplh1pgddzx9xck66kh5bm";

     

       11
       11
        
           })

     

       12
       12
       -
           else if stdenv.system == "x86_64-linux" then (fetchurl {

     

       12
       12
       +
           else if stdenv.hostPlatform.system == "x86_64-linux" then (fetchurl {

     

       13
       13
        
               url = "http://www.scmmicro.com/support/download/scmccid_5.0.11_linux_x64.tar.gz";

     

       14
       14
        
               sha256 = "0k9lzlk01sl4ycfqgrqqy3bildz0mcr1r0kkicgjz96l4s0jgz0i";

     

       15
       15
        
           })

+1 -1

pkgs/development/libraries/skalibs/default.nix

···

       33
       33
        
         # Explicitly setting target ensures code can be compiled against a skalibs

     

       34
       34
        
         # binary built on a different version of darwin.

     

       35
       35
        
         # http://www.skarnet.org/cgi-bin/archive.cgi?1:mss:623:heiodchokfjdkonfhdph

     

       36
       36
       -
         ++ (stdenv.lib.optional stdenv.isDarwin "--build=${stdenv.system}");

     

       36
       36
       +
         ++ (stdenv.lib.optional stdenv.isDarwin "--build=${stdenv.hostPlatform.system}");

     

       37
       37
        
       

     

       38
       38
        
         postInstall = ''

     

       39
       39
        
           mkdir -p $doc/share/doc/skalibs

+9 -9

pkgs/development/libraries/tachyon/default.nix

···

       34
       34
        
           export USEPNG=" -DUSEPNG"

     

       35
       35
        
           export PNGLIB=" -lpng -lz"

     

       36
       36
        
         '';

     

       37
       37
       -
         arch = if stdenv.system == "x86_64-linux"   then "linux-64-thr"  else

     

       38
       38
       -
                if stdenv.system == "i686-linux"     then "linux-thr"     else

     

       39
       39
       -
                if stdenv.system == "aarch64-linux"  then "linux-arm-thr" else

     

       40
       40
       -
                if stdenv.system == "armv7l-linux"   then "linux-arm-thr" else

     

       41
       41
       -
                if stdenv.system == "x86_64-darwin"  then "macosx-thr"    else

     

       42
       42
       -
                if stdenv.system == "i686-darwin"    then "macosx-64-thr" else

     

       43
       43
       -
                if stdenv.system == "i686-cygwin"    then "win32"         else

     

       44
       44
       -
                if stdenv.system == "x86_64-freebsd" then "bsd"           else

     

       45
       45
       -
                if stdenv.system == "x686-freebsd"   then "bsd"           else

     

       37
       37
       +
         arch = if stdenv.hostPlatform.system == "x86_64-linux"   then "linux-64-thr"  else

     

       38
       38
       +
                if stdenv.hostPlatform.system == "i686-linux"     then "linux-thr"     else

     

       39
       39
       +
                if stdenv.hostPlatform.system == "aarch64-linux"  then "linux-arm-thr" else

     

       40
       40
       +
                if stdenv.hostPlatform.system == "armv7l-linux"   then "linux-arm-thr" else

     

       41
       41
       +
                if stdenv.hostPlatform.system == "x86_64-darwin"  then "macosx-thr"    else

     

       42
       42
       +
                if stdenv.hostPlatform.system == "i686-darwin"    then "macosx-64-thr" else

     

       43
       43
       +
                if stdenv.hostPlatform.system == "i686-cygwin"    then "win32"         else

     

       44
       44
       +
                if stdenv.hostPlatform.system == "x86_64-freebsd" then "bsd"           else

     

       45
       45
       +
                if stdenv.hostPlatform.system == "x686-freebsd"   then "bsd"           else

     

       46
       46
        
                throw "Don't know what arch to select for tachyon build";

     

       47
       47
        
         makeFlags = "${arch}";

     

       48
       48
        
         patches = [

+1 -1

pkgs/development/libraries/v8/3.14.nix

···

       65
       65
        
       

     

       66
       66
        
         installPhase = ''

     

       67
       67
        
           install -vD out/Release/d8 "$out/bin/d8"

     

       68
       68
       -
           ${if stdenv.system == "x86_64-darwin" then ''

     

       68
       68
       +
           ${if stdenv.hostPlatform.system == "x86_64-darwin" then ''

     

       69
       69
        
           install -vD out/Release/lib.target/libv8.dylib "$out/lib/libv8.dylib"

     

       70
       70
        
           '' else ''

     

       71
       71
        
           install -vD out/Release/lib.target/libv8.so "$out/lib/libv8.so"

+1 -1

pkgs/development/libraries/vigra/default.nix

···

       21
       21
        
         preConfigure = "cmakeFlags+=\" -DVIGRANUMPY_INSTALL_DIR=$out/lib/${python.libPrefix}/site-packages\"";

     

       22
       22
        
       

     

       23
       23
        
         cmakeFlags = [ "-DWITH_OPENEXR=1" ]

     

       24
       24
       -
                   ++ stdenv.lib.optionals (stdenv.system == "x86_64-linux")

     

       24
       24
       +
                   ++ stdenv.lib.optionals (stdenv.hostPlatform.system == "x86_64-linux")

     

       25
       25
        
                         [ "-DCMAKE_CXX_FLAGS=-fPIC" "-DCMAKE_C_FLAGS=-fPIC" ];

     

       26
       26
        
       

     

       27
       27
        
         enableParallelBuilding = true;

+1 -1

pkgs/development/libraries/vxl/default.nix

···

       15
       15
        
         # in stdenv linux headers

     

       16
       16
        
         # BUILD_BRL fails to find open()

     

       17
       17
        
         cmakeFlags = "-DBUILD_TESTING=OFF -DBUILD_OUL=OFF -DBUILD_BRL=OFF -DBUILD_CONTRIB=OFF "

     

       18
       18
       -
           + (if stdenv.system == "x86_64-linux" then

     

       18
       18
       +
           + (if stdenv.hostPlatform.system == "x86_64-linux" then

     

       19
       19
        
             "-DCMAKE_CXX_FLAGS=-fPIC -DCMAKE_C_FLAGS=-fPIC"

     

       20
       20
        
           else

     

       21
       21
        
             "");

+1 -1

pkgs/development/libraries/wtk/default.nix

···

       1
       1
        
       { stdenv, requireFile, unzip, xorg }:

     

       2
       2
        
       

     

       3
       3
       -
       assert stdenv.system == "i686-linux";

     

       3
       3
       +
       assert stdenv.hostPlatform.system == "i686-linux";

     

       4
       4
        
       

     

       5
       5
        
       stdenv.mkDerivation rec {

     

       6
       6
        
         name = "sun-java-wtk-2.5.2_01";

+2 -2

pkgs/development/misc/amdapp-sdk/default.nix

···

       5
       5
        
       

     

       6
       6
        
       let

     

       7
       7
        
       

     

       8
       8
       -
         bits = if stdenv.system == "x86_64-linux" then "64"

     

       8
       8
       +
         bits = if stdenv.hostPlatform.system == "x86_64-linux" then "64"

     

       9
       9
        
                else "32";

     

       10
       10
        
       

     

       11
       11
       -
         arch = if stdenv.system == "x86_64-linux" then "x86_64"

     

       11
       11
       +
         arch = if stdenv.hostPlatform.system == "x86_64-linux" then "x86_64"

     

       12
       12
        
                else "x86";

     

       13
       13
        
       

     

       14
       14
        
         src_info = {

+2 -2

pkgs/development/mobile/androidenv/androidndk.nix

···

       10
       10
        
         name = "android-ndk-r${version}";

     

       11
       11
        
         inherit version;

     

       12
       12
        
       

     

       13
       13
       -
         src = if stdenv.system == "x86_64-linux" then fetchurl {

     

       13
       13
       +
         src = if stdenv.hostPlatform.system == "x86_64-linux" then fetchurl {

     

       14
       14
        
             url = "https://dl.google.com/android/repository/${name}-linux-x86_64.zip";

     

       15
       15
        
             inherit sha256;

     

       16
       16
       -
           } else throw "platform ${stdenv.system} not supported!";

     

       16
       16
       +
           } else throw "platform ${stdenv.hostPlatform.system} not supported!";

     

       17
       17
        
       

     

       18
       18
        
         phases = "buildPhase";

     

       19
       19

+3 -3

pkgs/development/mobile/androidenv/androidndk_r8e.nix

···

       9
       9
        
       stdenv.mkDerivation rec {

     

       10
       10
        
         name = "android-ndk-r8e";

     

       11
       11
        
       

     

       12
       12
       -
         src = if stdenv.system == "i686-linux"

     

       12
       12
       +
         src = if stdenv.hostPlatform.system == "i686-linux"

     

       13
       13
        
           then fetchurl {

     

       14
       14
        
             url = "http://dl.google.com/android/ndk/${name}-linux-x86.tar.bz2";

     

       15
       15
        
             sha256 = "c2c4e0c8b3037149a0f5dbb08d72f814a52af4da9fff9d80328c675457e95a98";

     

       16
       16
        
           }

     

       17
       17
       -
           else if stdenv.system == "x86_64-linux" then fetchurl {

     

       17
       17
       +
           else if stdenv.hostPlatform.system == "x86_64-linux" then fetchurl {

     

       18
       18
        
             url = "http://dl.google.com/android/ndk/${name}-linux-x86_64.tar.bz2";

     

       19
       19
        
             sha256 = "093gf55zbh38p2gk5bdykj1vg9p5l774wjdzw5mhk4144jm1wdq7";

     

       20
       20
        
           }

     

       21
       21
       -
           else throw "platform ${stdenv.system} not supported!";

     

       21
       21
       +
           else throw "platform ${stdenv.hostPlatform.system} not supported!";

     

       22
       22
        
       

     

       23
       23
        
         phases = "buildPhase";

     

       24
       24

+9 -9

pkgs/development/mobile/androidenv/androidsdk.nix

···

       22
       22
        
         name = "android-sdk-${version}";

     

       23
       23
        
         version = "25.2.5";

     

       24
       24
        
       

     

       25
       25
       -
         src = if (stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux")

     

       25
       25
       +
         src = if (stdenv.hostPlatform.system == "i686-linux" || stdenv.hostPlatform.system == "x86_64-linux")

     

       26
       26
        
           then fetchurl {

     

       27
       27
        
             url = "https://dl.google.com/android/repository/tools_r${version}-linux.zip";

     

       28
       28
        
             sha256 = "0gnk49pkwy4m0nqwm1xnf3w4mfpi9w0kk7841xlawpwbkj0icxap";

     

       29
       29
        
           }

     

       30
       30
       -
           else if stdenv.system == "x86_64-darwin" then fetchurl {

     

       30
       30
       +
           else if stdenv.hostPlatform.system == "x86_64-darwin" then fetchurl {

     

       31
       31
        
             url = "http://dl.google.com/android/repository/tools_r${version}-macosx.zip";

     

       32
       32
        
             sha256 = "0yg7wjmyw70xsh8k4hgbqb5rilam2a94yc8dwbh7fjwqcmpxgwqb";

     

       33
       33
        
           }

     

       34
       34
       -
           else throw "platform not ${stdenv.system} supported!";

     

       34
       34
       +
           else throw "platform not ${stdenv.hostPlatform.system} supported!";

     

       35
       35
        
       

     

       36
       36
        
         buildCommand = ''

     

       37
       37
        
           mkdir -p $out/libexec

     
···

       44
       44
        
               sed -i -e "s|/bin/ls|${coreutils}/bin/ls|" "$f"

     

       45
       45
        
           done

     

       46
       46
        
       

     

       47
       47
       -
           ${stdenv.lib.optionalString (stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux")

     

       47
       47
       +
           ${stdenv.lib.optionalString (stdenv.hostPlatform.system == "i686-linux" || stdenv.hostPlatform.system == "x86_64-linux")

     

       48
       48
        
           ''

     

       49
       49
        
             # There are a number of native binaries. We must patch them to let them find the interpreter and libstdc++

     

       50
       50
        
       

     
···

       54
       54
        
                 patchelf --set-rpath ${stdenv_32bit.cc.cc.lib}/lib $i

     

       55
       55
        
             done

     

       56
       56
        
       

     

       57
       57
       -
             ${stdenv.lib.optionalString (stdenv.system == "x86_64-linux") ''

     

       57
       57
       +
             ${stdenv.lib.optionalString (stdenv.hostPlatform.system == "x86_64-linux") ''

     

       58
       58
        
               for i in bin64/{mkfs.ext4,fsck.ext4,e2fsck,tune2fs,resize2fs}

     

       59
       59
        
               do

     

       60
       60
        
                   patchelf --set-interpreter ${stdenv.cc.libc.out}/lib/ld-linux-x86-64.so.2 $i

     
···

       62
       62
        
               done

     

       63
       63
        
             ''}

     

       64
       64
        
       

     

       65
       65
       -
             ${stdenv.lib.optionalString (stdenv.system == "x86_64-linux") ''

     

       65
       65
       +
             ${stdenv.lib.optionalString (stdenv.hostPlatform.system == "x86_64-linux") ''

     

       66
       66
        
               # We must also patch the 64-bit emulator instances, if needed

     

       67
       67
        
       

     

       68
       68
        
               for i in emulator emulator64-arm emulator64-mips emulator64-x86 emulator64-crash-service emulator-check qemu/linux-x86_64/qemu-system-*

     
···

       89
       89
        
       

     

       90
       90
        
             # The emulators need additional libraries, which are dynamically loaded => let's wrap them

     

       91
       91
        
       

     

       92
       92
       -
             ${stdenv.lib.optionalString (stdenv.system == "x86_64-linux") ''

     

       92
       92
       +
             ${stdenv.lib.optionalString (stdenv.hostPlatform.system == "x86_64-linux") ''

     

       93
       93
        
               for i in emulator emulator64-arm emulator64-mips emulator64-x86 emulator64-crash-service

     

       94
       94
        
               do

     

       95
       95
        
                   wrapProgram `pwd`/$i \

     
···

       102
       102
        
       

     

       103
       103
        
           patchShebangs .

     

       104
       104
        
       

     

       105
       105
       -
           ${if stdenv.system == "i686-linux" then

     

       105
       105
       +
           ${if stdenv.hostPlatform.system == "i686-linux" then

     

       106
       106
        
             ''

     

       107
       107
        
               # The monitor requires some more patching

     

       108
       108
        
       

     
···

       115
       115
        
       

     

       116
       116
        
               cd ../..

     

       117
       117
        
             ''

     

       118
       118
       -
             else if stdenv.system == "x86_64-linux" then

     

       118
       118
       +
             else if stdenv.hostPlatform.system == "x86_64-linux" then

     

       119
       119
        
             ''

     

       120
       120
        
               # The monitor requires some more patching

     

       121
       121

+4 -4

pkgs/development/mobile/androidenv/build-tools.nix

···

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         version = "26.0.2";

     

       5
       5
        
         name = "android-build-tools-r${version}";

     

       6
       6
       -
         src = if (stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux")

     

       6
       6
       +
         src = if (stdenv.hostPlatform.system == "i686-linux" || stdenv.hostPlatform.system == "x86_64-linux")

     

       7
       7
        
           then fetchurl {

     

       8
       8
        
             url = "https://dl.google.com/android/repository/build-tools_r${version}-linux.zip";

     

       9
       9
        
             sha256 = "1kii880bwhjkc343zwx1ysxyisxhczrwhphnxbwsgi45mjgq8lm7";

     

       10
       10
        
           }

     

       11
       11
       -
           else if stdenv.system == "x86_64-darwin" then fetchurl {

     

       11
       11
       +
           else if stdenv.hostPlatform.system == "x86_64-darwin" then fetchurl {

     

       12
       12
        
             url = "https://dl.google.com/android/repository/build-tools_r${version}-macosx.zip";

     

       13
       13
        
             sha256 = "1x0ycprl6hgsm23kck5ind7x00hzydc5k3h3ch4a13407xbpvzvx";

     

       14
       14
        
           }

     

       15
       15
       -
           else throw "System ${stdenv.system} not supported!";

     

       15
       15
       +
           else throw "System ${stdenv.hostPlatform.system} not supported!";

     

       16
       16
        
       

     

       17
       17
        
         buildCommand = ''

     

       18
       18
        
           mkdir -p $out/build-tools

     
···

       20
       20
        
           unzip $src

     

       21
       21
        
           mv android-* ${version}

     

       22
       22
        
       

     

       23
       23
       -
           ${stdenv.lib.optionalString (stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux")

     

       23
       23
       +
           ${stdenv.lib.optionalString (stdenv.hostPlatform.system == "i686-linux" || stdenv.hostPlatform.system == "x86_64-linux")

     

       24
       24
        
             ''

     

       25
       25
        
               cd ${version}

     

       26
       26

+3 -3

pkgs/development/mobile/androidenv/default.nix

···

       25
       25
        
           inherit (pkgs) stdenv fetchurl unzip;

     

       26
       26
        
         };

     

       27
       27
        
       

     

       28
       28
       -
         platforms = if (pkgs.stdenv.system == "i686-linux" || pkgs.stdenv.system == "x86_64-linux")

     

       28
       28
       +
         platforms = if (pkgs.stdenv.hostPlatform.system == "i686-linux" || pkgs.stdenv.hostPlatform.system == "x86_64-linux")

     

       29
       29
        
           then import ./platforms-linux.nix {

     

       30
       30
        
             inherit (pkgs) stdenv fetchurl unzip;

     

       31
       31
        
           }

     

       32
       32
       -
           else if pkgs.stdenv.system == "x86_64-darwin"

     

       32
       32
       +
           else if pkgs.stdenv.hostPlatform.system == "x86_64-darwin"

     

       33
       33
        
           then import ./platforms-macosx.nix {

     

       34
       34
        
             inherit (pkgs) stdenv fetchurl unzip;

     

       35
       35
        
           }

     

       36
       36
       -
           else throw "Platform: ${pkgs.stdenv.system} not supported!";

     

       36
       36
       +
           else throw "Platform: ${pkgs.stdenv.hostPlatform.system} not supported!";

     

       37
       37
        
       

     

       38
       38
        
         sysimages = import ./sysimages.nix {

     

       39
       39
        
           inherit (pkgs) stdenv fetchurl unzip;

+4 -4

pkgs/development/mobile/androidenv/platform-tools.nix

···

       8
       8
        
       stdenv.mkDerivation rec {

     

       9
       9
        
         version = "26.0.2";

     

       10
       10
        
         name = "android-platform-tools-r${version}";

     

       11
       11
       -
         src = if (stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux")

     

       11
       11
       +
         src = if (stdenv.hostPlatform.system == "i686-linux" || stdenv.hostPlatform.system == "x86_64-linux")

     

       12
       12
        
           then fetchurl {

     

       13
       13
        
             url = "https://dl.google.com/android/repository/platform-tools_r${version}-linux.zip";

     

       14
       14
        
             sha256 = "0695npvxljbbh8xwfm65k34fcpyfkzvfkssgnp46wkmnq8w5mcb3";

     

       15
       15
        
           }

     

       16
       16
       -
           else if stdenv.system == "x86_64-darwin" then fetchurl {

     

       16
       16
       +
           else if stdenv.hostPlatform.system == "x86_64-darwin" then fetchurl {

     

       17
       17
        
             url = "https://dl.google.com/android/repository/platform-tools_r${version}-darwin.zip";

     

       18
       18
        
             sha256 = "0gy7apw9pmnnm41z6ywglw5va4ghmny4j57778may4q7ar751l56";

     

       19
       19
        
           }

     

       20
       20
       -
           else throw "System ${stdenv.system} not supported!";

     

       20
       20
       +
           else throw "System ${stdenv.hostPlatform.system} not supported!";

     

       21
       21
        
       

     

       22
       22
        
         buildCommand = ''

     

       23
       23
        
           mkdir -p $out

     
···

       25
       25
        
           unzip $src

     

       26
       26
        
           cd platform-tools

     

       27
       27
        
       

     

       28
       28
       -
           ${stdenv.lib.optionalString (stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux")

     

       28
       28
       +
           ${stdenv.lib.optionalString (stdenv.hostPlatform.system == "i686-linux" || stdenv.hostPlatform.system == "x86_64-linux")

     

       29
       29
        
             ''

     

       30
       30
        
               for i in adb dmtracedump fastboot hprof-conv sqlite3

     

       31
       31
        
               do

+1 -1

pkgs/development/mobile/titaniumenv/build-app.nix

···

       26
       26
        
         name = stdenv.lib.replaceChars [" "] [""] name;

     

       27
       27
        
         inherit src;

     

       28
       28
        
       

     

       29
       29
       -
         buildInputs = [ nodejs titanium alloy jdk python which file ] ++ stdenv.lib.optional (stdenv.system == "x86_64-darwin") xcodewrapper;

     

       29
       29
       +
         buildInputs = [ nodejs titanium alloy jdk python which file ] ++ stdenv.lib.optional (stdenv.hostPlatform.system == "x86_64-darwin") xcodewrapper;

     

       30
       30
        
         

     

       31
       31
        
         buildPhase = ''

     

       32
       32
        
           ${preBuild}

+1 -1

pkgs/development/mobile/titaniumenv/default.nix

···

       3
       3
        
       rec {

     

       4
       4
        
         androidenv = pkgs.androidenv;

     

       5
       5
        
       

     

       6
       6
       -
         xcodeenv = if pkgs.stdenv.system == "x86_64-darwin" then pkgs.xcodeenv.override {

     

       6
       6
       +
         xcodeenv = if pkgs.stdenv.hostPlatform.system == "x86_64-darwin" then pkgs.xcodeenv.override {

     

       7
       7
        
           version = xcodeVersion;

     

       8
       8
        
           inherit xcodeBaseDir;

     

       9
       9
        
         } else null;

+6 -6

pkgs/development/mobile/titaniumenv/titaniumsdk-6.3.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation {

     

       4
       4
        
         name = "mobilesdk-6.3.1.GA";

     

       5
       5
       -
         src = if (stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux") then fetchurl {

     

       5
       5
       +
         src = if (stdenv.hostPlatform.system == "i686-linux" || stdenv.hostPlatform.system == "x86_64-linux") then fetchurl {

     

       6
       6
        
           url = http://builds.appcelerator.com/mobile/6_3_X/mobilesdk-6.3.1.v20171101154403-linux.zip;

     

       7
       7
        
           sha256 = "0g8dqqf5ffa7ll3rqm5naywipnv2vvfxcj9fmqg1wnvvxf0rflqj";

     

       8
       8
        
         }

     

       9
       9
       -
         else if stdenv.system == "x86_64-darwin" then fetchurl {

     

       9
       9
       +
         else if stdenv.hostPlatform.system == "x86_64-darwin" then fetchurl {

     

       10
       10
        
           url = http://builds.appcelerator.com/mobile/6_3_X/mobilesdk-6.3.1.v20171101154403-osx.zip;

     

       11
       11
        
           sha256 = "00bm8vv70mg4kd7jvmxd1bfqafv6zdpdx816i0hvf801zwnak4nj";

     

       12
       12
        
         }

     

       13
       13
       -
         else throw "Platform: ${stdenv.system} not supported!";

     

       13
       13
       +
         else throw "Platform: ${stdenv.hostPlatform.system} not supported!";

     

       14
       14
        
         

     

       15
       15
        
         buildInputs = [ unzip makeWrapper ];

     

       16
       16
        
         

     
···

       23
       23
        
           cd mobilesdk/*

     

       24
       24
        
           mv * 6.3.1.GA

     

       25
       25
        
           cd *

     

       26
       26
       -
           ${stdenv.lib.optionalString (stdenv.system == "x86_64-darwin") ''

     

       26
       26
       +
           ${stdenv.lib.optionalString (stdenv.hostPlatform.system == "x86_64-darwin") ''

     

       27
       27
        
             # Fixes a bad archive copying error when generating an IPA file

     

       28
       28
        
             sed -i -e "s|cp -rf|/bin/cp -rf|" iphone/cli/commands/_build.js

     

       29
       29
        
           ''}

     

       30
       30
        
       

     

       31
       31
        
           # Patch some executables

     

       32
       32
        
           

     

       33
       33
       -
           ${if stdenv.system == "i686-linux" then

     

       33
       33
       +
           ${if stdenv.hostPlatform.system == "i686-linux" then

     

       34
       34
        
             ''

     

       35
       35
        
               patchelf --set-interpreter ${stdenv.cc.libc}/lib/ld-linux.so.2 android/titanium_prep.linux32

     

       36
       36
        
             ''

     

       37
       37
       -
             else if stdenv.system == "x86_64-linux" then

     

       37
       37
       +
             else if stdenv.hostPlatform.system == "x86_64-linux" then

     

       38
       38
        
             ''

     

       39
       39
        
               patchelf --set-interpreter ${stdenv.cc.libc}/lib/ld-linux-x86-64.so.2 android/titanium_prep.linux64

     

       40
       40
        
             ''

+5 -5

pkgs/development/mobile/titaniumenv/titaniumsdk-7.1.nix

···

       54
       54
        
       in

     

       55
       55
        
       stdenv.mkDerivation {

     

       56
       56
        
         name = "mobilesdk-7.1.0.GA";

     

       57
       57
       -
         src = if (stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux") then fetchurl {

     

       57
       57
       +
         src = if (stdenv.hostPlatform.system == "i686-linux" || stdenv.hostPlatform.system == "x86_64-linux") then fetchurl {

     

       58
       58
        
           url = http://builds.appcelerator.com/mobile/7_1_X/mobilesdk-7.1.0.v20180314133955-linux.zip;

     

       59
       59
        
           sha256 = "18b3jnr65sdn5wj191bcl48gvhyklxmighxakv4vrz1fb59kyvqn";

     

       60
       60
        
         }

     

       61
       61
       -
         else if stdenv.system == "x86_64-darwin" then fetchurl {

     

       61
       61
       +
         else if stdenv.hostPlatform.system == "x86_64-darwin" then fetchurl {

     

       62
       62
        
           url = http://builds.appcelerator.com/mobile/7_1_X/mobilesdk-7.1.0.v20180314133955-osx.zip;

     

       63
       63
        
           sha256 = "1f62616biwsw1fqxz2sq7lpa6bsfjazffliplyf5dpnh298cnc1m";

     

       64
       64
        
         }

     

       65
       65
       -
         else throw "Platform: ${stdenv.system} not supported!";

     

       65
       65
       +
         else throw "Platform: ${stdenv.hostPlatform.system} not supported!";

     

       66
       66
        
       

     

       67
       67
        
         buildInputs = [ unzip makeWrapper ];

     

       68
       68
        
       

     
···

       89
       89
        
       

     

       90
       90
        
           # Patch some executables

     

       91
       91
        
       

     

       92
       92
       -
           ${if stdenv.system == "i686-linux" then

     

       92
       92
       +
           ${if stdenv.hostPlatform.system == "i686-linux" then

     

       93
       93
        
             ''

     

       94
       94
        
               patchelf --set-interpreter ${stdenv.cc.libc}/lib/ld-linux.so.2 android/titanium_prep.linux32

     

       95
       95
        
             ''

     

       96
       96
       -
             else if stdenv.system == "x86_64-linux" then

     

       96
       96
       +
             else if stdenv.hostPlatform.system == "x86_64-linux" then

     

       97
       97
        
             ''

     

       98
       98
        
               patchelf --set-interpreter ${stdenv.cc.libc}/lib/ld-linux-x86-64.so.2 android/titanium_prep.linux64

     

       99
       99
        
             ''

+3 -2

pkgs/development/node-packages/default-v10.nix

···

       1
       1
       -
       {pkgs, system, nodejs, stdenv}:

     

       1
       1
       +
       { pkgs, nodejs, stdenv }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         nodePackages = import ./composition-v10.nix {

     

       5
       5
       -
           inherit pkgs system nodejs;

     

       5
       5
       +
           inherit pkgs nodejs;

     

       6
       6
       +
           inherit (stdenv.hostPlatform) system;

     

       6
       7
        
         };

     

       7
       8
        
       in

     

       8
       9
        
       nodePackages // {

+3 -2

pkgs/development/node-packages/default-v6.nix

···

       1
       1
       -
       {pkgs, system, nodejs, stdenv}:

     

       1
       1
       +
       { pkgs, nodejs, stdenv }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         nodePackages = import ./composition-v6.nix {

     

       5
       5
       -
           inherit pkgs system nodejs;

     

       5
       5
       +
           inherit pkgs nodejs;

     

       6
       6
       +
           inherit (stdenv.hostPlatform) system;

     

       6
       7
        
         };

     

       7
       8
        
       in

     

       8
       9
        
       nodePackages // {

+3 -2

pkgs/development/node-packages/default-v8.nix

···

       1
       1
       -
       {pkgs, system, nodejs, stdenv}:

     

       1
       1
       +
       { pkgs, nodejs, stdenv }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         nodePackages = import ./composition-v8.nix {

     

       5
       5
       -
           inherit pkgs system nodejs;

     

       5
       5
       +
           inherit pkgs nodejs;

     

       6
       6
       +
           inherit (stdenv.hostPlatform) system;

     

       6
       7
        
         };

     

       7
       8
        
       in

     

       8
       9
        
       nodePackages // {

+1 -1

pkgs/development/ruby-modules/testing/stubs.nix

···

       6
       6
        
           text = (builtins.toJSON (lib.filterAttrs ( n: v: builtins.any (x: x == n) ["name" "system"]) argSet));

     

       7
       7
        
           builder = stdenv.shell;

     

       8
       8
        
           args = [ "-c" "echo  $(<$textPath) > $out"];

     

       9
       9
       -
           system = stdenv.system;

     

       9
       9
       +
           system = stdenv.hostPlatform.system;

     

       10
       10
        
           passAsFile = ["text"];

     

       11
       11
        
         };

     

       12
       12
        
         fetchurl = {url?"", urls ? [],...}: "fetchurl:${if urls == [] then url else builtins.head urls}";

+1 -1

pkgs/development/tools/analysis/cov-build/default.nix

···

       11
       11
        
         version = "7.0.2";

     

       12
       12
        
       

     

       13
       13
        
         src =

     

       14
       14
       -
           if stdenv.system == "i686-linux"

     

       14
       14
       +
           if stdenv.hostPlatform.system == "i686-linux"

     

       15
       15
        
           then requireFile {

     

       16
       16
        
             name = "cov-analysis-linux32-${version}.tar.gz";

     

       17
       17
        
             sha256 = "0i06wbd7blgx9adh9w09by4i18vwmldfp9ix97a5dph2cjymsviy";

+1 -1

pkgs/development/tools/analysis/valgrind/default.nix

···

       57
       57
        
           '';

     

       58
       58
        
       

     

       59
       59
        
         configureFlags =

     

       60
       60
       -
           stdenv.lib.optional (stdenv.system == "x86_64-linux" || stdenv.system == "x86_64-darwin") "--enable-only64bit";

     

       60
       60
       +
           stdenv.lib.optional (stdenv.hostPlatform.system == "x86_64-linux" || stdenv.hostPlatform.system == "x86_64-darwin") "--enable-only64bit";

     

       61
       61
        
       

     

       62
       62
        
         doCheck = false; # fails

     

       63
       63

+2 -2

pkgs/development/tools/electron/default.nix

···

       4
       4
        
         version = "1.8.2";

     

       5
       5
        
         name = "electron-${version}";

     

       6
       6
        
       

     

       7
       7
       -
         throwSystem = throw "Unsupported system: ${stdenv.system}";

     

       7
       7
       +
         throwSystem = throw "Unsupported system: ${stdenv.hostPlatform.system}";

     

       8
       8
        
       

     

       9
       9
        
         meta = with stdenv.lib; {

     

       10
       10
        
           description = "Cross platform desktop application shell";

     
···

       34
       34
        
               url = "https://github.com/electron/electron/releases/download/v${version}/electron-v${version}-linux-arm64.zip";

     

       35
       35
        
               sha256 = "0k4np2d4y15x1qfay8y9m8v9y223vdpbq5fdxa3ywbbyf8j361zd";

     

       36
       36
        
             };

     

       37
       37
       -
           }.${stdenv.system} or throwSystem;

     

       37
       37
       +
           }.${stdenv.hostPlatform.system} or throwSystem;

     

       38
       38
        
       

     

       39
       39
        
           buildInputs = [ unzip makeWrapper ];

     

       40
       40

+3 -3

pkgs/development/tools/github/github-release/default.nix

···

       1
       1
        
       { stdenv, fetchurl }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         linuxPredicate = stdenv.system == "x86_64-linux";

     

       5
       5
       -
         bsdPredicate = stdenv.system == "x86_64-freebsd";

     

       6
       6
       -
         darwinPredicate = stdenv.system == "x86_64-darwin";

     

       4
       4
       +
         linuxPredicate = stdenv.hostPlatform.system == "x86_64-linux";

     

       5
       5
       +
         bsdPredicate = stdenv.hostPlatform.system == "x86_64-freebsd";

     

       6
       6
       +
         darwinPredicate = stdenv.hostPlatform.system == "x86_64-darwin";

     

       7
       7
        
         metadata = assert linuxPredicate || bsdPredicate || darwinPredicate;

     

       8
       8
        
           if linuxPredicate then

     

       9
       9
        
             { arch = "linux-amd64";

+1 -1

pkgs/development/tools/google-app-engine-go-sdk/default.nix

···

       6
       6
        
         name = "google-app-engine-go-sdk-${version}";

     

       7
       7
        
         version = "1.9.61";

     

       8
       8
        
         src =

     

       9
       9
       -
           if stdenv.system == "x86_64-linux" then

     

       9
       9
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       10
       10
        
             fetchzip {

     

       11
       11
        
               url = "https://storage.googleapis.com/appengine-sdks/featured/go_appengine_sdk_linux_amd64-${version}.zip";

     

       12
       12
        
               sha256 = "1i2j9ympl1218akwsmm7yb31v0gibgpzlb657bcravi1irfv1hhs";

+1 -1

pkgs/development/tools/misc/cflow/default.nix

···

       17
       17
        
         buildInputs = [ gettext ] ++

     

       18
       18
        
           # We don't have Emacs/GTK/etc. on {Dar,Cyg}win.

     

       19
       19
        
           stdenv.lib.optional

     

       20
       20
       -
             (! (stdenv.lib.lists.any (x: stdenv.system == x)

     

       20
       20
       +
             (! (stdenv.lib.lists.any (x: stdenv.hostPlatform.system == x)

     

       21
       21
        
                     [ "i686-cygwin" ]))

     

       22
       22
        
             emacs;

     

       23
       23

+5 -5

pkgs/development/tools/misc/iozone/default.nix

···

       1
       1
        
       { stdenv, fetchurl, gnuplot }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         target = if stdenv.system == "i686-linux" then

     

       4
       4
       +
         target = if stdenv.hostPlatform.system == "i686-linux" then

     

       5
       5
        
           "linux"

     

       6
       6
       -
         else if stdenv.system == "x86_64-linux" then

     

       6
       6
       +
         else if stdenv.hostPlatform.system == "x86_64-linux" then

     

       7
       7
        
           "linux-AMD64"

     

       8
       8
       -
         else if stdenv.system == "x86_64-darwin" then

     

       8
       8
       +
         else if stdenv.hostPlatform.system == "x86_64-darwin" then

     

       9
       9
        
           "macosx"

     

       10
       10
       -
         else if stdenv.system == "aarch64-linux" then

     

       10
       10
       +
         else if stdenv.hostPlatform.system == "aarch64-linux" then

     

       11
       11
        
           "linux-arm"

     

       12
       12
       -
         else throw "Platform ${stdenv.system} not yet supported.";

     

       12
       12
       +
         else throw "Platform ${stdenv.hostPlatform.system} not yet supported.";

     

       13
       13
        
       in

     

       14
       14
        
       

     

       15
       15
        
       stdenv.mkDerivation rec {

+2 -2

pkgs/development/tools/misc/kibana/5.x.nix

···

       6
       6
        
         archOverrides = {

     

       7
       7
        
           "i686" = "x86";

     

       8
       8
        
         };

     

       9
       9
       -
         info = splitString "-" stdenv.system;

     

       9
       9
       +
         info = splitString "-" stdenv.hostPlatform.system;

     

       10
       10
        
         arch = (elemAt info 0);

     

       11
       11
        
         elasticArch = archOverrides."${arch}" or arch;

     

       12
       12
        
         plat = elemAt info 1;

     
···

       21
       21
        
       

     

       22
       22
        
         src = fetchurl {

     

       23
       23
        
           url = "https://artifacts.elastic.co/downloads/kibana/${name}-${plat}-${elasticArch}.tar.gz";

     

       24
       24
       -
           sha256 = shas."${stdenv.system}" or (throw "Unknown architecture");

     

       24
       24
       +
           sha256 = shas."${stdenv.hostPlatform.system}" or (throw "Unknown architecture");

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
        
         buildInputs = [ makeWrapper ];

+2 -2

pkgs/development/tools/misc/kibana/default.nix

···

       12
       12
        
       with stdenv.lib;

     

       13
       13
        
       let

     

       14
       14
        
         inherit (builtins) elemAt;

     

       15
       15
       -
         info = splitString "-" stdenv.system;

     

       15
       15
       +
         info = splitString "-" stdenv.hostPlatform.system;

     

       16
       16
        
         arch = elemAt info 0;

     

       17
       17
        
         plat = elemAt info 1;

     

       18
       18
        
         shas =

     
···

       44
       44
        
       

     

       45
       45
        
         src = fetchurl {

     

       46
       46
        
           url = "https://artifacts.elastic.co/downloads/kibana/${name}-${plat}-${arch}.tar.gz";

     

       47
       47
       -
           sha256 = shas."${stdenv.system}" or (throw "Unknown architecture");

     

       47
       47
       +
           sha256 = shas."${stdenv.hostPlatform.system}" or (throw "Unknown architecture");

     

       48
       48
        
         };

     

       49
       49
        
       

     

       50
       50
        
         buildInputs = [ makeWrapper ];

+1 -1

pkgs/development/tools/misc/lsof/default.nix

···

       1
       1
        
       { stdenv, fetchurl, buildPackages, ncurses }:

     

       2
       2
        
       

     

       3
       3
       -
       let dialect = with stdenv.lib; last (splitString "-" stdenv.system); in

     

       3
       3
       +
       let dialect = with stdenv.lib; last (splitString "-" stdenv.hostPlatform.system); in

     

       4
       4
        
       

     

       5
       5
        
       stdenv.mkDerivation rec {

     

       6
       6
        
         name = "lsof-${version}";

+2 -2

pkgs/development/tools/misc/saleae-logic/default.nix

···

       27
       27
        
         name = "${pname}-${version}";

     

       28
       28
        
       

     

       29
       29
        
         src =

     

       30
       30
       -
           if stdenv.system == "i686-linux" then

     

       30
       30
       +
           if stdenv.hostPlatform.system == "i686-linux" then

     

       31
       31
        
             fetchurl {

     

       32
       32
        
               name = "saleae-logic-${version}-32bit.zip";

     

       33
       33
        
               url = "http://downloads.saleae.com/logic/${version}/Logic%20${version}%20(32-bit).zip";

     

       34
       34
        
               sha256 = "1dyrj07cgj2fvwi1sk97vady9ri8f8n7mxy9zyzmw9isngs7bmll";

     

       35
       35
        
             }

     

       36
       36
       -
           else if stdenv.system == "x86_64-linux" then

     

       36
       36
       +
           else if stdenv.hostPlatform.system == "x86_64-linux" then

     

       37
       37
        
             fetchurl {

     

       38
       38
        
               name = "saleae-logic-${version}-64bit.zip";

     

       39
       39
        
               url = "http://downloads.saleae.com/logic/${version}/Logic%20${version}%20(64-bit).zip";

+1 -1

pkgs/development/tools/neoload/default.nix

···

       34
       34
        
         name = "neoload-4.1.4";

     

       35
       35
        
       

     

       36
       36
        
         src = fetchurl (

     

       37
       37
       -
           if stdenv.system == "x86_64-linux" then

     

       37
       37
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       38
       38
        
             { url = http://neoload.installers.neotys.com/documents/download/neoload/v4.1/neoload_4_1_4_linux_x64.sh;

     

       39
       39
        
               sha256 = "199jcf5a0nwfm8wfld2rcjgq64g91vvz2bkmki8dxfzf1yasifcd"; }

     

       40
       40
        
           else

+1 -1

pkgs/development/tools/node-webkit/nw12.nix

···

       3
       3
        
       , gdk_pixbuf, cairo, nss, nspr, gconf, expat, systemd, libcap

     

       4
       4
        
       , libnotify}:

     

       5
       5
        
       let

     

       6
       6
       -
         bits = if stdenv.system == "x86_64-linux" then "x64"

     

       6
       6
       +
         bits = if stdenv.hostPlatform.system == "x86_64-linux" then "x64"

     

       7
       7
        
                else "ia32";

     

       8
       8
        
       

     

       9
       9
        
         nwEnv = buildEnv {

+1 -1

pkgs/development/tools/nwjs/default.nix

···

       7
       7
        
       , sqlite, udev

     

       8
       8
        
       }:

     

       9
       9
        
       let

     

       10
       10
       -
         bits = if stdenv.system == "x86_64-linux" then "x64"

     

       10
       10
       +
         bits = if stdenv.hostPlatform.system == "x86_64-linux" then "x64"

     

       11
       11
        
                else "ia32";

     

       12
       12
        
       

     

       13
       13
        
         nwEnv = buildEnv {

+2 -2

pkgs/development/tools/phantomjs/default.nix

···

       12
       12
        
         # because it has bundled a lot of external libraries (like QT and Webkit)

     

       13
       13
        
         # and no easy/nice way to use the system versions of these

     

       14
       14
        
       

     

       15
       15
       -
         src = if stdenv.system == "i686-linux" then

     

       15
       15
       +
         src = if stdenv.hostPlatform.system == "i686-linux" then

     

       16
       16
        
                 fetchurl {

     

       17
       17
        
                   url = "https://bitbucket.org/ariya/phantomjs/downloads/${name}-linux-i686.tar.bz2";

     

       18
       18
        
                   sha256 = "11fzmssz9pqf3arh4f36w06sl2nyz8l9h8iyxyd7w5aqnq5la0j1";

     

       19
       19
        
                 }

     

       20
       20
        
               else

     

       21
       21
       -
                 if stdenv.system == "x86_64-linux" then

     

       21
       21
       +
                 if stdenv.hostPlatform.system == "x86_64-linux" then

     

       22
       22
        
                   fetchurl {

     

       23
       23
        
                     url = "https://bitbucket.org/ariya/phantomjs/downloads/${name}-linux-x86_64.tar.bz2";

     

       24
       24
        
                     sha256 = "0fhnqxxsxhy125fmif1lwgnlhfx908spy7fx9mng4w72320n5nd1";

+2 -2

pkgs/development/tools/sauce-connect/default.nix

···

       7
       7
        
         version = "4.4.12";

     

       8
       8
        
       

     

       9
       9
        
         src = fetchurl (

     

       10
       10
       -
           if stdenv.system == "x86_64-linux" then {

     

       10
       10
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then {

     

       11
       11
        
             url = "https://saucelabs.com/downloads/sc-${version}-linux.tar.gz";

     

       12
       12
        
             sha256 = "1yqvx64bgiq27hdhwkzgmzyib8pbjn1idpq6783srxq64asf6iyw";

     

       13
       13
       -
           } else if stdenv.system == "i686-linux" then {

     

       13
       13
       +
           } else if stdenv.hostPlatform.system == "i686-linux" then {

     

       14
       14
        
             url = "https://saucelabs.com/downloads/sc-${version}-linux32.tar.gz";

     

       15
       15
        
             sha256 = "02kib56lv4lhwkj5r15484lvvbyjvf9ydi5vccsmxgsxrzmddnl6";

     

       16
       16
        
           } else {

+2 -2

pkgs/development/tools/selenium/chromedriver/default.nix

···

       15
       15
        
           };

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
       -
         spec = allSpecs."${stdenv.system}"

     

       19
       19
       -
           or (throw "missing chromedriver binary for ${stdenv.system}");

     

       18
       18
       +
         spec = allSpecs."${stdenv.hostPlatform.system}"

     

       19
       19
       +
           or (throw "missing chromedriver binary for ${stdenv.hostPlatform.system}");

     

       20
       20
        
       

     

       21
       21
        
         libs = stdenv.lib.makeLibraryPath [

     

       22
       22
        
           stdenv.cc.cc.lib

+1 -1

pkgs/development/web/remarkjs/default.nix

···

       13
       13
        
         

     

       14
       14
        
         nodePackages = import ./nodepkgs.nix {

     

       15
       15
        
           inherit pkgs;

     

       16
       16
       -
           inherit (stdenv) system;

     

       16
       16
       +
           inherit (stdenv.hostPlatform) system;

     

       17
       17
        
         };

     

       18
       18
        
       

     

       19
       19
        
       in stdenv.mkDerivation rec {

+4 -4

pkgs/games/andyetitmoves/default.nix

···

       7
       7
        
       stdenv.mkDerivation rec {

     

       8
       8
        
         name = "${plainName}-${version}";

     

       9
       9
        
       

     

       10
       10
       -
         src = if stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux"

     

       10
       10
       +
         src = if stdenv.hostPlatform.system == "i686-linux" || stdenv.hostPlatform.system == "x86_64-linux"

     

       11
       11
        
           then

     

       12
       12
       -
             let postfix        = if stdenv.system == "i686-linux" then "i386" else "x86_64";

     

       12
       12
       +
             let postfix        = if stdenv.hostPlatform.system == "i686-linux" then "i386" else "x86_64";

     

       13
       13
        
                 commercialName = "${plainName}-${version}_${postfix}.tar.gz";

     

       14
       14
        
                 demoUrl        = "http://www.andyetitmoves.net/demo/${plainName}Demo-${version}_${postfix}.tar.gz";

     

       15
       15
        
             in

     
···

       22
       22
        
                        directory where yousaved it.

     

       23
       23
        
                      '';

     

       24
       24
        
                      name = commercialName;

     

       25
       25
       -
                      sha256 = if stdenv.system == "i686-linux"

     

       25
       25
       +
                      sha256 = if stdenv.hostPlatform.system == "i686-linux"

     

       26
       26
        
                                 then "15wvzmmidvykwjrbnq70h5jrvnjx1hcrm0357qj85q4aqbzavh01"

     

       27
       27
        
                                 else "1v8z16qa9ka8sf7qq45knsxj87s6sipvv3a7xq11pb5xk08fb2ql";

     

       28
       28
        
                    }

     

       29
       29
        
               else fetchurl {

     

       30
       30
        
                      url = demoUrl;

     

       31
       31
       -
                      sha256 = if stdenv.system == "i686-linux"

     

       31
       31
       +
                      sha256 = if stdenv.hostPlatform.system == "i686-linux"

     

       32
       32
        
                                 then "0f14vrrbq05hsbdajrb5y9za65fpng1lc8f0adb4aaz27x7sh525"

     

       33
       33
        
                                 else "0mg41ya0b27blq3b5498kwl4rj46dj21rcd7qd0rw1kyvr7sx4v4";

     

       34
       34
        
                    }

+2 -2

pkgs/games/dwarf-fortress/dfhack/default.nix

···

       13
       13
        
         xmlRev = "23500e4e9bd1885365d0a2ef1746c321c1dd5094";

     

       14
       14
        
       

     

       15
       15
        
         arch =

     

       16
       16
       -
           if stdenv.system == "x86_64-linux" then "64"

     

       17
       17
       -
           else if stdenv.system == "i686-linux" then "32"

     

       16
       16
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then "64"

     

       17
       17
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "32"

     

       18
       18
        
           else throw "Unsupported architecture";

     

       19
       19
        
       

     

       20
       20
        
         fakegit = writeScriptBin "git" ''

+3 -3

pkgs/games/dwarf-fortress/game.nix

···

       33
       33
        
         game = if hasAttr dfVersion df-hashes

     

       34
       34
        
                then getAttr dfVersion df-hashes

     

       35
       35
        
                else throw "Unknown Dwarf Fortress version: ${dfVersion}";

     

       36
       36
       -
         dfPlatform = if hasAttr stdenv.system platforms

     

       37
       37
       -
                      then getAttr stdenv.system platforms

     

       38
       38
       -
                      else throw "Unsupported system: ${stdenv.system}";

     

       36
       36
       +
         dfPlatform = if hasAttr stdenv.hostPlatform.system platforms

     

       37
       37
       +
                      then getAttr stdenv.hostPlatform.system platforms

     

       38
       38
       +
                      else throw "Unsupported system: ${stdenv.hostPlatform.system}";

     

       39
       39
        
         sha256 = if hasAttr dfPlatform game

     

       40
       40
        
                  then getAttr dfPlatform game

     

       41
       41
        
                  else throw "Unsupported dfPlatform: ${dfPlatform}";

+1 -1

pkgs/games/eduke32/default.nix

···

       15
       15
        
         };

     

       16
       16
        
       

     

       17
       17
        
         buildInputs = [ flac gtk2 libvorbis libvpx libGLU_combined SDL2 SDL2_mixer ]

     

       18
       18
       -
           ++ stdenv.lib.optional (stdenv.system == "i686-linux") nasm;

     

       18
       18
       +
           ++ stdenv.lib.optional (stdenv.hostPlatform.system == "i686-linux") nasm;

     

       19
       19
        
         nativeBuildInputs = [ pkgconfig ];

     

       20
       20
        
       

     

       21
       21
        
         postPatch = ''

+2 -2

pkgs/games/ezquake/default.nix

···

       20
       20
        
         ];

     

       21
       21
        
       

     

       22
       22
        
         installPhase = with stdenv.lib; let

     

       23
       23
       -
           sys = last (splitString "-" stdenv.system);

     

       24
       24
       -
           arch = head (splitString "-" stdenv.system);

     

       23
       23
       +
           sys = last (splitString "-" stdenv.hostPlatform.system);

     

       24
       24
       +
           arch = head (splitString "-" stdenv.hostPlatform.system);

     

       25
       25
        
         in ''

     

       26
       26
        
           mkdir -p $out/bin

     

       27
       27
        
           find .

+1 -1

pkgs/games/factorio/default.nix

···

       46
       46
        
             };

     

       47
       47
        
           };

     

       48
       48
        
         };

     

       49
       49
       -
         actual = binDists.${stdenv.system}.${releaseType}.${branch} or (throw "Factorio: unsupported platform");

     

       49
       49
       +
         actual = binDists.${stdenv.hostPlatform.system}.${releaseType}.${branch} or (throw "Factorio: unsupported platform");

     

       50
       50
        
       

     

       51
       51
        
         bdistForArch = arch: { sha256 ? null

     

       52
       52
        
                              , version ? "0.16.51"

+1 -1

pkgs/games/nethack/default.nix

···

       6
       6
        
       let

     

       7
       7
        
         platform =

     

       8
       8
        
           if stdenv.hostPlatform.isUnix then "unix"

     

       9
       9
       -
           else throw "Unknown platform for NetHack: ${stdenv.system}";

     

       9
       9
       +
           else throw "Unknown platform for NetHack: ${stdenv.hostPlatform.system}";

     

       10
       10
        
         unixHint =

     

       11
       11
        
           if x11Mode then "linux-x11"

     

       12
       12
        
           else if qtMode then "linux-qt4"

+2 -2

pkgs/games/oilrush/default.nix

···

       13
       13
        
           assert url != null && sha256 != null;

     

       14
       14
        
           fetchurl { inherit url sha256; };

     

       15
       15
        
         shell = stdenv.shell;

     

       16
       16
       -
         arch = if stdenv.system == "x86_64-linux" then "x64"

     

       17
       17
       -
                else if stdenv.system == "i686-linux" then "x86"

     

       16
       16
       +
         arch = if stdenv.hostPlatform.system == "x86_64-linux" then "x64"

     

       17
       17
       +
                else if stdenv.hostPlatform.system == "i686-linux" then "x86"

     

       18
       18
        
                else "";

     

       19
       19
        
         unpackPhase = ''

     

       20
       20
        
           mkdir oilrush

+1 -1

pkgs/games/openarena/default.nix

···

       21
       21
        
           cd $out

     

       22
       22
        
           unzip $src

     

       23
       23
        
       

     

       24
       24
       -
           ${if stdenv.system == "x86_64-linux" then ''

     

       24
       24
       +
           ${if stdenv.hostPlatform.system == "x86_64-linux" then ''

     

       25
       25
        
             patchelf --set-interpreter "${interpreter}" "${gameDir}/openarena.x86_64"

     

       26
       26
        
             makeWrapper "${gameDir}/openarena.x86_64" "$out/bin/openarena" \

     

       27
       27
        
               --prefix LD_LIBRARY_PATH : "${libPath}"

+2 -2

pkgs/games/racer/default.nix

···

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         name = "racer-1.1";

     

       5
       5
        
       

     

       6
       6
       -
         src = if stdenv.system == "i686-linux" then fetchurl {

     

       6
       6
       +
         src = if stdenv.hostPlatform.system == "i686-linux" then fetchurl {

     

       7
       7
        
           url = http://hippo.nipax.cz/src/racer-1.1.tar.gz;

     

       8
       8
        
           sha256 = "0fll1qkqfcjq87k0jzsilcw701z92lfxn2y5ga1n038772lymxl9";

     

       9
       9
       -
         } else if stdenv.system == "x86_64-linux" then fetchurl {

     

       9
       9
       +
         } else if stdenv.hostPlatform.system == "x86_64-linux" then fetchurl {

     

       10
       10
        
           url = https://hippo.nipax.cz/src/racer-1.1.64.tar.gz;

     

       11
       11
        
           sha256 = "0rjy3gmlhwfkb9zs58j0mc0dar0livwpbc19r6zw5r2k6r7xdan0";

     

       12
       12
        
         } else

+1 -1

pkgs/games/sdlmame/default.nix

···

       4
       4
        
         version = "0.151.u0-1";

     

       5
       5
        
         name    = "sdlmame-${version}";

     

       6
       6
        
       

     

       7
       7
       -
         src = if stdenv.system == "x86_64-linux"

     

       7
       7
       +
         src = if stdenv.hostPlatform.system == "x86_64-linux"

     

       8
       8
        
           then fetchurl {

     

       9
       9
        
             url    = "http://seblu.net/a/archive/packages/s/sdlmame/${name}-x86_64.pkg.tar.xz";

     

       10
       10
        
             sha256 = "1j9vjxhrhsskrlk5wr7al4wk2hh3983kcva42mqal09bmc8qg3m9";

+3 -3

pkgs/games/steam/default.nix

···

       4
       4
        
         callPackage = newScope self;

     

       5
       5
        
       

     

       6
       6
        
         self = rec {

     

       7
       7
       -
           steamArch = if pkgs.stdenv.system == "x86_64-linux" then "amd64"

     

       8
       8
       -
                       else if pkgs.stdenv.system == "i686-linux" then "i386"

     

       9
       9
       -
                       else throw "Unsupported platform: ${pkgs.stdenv.system}";

     

       7
       7
       +
           steamArch = if pkgs.stdenv.hostPlatform.system == "x86_64-linux" then "amd64"

     

       8
       8
       +
                       else if pkgs.stdenv.hostPlatform.system == "i686-linux" then "i386"

     

       9
       9
       +
                       else throw "Unsupported platform: ${pkgs.stdenv.hostPlatform.system}";

     

       10
       10
        
       

     

       11
       11
        
           steam-runtime = callPackage ./runtime.nix { };

     

       12
       12
        
           steam-runtime-wrapped = callPackage ./runtime-wrapped.nix { };

+2 -2

pkgs/games/ut2004/demo.nix

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         arch =

     

       5
       5
       -
           if stdenv.system == "x86_64-linux" then "amd64"

     

       6
       6
       -
           else if stdenv.system == "i686-linux" then "x86"

     

       5
       5
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then "amd64"

     

       6
       6
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "x86"

     

       7
       7
        
           else throw "Unsupported architecture";

     

       8
       8
        
       

     

       9
       9
        
       in stdenv.mkDerivation rec {

+1 -1

pkgs/games/vessel/default.nix

···

       15
       15
        
             message = goBuyItNow;

     

       16
       16
        
             name = "${name}-bin";

     

       17
       17
        
             sha256 = "1vpwcrjiln2mx43h7ib3jnccyr3chk7a5x2bw9kb4lw8ycygvg96";

     

       18
       18
       -
           } else throw "unsupported platform ${stdenv.system} only i686-linux supported for now.";

     

       18
       18
       +
           } else throw "unsupported platform ${stdenv.hostPlatform.system} only i686-linux supported for now.";

     

       19
       19
        
       

     

       20
       20
        
         phases = "installPhase";

     

       21
       21
        
         ld_preload = ./isatty.c;

+1 -1

pkgs/games/worldofgoo/default.nix

···

       9
       9
        
           then "WorldOfGooDemo-1.41"

     

       10
       10
        
           else "WorldofGoo-1.41";

     

       11
       11
        
       

     

       12
       12
       -
         arch = if stdenv.system == "x86_64-linux" then "supported"

     

       12
       12
       +
         arch = if stdenv.hostPlatform.system == "x86_64-linux" then "supported"

     

       13
       13
        
           else throw "Sorry. World of Goo only is only supported on x86_64 now.";

     

       14
       14
        
       

     

       15
       15
        
         goBuyItNow = ''

+1 -1

pkgs/games/zandronum/fmod.nix

···

       1
       1
        
       { stdenv, lib, fetchurl, alsaLib, libpulseaudio, undmg }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         bits = stdenv.lib.optionalString (stdenv.system == "x86_64-linux") "64";

     

       4
       4
       +
         bits = stdenv.lib.optionalString (stdenv.hostPlatform.system == "x86_64-linux") "64";

     

       5
       5
        
         libPath = lib.makeLibraryPath [ stdenv.cc.cc alsaLib libpulseaudio ];

     

       6
       6
        
       

     

       7
       7
        
       in

+1 -1

pkgs/misc/base16-builder/default.nix

···

       11
       11
        
         #

     

       12
       12
        
         nodePackages = import ./node-packages.nix {

     

       13
       13
        
           inherit pkgs;

     

       14
       14
       -
           inherit (stdenv) system;

     

       14
       14
       +
           inherit (stdenv.hostPlatform) system;

     

       15
       15
        
         };

     

       16
       16
        
       in nodePackages.base16-builder

+3 -3

pkgs/misc/cups/drivers/cnijfilter_4_00/default.nix

···

       7
       7
        
          file included in the tarball */

     

       8
       8
        
       

     

       9
       9
        
       let arch = 

     

       10
       10
       -
         if stdenv.system == "x86_64-linux" then "64"

     

       11
       11
       -
           else if stdenv.system == "i686-linux" then "32"

     

       12
       12
       -
           else throw "Unsupported system ${stdenv.system}";

     

       10
       10
       +
         if stdenv.hostPlatform.system == "x86_64-linux" then "64"

     

       11
       11
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "32"

     

       12
       12
       +
           else throw "Unsupported system ${stdenv.hostPlatform.system}";

     

       13
       13
        
       

     

       14
       14
        
       in stdenv.mkDerivation rec {

     

       15
       15
        
         name = "cnijfilter-${version}";

+3 -3

pkgs/misc/cups/drivers/kyocera/default.nix

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         platform =

     

       5
       5
       -
           if stdenv.system == "x86_64-linux" then "64bit"

     

       6
       6
       -
           else if stdenv.system == "i686-linux" then "32bit"

     

       7
       7
       -
                else throw "Unsupported system: ${stdenv.system}";

     

       5
       5
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then "64bit"

     

       6
       6
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "32bit"

     

       7
       7
       +
                else throw "Unsupported system: ${stdenv.hostPlatform.system}";

     

       8
       8
        
       

     

       9
       9
        
         libPath = lib.makeLibraryPath [ cups ];

     

       10
       10
        
       in

+3 -3

pkgs/misc/cups/drivers/kyodialog3/default.nix

···

       6
       6
        
       

     

       7
       7
        
       let

     

       8
       8
        
         platform =

     

       9
       9
       -
           if stdenv.system == "x86_64-linux" then "64bit"

     

       10
       10
       -
           else if stdenv.system == "i686-linux" then "32bit"

     

       11
       11
       -
                else throw "Unsupported system: ${stdenv.system}";

     

       9
       9
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then "64bit"

     

       10
       10
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "32bit"

     

       11
       11
       +
                else throw "Unsupported system: ${stdenv.hostPlatform.system}";

     

       12
       12
        
         debPlatform =

     

       13
       13
        
           if platform == "64bit" then "amd64"

     

       14
       14
        
           else "i386";

+2 -2

pkgs/misc/cups/drivers/samsung/4.01.17.nix

···

       16
       16
        
       # Do not bump lightly! Visit <http://www.bchemnet.com/suldr/supported.html>

     

       17
       17
        
       # to see what will break when upgrading. Consider a new versioned attribute.

     

       18
       18
        
       let

     

       19
       19
       -
         installationPath = if stdenv.system == "x86_64-linux" then "x86_64" else "i386";

     

       20
       20
       -
         appendPath = if stdenv.system == "x86_64-linux" then "64" else "";

     

       19
       19
       +
         installationPath = if stdenv.hostPlatform.system == "x86_64-linux" then "x86_64" else "i386";

     

       20
       20
       +
         appendPath = if stdenv.hostPlatform.system == "x86_64-linux" then "64" else "";

     

       21
       21
        
         libPath = stdenv.lib.makeLibraryPath [ cups libusb ] + ":$out/lib:${stdenv.cc.cc.lib}/lib${appendPath}";

     

       22
       22
        
       in stdenv.mkDerivation rec {

     

       23
       23
        
         name = "samsung-UnifiedLinuxDriver-${version}";

+1 -1

pkgs/misc/cups/drivers/samsung/default.nix

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
       

     

       5
       5
       -
           arch = if stdenv.system == "x86_64-linux"

     

       5
       5
       +
           arch = if stdenv.hostPlatform.system == "x86_64-linux"

     

       6
       6
        
             then "x86_64"

     

       7
       7
        
             else "i386";

     

       8
       8

+1 -1

pkgs/misc/drivers/gutenprint/bin.nix

···

       27
       27
        
       stdenv.mkDerivation {

     

       28
       28
        
         name = "cups-gutenprint-binary-5.0.1";

     

       29
       29
        
       

     

       30
       30
       -
         src = if stdenv.system == "x86_64-linux" then fetchurl {

     

       30
       30
       +
         src = if stdenv.hostPlatform.system == "x86_64-linux" then fetchurl {

     

       31
       31
        
           url = https://www.openprinting.org/download/printdriver/debian/dists/lsb3.1/main/binary-amd64/gutenprint_5.0.1-1lsb3.1_amd64.deb;

     

       32
       32
        
           sha256 = "0an5gba6r6v54r53s2gj2fjk8fzpl4lrksjas2333528b0k8gbbc";

     

       33
       33
        
         } else throw "TODO"; # get from openprint.com -> drivers -> gutenprint

+3 -3

pkgs/misc/drivers/hplip/3.16.11.nix

···

       34
       34
        
           "armv7l-linux" = "arm32";

     

       35
       35
        
         };

     

       36
       36
        
       

     

       37
       37
       -
         hplipArch = hplipPlatforms."${stdenv.system}"

     

       38
       38
       -
           or (throw "HPLIP not supported on ${stdenv.system}");

     

       37
       37
       +
         hplipArch = hplipPlatforms."${stdenv.hostPlatform.system}"

     

       38
       38
       +
           or (throw "HPLIP not supported on ${stdenv.hostPlatform.system}");

     

       39
       39
        
       

     

       40
       40
        
         pluginArches = [ "x86_32" "x86_64" "arm32" ];

     

       41
       41
        
       

     

       42
       42
        
       in

     

       43
       43
        
       

     

       44
       44
        
       assert withPlugin -> builtins.elem hplipArch pluginArches

     

       45
       45
       -
         || throw "HPLIP plugin not supported on ${stdenv.system}";

     

       45
       45
       +
         || throw "HPLIP plugin not supported on ${stdenv.hostPlatform.system}";

     

       46
       46
        
       

     

       47
       47
        
       pythonPackages.buildPythonApplication {

     

       48
       48
        
         inherit name src;

+3 -3

pkgs/misc/drivers/hplip/default.nix

···

       36
       36
        
           "armv7l-linux" = "arm32";

     

       37
       37
        
         };

     

       38
       38
        
       

     

       39
       39
       -
         hplipArch = hplipPlatforms."${stdenv.system}"

     

       40
       40
       -
           or (throw "HPLIP not supported on ${stdenv.system}");

     

       39
       39
       +
         hplipArch = hplipPlatforms."${stdenv.hostPlatform.system}"

     

       40
       40
       +
           or (throw "HPLIP not supported on ${stdenv.hostPlatform.system}");

     

       41
       41
        
       

     

       42
       42
        
         pluginArches = [ "x86_32" "x86_64" "arm32" ];

     

       43
       43
        
       

     

       44
       44
        
       in

     

       45
       45
        
       

     

       46
       46
        
       assert withPlugin -> builtins.elem hplipArch pluginArches

     

       47
       47
       -
         || throw "HPLIP plugin not supported on ${stdenv.system}";

     

       47
       47
       +
         || throw "HPLIP plugin not supported on ${stdenv.hostPlatform.system}";

     

       48
       48
        
       

     

       49
       49
        
       pythonPackages.buildPythonApplication {

     

       50
       50
        
         inherit name src;

+2 -2

pkgs/misc/emulators/retroarch/cores.nix

···

       272
       272
        
       

     

       273
       273
        
           extraBuildInputs = [ libGLU_combined libpng ];

     

       274
       274
        
         }).override {

     

       275
       275
       -
           buildPhase = "make WITH_DYNAREC=${if stdenv.system == "x86_64-linux" then "x86_64" else "x86"}";

     

       275
       275
       +
           buildPhase = "make WITH_DYNAREC=${if stdenv.hostPlatform.system == "x86_64-linux" then "x86_64" else "x86"}";

     

       276
       276
        
         };

     

       277
       277
        
       

     

       278
       278
        
         nestopia = (mkLibRetroCore rec {

     
···

       300
       300
        
       

     

       301
       301
        
           extraBuildInputs = [ libGLU_combined libpng ];

     

       302
       302
        
         }).override {

     

       303
       303
       -
           buildPhase = "make WITH_DYNAREC=${if stdenv.system == "x86_64-linux" then "x86_64" else "x86"}";

     

       303
       303
       +
           buildPhase = "make WITH_DYNAREC=${if stdenv.hostPlatform.system == "x86_64-linux" then "x86_64" else "x86"}";

     

       304
       304
        
         };

     

       305
       305
        
       

     

       306
       306
        
         picodrive = (mkLibRetroCore rec {

+2 -2

pkgs/misc/emulators/wine/default.nix

···

       6
       6
        
       # };

     

       7
       7
        
       # Make additional configurations on demand:

     

       8
       8
        
       # wine.override { wineBuild = "wine32"; wineRelease = "staging"; };

     

       9
       9
       -
       { lib, system, callPackage,

     

       9
       9
       +
       { lib, stdenv, callPackage,

     

       10
       10
        
         wineRelease ? "stable",

     

       11
       11
       -
         wineBuild ? (if system == "x86_64-linux" then "wineWow" else "wine32"),

     

       11
       11
       +
         wineBuild ? if stdenv.hostPlatform.system == "x86_64-linux" then "wineWow" else "wine32",

     

       12
       12
        
         libtxc_dxtn_Name ? "libtxc_dxtn_s2tc",

     

       13
       13
        
         pngSupport ? false,

     

       14
       14
        
         jpegSupport ? false,

+1 -1

pkgs/os-specific/linux/alsa-plugins/wrapper.nix

···

       1
       1
        
       { writeScriptBin, stdenv, alsaPlugins }:

     

       2
       2
       -
       writeScriptBin "ap${if stdenv.system == "i686-linux" then "32" else "64"}" ''

     

       2
       2
       +
       writeScriptBin "ap${if stdenv.hostPlatform.system == "i686-linux" then "32" else "64"}" ''

     

       3
       3
        
         #/bin/sh

     

       4
       4
        
         ALSA_PLUGIN_DIRS=${alsaPlugins}/lib/alsa-lib "$@"

     

       5
       5
        
       ''

+2 -2

pkgs/os-specific/linux/amdgpu-pro/default.nix

···

       16
       16
        
         bitness = if stdenv.is64bit then "64" else "32";

     

       17
       17
        
       

     

       18
       18
        
         libArch =

     

       19
       19
       -
           if stdenv.system == "i686-linux" then

     

       19
       19
       +
           if stdenv.hostPlatform.system == "i686-linux" then

     

       20
       20
        
             "i386-linux-gnu"

     

       21
       21
       -
           else if stdenv.system == "x86_64-linux" then

     

       21
       21
       +
           else if stdenv.hostPlatform.system == "x86_64-linux" then

     

       22
       22
        
             "x86_64-linux-gnu"

     

       23
       23
        
           else throw "amdgpu-pro is Linux only. Sorry. The build was stopped.";

     

       24
       24

+2 -2

pkgs/os-specific/linux/ati-drivers/default.nix

···

       37
       37
        
         build = "15.302";

     

       38
       38
        
       

     

       39
       39
        
         linuxonly =

     

       40
       40
       -
           if stdenv.system == "i686-linux" then

     

       40
       40
       +
           if stdenv.hostPlatform.system == "i686-linux" then

     

       41
       41
        
             true

     

       42
       42
       -
           else if stdenv.system == "x86_64-linux" then

     

       42
       42
       +
           else if stdenv.hostPlatform.system == "x86_64-linux" then

     

       43
       43
        
             true

     

       44
       44
        
           else throw "ati-drivers are Linux only. Sorry. The build was stopped.";

     

       45
       45

+2 -2

pkgs/os-specific/linux/broadcom-sta/default.nix

···

       7
       7
        
           x86_64-linux = "1gj485qqr190idilacpxwgqyw21il03zph2rddizgj7fbd6pfyaz";

     

       8
       8
        
         };

     

       9
       9
        
       

     

       10
       10
       -
         arch = stdenv.lib.optionalString (stdenv.system == "x86_64-linux") "_64";

     

       10
       10
       +
         arch = stdenv.lib.optionalString (stdenv.hostPlatform.system == "x86_64-linux") "_64";

     

       11
       11
        
         tarballVersion = stdenv.lib.replaceStrings ["."] ["_"] version;

     

       12
       12
        
         tarball = "hybrid-v35${arch}-nodebug-pcoem-${tarballVersion}.tar.gz";

     

       13
       13
        
       in

     
···

       16
       16
        
       

     

       17
       17
        
         src = fetchurl {

     

       18
       18
        
           url = "https://docs.broadcom.com/docs-and-downloads/docs/linux_sta/${tarball}";

     

       19
       19
       -
           sha256 = hashes.${stdenv.system} or (throw "Unsupported system: ${stdenv.system}");

     

       19
       19
       +
           sha256 = hashes.${stdenv.hostPlatform.system} or (throw "Unsupported system: ${stdenv.hostPlatform.system}");

     

       20
       20
        
         };

     

       21
       21
        
       

     

       22
       22
        
         hardeningDisable = [ "pic" ];

+2 -2

pkgs/os-specific/linux/displaylink/default.nix

···

       3
       3
        
       

     

       4
       4
        
       let

     

       5
       5
        
         arch =

     

       6
       6
       -
           if stdenv.system == "x86_64-linux" then "x64"

     

       7
       7
       -
           else if stdenv.system == "i686-linux" then "x86"

     

       6
       6
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then "x64"

     

       7
       7
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "x86"

     

       8
       8
        
           else throw "Unsupported architecture";

     

       9
       9
        
         bins = "${arch}-ubuntu-1604";

     

       10
       10
        
         libPath = lib.makeLibraryPath [ stdenv.cc.cc utillinux libusb1 evdi ];

+1 -1

pkgs/os-specific/linux/fusionio/util.nix

···

       39
       39
        
           description = "Fusionio command line utilities";

     

       40
       40
        
           license = licenses.unfree;

     

       41
       41
        
           platforms = [ "x86_64-linux" ];

     

       42
       42
       -
           broken = stdenv.system != "x86_64-linux";

     

       42
       42
       +
           broken = stdenv.hostPlatform.system != "x86_64-linux";

     

       43
       43
        
           maintainers = with maintainers; [ wkennington ];

     

       44
       44
        
         };

     

       45
       45
        
       }

+1 -1

pkgs/os-specific/linux/fusionio/vsl.nix

···

       33
       33
        
           description = "Kernel driver for accessing fusion-io cards";

     

       34
       34
        
           license = licenses.unfree;

     

       35
       35
        
           platforms = [ "x86_64-linux" ];

     

       36
       36
       -
           broken = stdenv.system != "x86_64-linux";

     

       36
       36
       +
           broken = stdenv.hostPlatform.system != "x86_64-linux";

     

       37
       37
        
           maintainers = with maintainers; [ wkennington ];

     

       38
       38
        
         };

     

       39
       39
        
       }

+3 -3

pkgs/os-specific/linux/kernel/common-config.nix

···

       114
       114
        
             IP_DCCP_CCID3      = no; # experimental

     

       115
       115
        
             CLS_U32_PERF       = yes;

     

       116
       116
        
             CLS_U32_MARK       = yes;

     

       117
       117
       -
             BPF_JIT            = when (stdenv.system == "x86_64-linux") yes;

     

       117
       117
       +
             BPF_JIT            = when (stdenv.hostPlatform.system == "x86_64-linux") yes;

     

       118
       118
        
             WAN                = yes;

     

       119
       119
        
             # Required by systemd per-cgroup firewalling

     

       120
       120
        
             CGROUP_BPF                  = option yes;

     
···

       184
       184
        
             FB_VESA             = yes;

     

       185
       185
        
             FRAMEBUFFER_CONSOLE = yes;

     

       186
       186
        
             FRAMEBUFFER_CONSOLE_ROTATION = yes;

     

       187
       187
       -
             FB_GEODE            = when (stdenv.system == "i686-linux") yes;

     

       187
       187
       +
             FB_GEODE            = when (stdenv.hostPlatform.system == "i686-linux") yes;

     

       188
       188
        
           };

     

       189
       189
        
       

     

       190
       190
        
           video = {

     
···

       497
       497
        
           };

     

       498
       498
        
       

     

       499
       499
        
           # Support x2APIC (which requires IRQ remapping)

     

       500
       500
       -
           x2apic = optionalAttrs (stdenv.system == "x86_64-linux") {

     

       500
       500
       +
           x2apic = optionalAttrs (stdenv.hostPlatform.system == "x86_64-linux") {

     

       501
       501
        
             X86_X2APIC = yes;

     

       502
       502
        
             IRQ_REMAP  = yes;

     

       503
       503
        
           };

+1 -1

pkgs/os-specific/linux/kernel/linux-rpi.nix

···

       18
       18
        
         defconfig = {

     

       19
       19
        
           "armv6l-linux" = "bcmrpi_defconfig";

     

       20
       20
        
           "armv7l-linux" = "bcm2709_defconfig";

     

       21
       21
       -
         }.${stdenv.system} or (throw "linux_rpi not supported on '${stdenv.system}'");

     

       21
       21
       +
         }.${stdenv.hostPlatform.system} or (throw "linux_rpi not supported on '${stdenv.hostPlatform.system}'");

     

       22
       22
        
       

     

       23
       23
        
         features = {

     

       24
       24
        
           efiBootStub = false;

+4 -4

pkgs/os-specific/linux/nvidia-x11/generic.nix

···

       34
       34
        
           builder = ./builder.sh;

     

       35
       35
        
       

     

       36
       36
        
           src =

     

       37
       37
       -
             if stdenv.system == "i686-linux" then

     

       37
       37
       +
             if stdenv.hostPlatform.system == "i686-linux" then

     

       38
       38
        
               fetchurl {

     

       39
       39
        
                 url = "https://download.nvidia.com/XFree86/Linux-x86/${version}/NVIDIA-Linux-x86-${version}${pkgSuffix}.run";

     

       40
       40
        
                 sha256 = sha256_32bit;

     

       41
       41
        
               }

     

       42
       42
       -
             else if stdenv.system == "x86_64-linux" then

     

       42
       42
       +
             else if stdenv.hostPlatform.system == "x86_64-linux" then

     

       43
       43
        
               fetchurl {

     

       44
       44
        
                 url = "https://download.nvidia.com/XFree86/Linux-x86_64/${version}/NVIDIA-Linux-x86_64-${version}${pkgSuffix}.run";

     

       45
       45
        
                 sha256 = sha256_64bit;

     

       46
       46
        
               }

     

       47
       47
       -
             else throw "nvidia-x11 does not support platform ${stdenv.system}";

     

       47
       47
       +
             else throw "nvidia-x11 does not support platform ${stdenv.hostPlatform.system}";

     

       48
       48
        
       

     

       49
       49
        
           patches = if libsOnly then null else patches;

     

       50
       50
        
           inherit prePatch;

     

       51
       51
        
           inherit version useGLVND useProfiles;

     

       52
       52
       -
           inherit (stdenv) system;

     

       52
       52
       +
           inherit (stdenv.hostPlatform) system;

     

       53
       53
        
       

     

       54
       54
        
           outputs = [ "out" ] ++ optional (!libsOnly) "bin";

     

       55
       55
        
           outputDev = if libsOnly then null else "bin";

+2 -2

pkgs/os-specific/linux/prl-tools/default.nix

···

       10
       10
        
       

     

       11
       11
        
       let xorgFullVer = (builtins.parseDrvName xorg.xorgserver.name).version;

     

       12
       12
        
           xorgVer = lib.concatStringsSep "." (lib.take 2 (lib.splitString "." xorgFullVer));

     

       13
       13
       -
           x64 = if stdenv.system == "x86_64-linux" then true

     

       14
       14
       -
                 else if stdenv.system == "i686-linux" then false

     

       13
       13
       +
           x64 = if stdenv.hostPlatform.system == "x86_64-linux" then true

     

       14
       14
       +
                 else if stdenv.hostPlatform.system == "i686-linux" then false

     

       15
       15
        
                 else throw "Parallels Tools for Linux only support {x86-64,i686}-linux targets";

     

       16
       16
        
       in

     

       17
       17
        
       stdenv.mkDerivation rec {

+1 -1

pkgs/stdenv/generic/make-derivation.nix

···

       187
       187
        
                 builder = attrs.realBuilder or stdenv.shell;

     

       188
       188
        
                 args = attrs.args or ["-e" (attrs.builder or ./default-builder.sh)];

     

       189
       189
        
                 inherit stdenv;

     

       190
       190
       -
                 inherit (stdenv) system;

     

       190
       190
       +
                 inherit (stdenv.hostPlatform) system;

     

       191
       191
        
                 userHook = config.stdenv.userHook or null;

     

       192
       192
        
                 __ignoreNulls = true;

     

       193
       193

+3 -3

pkgs/tools/X11/xwinwrap/default.nix

···

       16
       16
        
           xlibsWrapper

     

       17
       17
        
         ];

     

       18
       18
        
       

     

       19
       19
       -
         buildPhase = if stdenv.system == "x86_64-linux" then ''

     

       19
       19
       +
         buildPhase = if stdenv.hostPlatform.system == "x86_64-linux" then ''

     

       20
       20
        
           make all64

     

       21
       21
       -
         '' else if stdenv.system == "i686-linux" then ''

     

       21
       21
       +
         '' else if stdenv.hostPlatform.system == "i686-linux" then ''

     

       22
       22
        
           make all32

     

       23
       23
       -
         '' else throw "xwinwrap is not supported on ${stdenv.system}";

     

       23
       23
       +
         '' else throw "xwinwrap is not supported on ${stdenv.hostPlatform.system}";

     

       24
       24
        
       

     

       25
       25
        
         installPhase = ''

     

       26
       26
        
           mkdir -p $out/bin

+1 -1

pkgs/tools/admin/bluemix-cli/default.nix

···

       5
       5
        
         version = "0.8.0";

     

       6
       6
        
       

     

       7
       7
        
         src =

     

       8
       8
       -
           if stdenv.system == "i686-linux" then

     

       8
       8
       +
           if stdenv.hostPlatform.system == "i686-linux" then

     

       9
       9
        
             fetchurl {

     

       10
       10
        
               name = "linux32-${version}.tar.gz";

     

       11
       11
        
               url = "https://clis.ng.bluemix.net/download/bluemix-cli/${version}/linux32";

+1 -1

pkgs/tools/admin/google-cloud-sdk/default.nix

···

       32
       32
        
         name = "google-cloud-sdk-${version}";

     

       33
       33
        
         version = "206.0.0";

     

       34
       34
        
       

     

       35
       35
       -
         src = fetchurl (sources name stdenv.system);

     

       35
       35
       +
         src = fetchurl (sources name stdenv.hostPlatform.system);

     

       36
       36
        
       

     

       37
       37
        
         buildInputs = [ python makeWrapper ];

     

       38
       38

+1 -1

pkgs/tools/archivers/gnutar/default.nix

···

       30
       30
        
       

     

       31
       31
        
         # May have some issues with root compilation because the bootstrap tool

     

       32
       32
        
         # cannot be used as a login shell for now.

     

       33
       33
       -
         FORCE_UNSAFE_CONFIGURE = stdenv.lib.optionalString (stdenv.system == "armv7l-linux" || stdenv.isSunOS) "1";

     

       33
       33
       +
         FORCE_UNSAFE_CONFIGURE = stdenv.lib.optionalString (stdenv.hostPlatform.system == "armv7l-linux" || stdenv.isSunOS) "1";

     

       34
       34
        
       

     

       35
       35
        
         preConfigure = if stdenv.isCygwin then ''

     

       36
       36
        
           sed -i gnu/fpending.h -e 's,include <stdio_ext.h>,,'

+1 -1

pkgs/tools/bootloaders/refind/default.nix

···

       7
       7
        
         };

     

       8
       8
        
       

     

       9
       9
        
         inherit

     

       10
       10
       -
           (archids.${stdenv.system} or (throw "unsupported system: ${stdenv.system}"))

     

       10
       10
       +
           (archids.${stdenv.hostPlatform.system} or (throw "unsupported system: ${stdenv.hostPlatform.system}"))

     

       11
       11
        
           hostarch efiPlatform;

     

       12
       12
        
       in

     

       13
       13

+1 -1

pkgs/tools/compression/bzip2/default.nix

···

       1
       1
        
       { stdenv, fetchurl

     

       2
       2
       -
       , linkStatic ? (stdenv.system == "i686-cygwin")

     

       2
       2
       +
       , linkStatic ? (stdenv.hostPlatform.system == "i686-cygwin")

     

       3
       3
        
       }:

     

       4
       4
        
       

     

       5
       5
        
       stdenv.mkDerivation rec {

+1 -1

pkgs/tools/filesystems/sshfs-fuse/default.nix

···

       19
       19
        
         checkInputs = [ which python3Packages.pytest ];

     

       20
       20
        
       

     

       21
       21
        
         NIX_CFLAGS_COMPILE = stdenv.lib.optional

     

       22
       22
       -
           (stdenv.system == "i686-linux")

     

       22
       22
       +
           (stdenv.hostPlatform.system == "i686-linux")

     

       23
       23
        
           "-D_FILE_OFFSET_BITS=64";

     

       24
       24
        
       

     

       25
       25
        
         postInstall = ''

+5 -5

pkgs/tools/graphics/pngout/default.nix

···

       1
       1
        
       {stdenv, fetchurl}:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         folder = if stdenv.system == "i686-linux" then "i686"

     

       5
       5
       -
         else if stdenv.system == "x86_64-linux" then "x86_64"

     

       6
       6
       -
         else throw "Unsupported system: ${stdenv.system}";

     

       4
       4
       +
         folder = if stdenv.hostPlatform.system == "i686-linux" then "i686"

     

       5
       5
       +
         else if stdenv.hostPlatform.system == "x86_64-linux" then "x86_64"

     

       6
       6
       +
         else throw "Unsupported system: ${stdenv.hostPlatform.system}";

     

       7
       7
        
       in

     

       8
       8
        
       stdenv.mkDerivation {

     

       9
       9
        
         name = "pngout-20130221";

     
···

       17
       17
        
           mkdir -p $out/bin

     

       18
       18
        
           cp ${folder}/pngout $out/bin

     

       19
       19
        
           

     

       20
       20
       -
           ${if stdenv.system == "i686-linux" then ''

     

       20
       20
       +
           ${if stdenv.hostPlatform.system == "i686-linux" then ''

     

       21
       21
        
               patchelf --set-interpreter ${stdenv.glibc.out}/lib/ld-linux.so.2 $out/bin/pngout

     

       22
       22
       -
             '' else if stdenv.system == "x86_64-linux" then ''

     

       22
       22
       +
             '' else if stdenv.hostPlatform.system == "x86_64-linux" then ''

     

       23
       23
        
               patchelf --set-interpreter ${stdenv.glibc.out}/lib/ld-linux-x86-64.so.2 $out/bin/pngout

     

       24
       24
        
             '' else ""}

     

       25
       25
        
         '';

+5 -5

pkgs/tools/misc/bandwidth/default.nix

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         arch =

     

       5
       5
       -
           if      stdenv.system == "x86_64-linux" then "bandwidth64"

     

       6
       6
       -
           else if stdenv.system == "i686-linux" then "bandwidth32"

     

       7
       7
       -
           else if stdenv.system == "x86_64-darwin" then "bandwidth-mac64"

     

       8
       8
       -
           else if stdenv.system == "i686-darwin" then "bandwidth-mac32"

     

       9
       9
       -
           else if stdenv.system == "i686-cygwin" then "bandwidth-win32"

     

       5
       5
       +
           if      stdenv.hostPlatform.system == "x86_64-linux" then "bandwidth64"

     

       6
       6
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "bandwidth32"

     

       7
       7
       +
           else if stdenv.hostPlatform.system == "x86_64-darwin" then "bandwidth-mac64"

     

       8
       8
       +
           else if stdenv.hostPlatform.system == "i686-darwin" then "bandwidth-mac32"

     

       9
       9
       +
           else if stdenv.hostPlatform.system == "i686-cygwin" then "bandwidth-win32"

     

       10
       10
        
           else throw "Unknown architecture";

     

       11
       11
        
       in

     

       12
       12
        
       stdenv.mkDerivation rec {

+1 -1

pkgs/tools/misc/execline/default.nix

···

       32
       32
        
           "--with-dynlib=${skalibs.lib}/lib"

     

       33
       33
        
         ]

     

       34
       34
        
         ++ (if stdenv.isDarwin then [ "--disable-shared" ] else [ "--enable-shared" ])

     

       35
       35
       -
         ++ (stdenv.lib.optional stdenv.isDarwin "--build=${stdenv.system}");

     

       35
       35
       +
         ++ (stdenv.lib.optional stdenv.isDarwin "--build=${stdenv.hostPlatform.system}");

     

       36
       36
        
       

     

       37
       37
        
         postInstall = ''

     

       38
       38
        
           mkdir -p $doc/share/doc/execline

+6 -6

pkgs/tools/misc/grub/2.0x.nix

···

       28
       28
        
           "aarch64-linux".target = "arm64";

     

       29
       29
        
         };

     

       30
       30
        
       

     

       31
       31
       -
         canEfi = any (system: stdenv.system == system) (mapAttrsToList (name: _: name) efiSystemsBuild);

     

       32
       32
       -
         inPCSystems = any (system: stdenv.system == system) (mapAttrsToList (name: _: name) pcSystems);

     

       31
       31
       +
         canEfi = any (system: stdenv.hostPlatform.system == system) (mapAttrsToList (name: _: name) efiSystemsBuild);

     

       32
       32
       +
         inPCSystems = any (system: stdenv.hostPlatform.system == system) (mapAttrsToList (name: _: name) pcSystems);

     

       33
       33
        
       

     

       34
       34
        
         version = "2.02";

     

       35
       35
        
       

     
···

       86
       86
        
       

     

       87
       87
        
         configureFlags = [ "--enable-grub-mount" ] # dep of os-prober

     

       88
       88
        
           ++ optional zfsSupport "--enable-libzfs"

     

       89
       89
       -
           ++ optionals efiSupport [ "--with-platform=efi" "--target=${efiSystemsBuild.${stdenv.system}.target}" "--program-prefix=" ]

     

       90
       90
       -
           ++ optionals xenSupport [ "--with-platform=xen" "--target=${efiSystemsBuild.${stdenv.system}.target}"];

     

       89
       89
       +
           ++ optionals efiSupport [ "--with-platform=efi" "--target=${efiSystemsBuild.${stdenv.hostPlatform.system}.target}" "--program-prefix=" ]

     

       90
       90
       +
           ++ optionals xenSupport [ "--with-platform=xen" "--target=${efiSystemsBuild.${stdenv.hostPlatform.system}.target}"];

     

       91
       91
        
       

     

       92
       92
        
         # save target that grub is compiled for

     

       93
       93
        
         grubTarget = if efiSupport

     

       94
       94
       -
                      then "${efiSystemsInstall.${stdenv.system}.target}-efi"

     

       94
       94
       +
                      then "${efiSystemsInstall.${stdenv.hostPlatform.system}.target}-efi"

     

       95
       95
        
                      else if inPCSystems

     

       96
       96
       -
                           then "${pcSystems.${stdenv.system}.target}-pc"

     

       96
       96
       +
                           then "${pcSystems.${stdenv.hostPlatform.system}.target}-pc"

     

       97
       97
        
                           else "";

     

       98
       98
        
       

     

       99
       99
        
         doCheck = false;

+4 -4

pkgs/tools/misc/grub/pvgrub_image/default.nix

···

       22
       22
        
           tar -cf memdisk.tar grub.cfg

     

       23
       23
        
           # We include all modules except all_video.mod as otherwise grub will fail printing "no symbol table"

     

       24
       24
        
           # if we include it.

     

       25
       25
       -
           grub-mkimage -O "${efiSystemsBuild.${stdenv.system}.target}-xen" -c grub-bootstrap.cfg \

     

       26
       26
       -
             -m memdisk.tar -o "grub-${efiSystemsBuild.${stdenv.system}.target}-xen.bin" \

     

       27
       27
       -
             $(ls "${grub2_xen}/lib/grub/${efiSystemsBuild.${stdenv.system}.target}-xen/" |grep 'mod''$'|grep -v '^all_video\.mod''$')

     

       25
       25
       +
           grub-mkimage -O "${efiSystemsBuild.${stdenv.hostPlatform.system}.target}-xen" -c grub-bootstrap.cfg \

     

       26
       26
       +
             -m memdisk.tar -o "grub-${efiSystemsBuild.${stdenv.hostPlatform.system}.target}-xen.bin" \

     

       27
       27
       +
             $(ls "${grub2_xen}/lib/grub/${efiSystemsBuild.${stdenv.hostPlatform.system}.target}-xen/" |grep 'mod''$'|grep -v '^all_video\.mod''$')

     

       28
       28
        
           mkdir -p "$out/lib/grub-xen"

     

       29
       29
       -
           cp "grub-${efiSystemsBuild.${stdenv.system}.target}-xen.bin" $out/lib/grub-xen/

     

       29
       29
       +
           cp "grub-${efiSystemsBuild.${stdenv.hostPlatform.system}.target}-xen.bin" $out/lib/grub-xen/

     

       30
       30
        
         '';

     

       31
       31
        
       

     

       32
       32
        
         meta = with stdenv.lib; {

+2 -2

pkgs/tools/misc/grub/trusted.nix

···

       10
       10
        
           "x86_64-linux".target = "i386";

     

       11
       11
        
         };

     

       12
       12
        
       

     

       13
       13
       -
         inPCSystems = any (system: stdenv.system == system) (mapAttrsToList (name: _: name) pcSystems);

     

       13
       13
       +
         inPCSystems = any (system: stdenv.hostPlatform.system == system) (mapAttrsToList (name: _: name) pcSystems);

     

       14
       14
        
       

     

       15
       15
        
         version = if for_HP_laptop then "1.2.1" else "1.2.0";

     

       16
       16
        
       

     
···

       84
       84
        
       

     

       85
       85
        
         # save target that grub is compiled for

     

       86
       86
        
         grubTarget = if inPCSystems

     

       87
       87
       -
                      then "${pcSystems.${stdenv.system}.target}-pc"

     

       87
       87
       +
                      then "${pcSystems.${stdenv.hostPlatform.system}.target}-pc"

     

       88
       88
        
                      else "";

     

       89
       89
        
       

     

       90
       90
        
         doCheck = false;

+2 -2

pkgs/tools/misc/mongodb-compass/default.nix

···

       43
       43
        
         ] + ":${stdenv.cc.cc.lib}/lib64";

     

       44
       44
        
       

     

       45
       45
        
         src =

     

       46
       46
       -
           if stdenv.system == "x86_64-linux" then

     

       46
       46
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       47
       47
        
             fetchurl {

     

       48
       48
        
               url = "https://downloads.mongodb.com/compass/mongodb-compass_${version}_amd64.deb";

     

       49
       49
        
               sha256 = "0x23jshnr0rafm5sn2vhq2y2gryg8mksahzyv5fszblgaxay234p";

     

       50
       50
        
             }

     

       51
       51
        
           else

     

       52
       52
       -
             throw "MongoDB compass is not supported on ${stdenv.system}";

     

       52
       52
       +
             throw "MongoDB compass is not supported on ${stdenv.hostPlatform.system}";

     

       53
       53
        
       

     

       54
       54
        
       in stdenv.mkDerivation {

     

       55
       55
        
         name = "mongodb-compass-${version}";

+7 -7

pkgs/tools/misc/mprime/default.nix

···

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         srcDir =

     

       5
       5
       -
           if stdenv.system == "x86_64-linux" then "linux64"

     

       6
       6
       -
           else if stdenv.system == "i686-linux" then "linux"

     

       7
       7
       -
           else if stdenv.system == "x86_64-darwin" then "macosx64"

     

       5
       5
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then "linux64"

     

       6
       6
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "linux"

     

       7
       7
       +
           else if stdenv.hostPlatform.system == "x86_64-darwin" then "macosx64"

     

       8
       8
        
           else throwSystem;

     

       9
       9
       -
         throwSystem = throw "Unsupported system: ${stdenv.system}";

     

       9
       9
       +
         throwSystem = throw "Unsupported system: ${stdenv.hostPlatform.system}";

     

       10
       10
        
         gwnum =

     

       11
       11
       -
           if stdenv.system == "x86_64-linux" then "make64"

     

       12
       12
       -
           else if stdenv.system == "i686-linux" then "makefile"

     

       13
       13
       -
           else if stdenv.system == "x86_64-darwin" then "makemac"

     

       11
       11
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then "make64"

     

       12
       12
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "makefile"

     

       13
       13
       +
           else if stdenv.hostPlatform.system == "x86_64-darwin" then "makemac"

     

       14
       14
        
           else throwSystem;

     

       15
       15
        
       in

     

       16
       16

+1 -1

pkgs/tools/misc/ocz-ssd-guru/default.nix

···

       1
       1
        
       { fetchurl, stdenv, xorg, freetype, fontconfig, libGLU_combined, glibc, makeWrapper }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         system = if stdenv.system == "x86_64-linux" then "linux64" else "linux32";

     

       4
       4
       +
         system = if stdenv.hostPlatform.system == "x86_64-linux" then "linux64" else "linux32";

     

       5
       5
        
       in

     

       6
       6
        
       stdenv.mkDerivation rec {

     

       7
       7
        
         name = "ocz-ssd-guru-${version}";

+1 -1

pkgs/tools/misc/os-prober/default.nix

···

       24
       24
        
           install -Dt $out/share common.sh

     

       25
       25
        
       

     

       26
       26
        
           # probes

     

       27
       27
       -
           case "${stdenv.system}" in

     

       27
       27
       +
           case "${stdenv.hostPlatform.system}" in

     

       28
       28
        
               i686*|x86_64*) ARCH=x86;;

     

       29
       29
        
               powerpc*) ARCH=powerpc;;

     

       30
       30
        
               arm*) ARCH=arm;;

+1 -1

pkgs/tools/misc/s6-portable-utils/default.nix

···

       29
       29
        
         # Explicitly setting target ensures code can be compiled against a skalibs

     

       30
       30
        
         # binary built on a different version of darwin.

     

       31
       31
        
         # http://www.skarnet.org/cgi-bin/archive.cgi?1:mss:623:heiodchokfjdkonfhdph

     

       32
       32
       -
         ++ (stdenv.lib.optional stdenv.isDarwin "--build=${stdenv.system}");

     

       32
       32
       +
         ++ (stdenv.lib.optional stdenv.isDarwin "--build=${stdenv.hostPlatform.system}");

     

       33
       33
        
       

     

       34
       34
        
         postInstall = ''

     

       35
       35
        
           mkdir -p $doc/share/doc/s6-portable-utils/

+1 -1

pkgs/tools/misc/staruml/default.nix

···

       13
       13
        
         name = "staruml-${version}";

     

       14
       14
        
       

     

       15
       15
        
         src =

     

       16
       16
       -
           if stdenv.system == "i686-linux" then fetchurl {

     

       16
       16
       +
           if stdenv.hostPlatform.system == "i686-linux" then fetchurl {

     

       17
       17
        
             url = "http://staruml.io/download/release/v${version}/StarUML-v${version}-32-bit.deb";

     

       18
       18
        
             sha256 = "0vb3k9m3l6pmsid4shlk0xdjsriq3gxzm8q7l04didsppg0vvq1n";

     

       19
       19
        
           } else fetchurl {

+1 -1

pkgs/tools/networking/airfield/default.nix

···

       6
       6
        
       let

     

       7
       7
        
         nodePackages = import ./node.nix {

     

       8
       8
        
           inherit pkgs;

     

       9
       9
       -
           system = stdenv.system;

     

       9
       9
       +
           system = stdenv.hostPlatform.system;

     

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         runtimeEnv = buildEnv {

+1 -1

pkgs/tools/networking/filegive/default.nix

···

       21
       21
        
         buildInputs = [ go ];

     

       22
       22
        
       

     

       23
       23
        
         buildPhase = ''

     

       24
       24
       -
           ${stdenv.lib.optionalString (stdenv.system == "armv5tel-linux") "export GOARM=5"}

     

       24
       24
       +
           ${stdenv.lib.optionalString (stdenv.hostPlatform.system == "armv5tel-linux") "export GOARM=5"}

     

       25
       25
        
       

     

       26
       26
        
           mkdir $TMPDIR/go

     

       27
       27
        
           export GOPATH=$TMPDIR/go

+5 -5

pkgs/tools/networking/logmein-hamachi/default.nix

···

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
        
         arch =

     

       7
       7
       -
           if stdenv.system == "x86_64-linux" then "x64"

     

       8
       8
       -
           else if stdenv.system == "i686-linux" then "x86"

     

       7
       7
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then "x64"

     

       8
       8
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "x86"

     

       9
       9
        
           else throwSystem;

     

       10
       10
       -
         throwSystem = throw "Unsupported system: ${stdenv.system}";

     

       10
       10
       +
         throwSystem = throw "Unsupported system: ${stdenv.hostPlatform.system}";

     

       11
       11
        
         sha256 =

     

       12
       12
       -
           if stdenv.system == "x86_64-linux" then "11mxa4kls5xjj3462ycrfvfxb1xkk23p5m9iirvwsi0zdmhpnwm8"

     

       13
       13
       -
           else if stdenv.system == "i686-linux" then "03ml9xv19km99f0z7fpr21b1zkxvw7q39kjzd8wpb2pds51wnc62"

     

       12
       12
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then "11mxa4kls5xjj3462ycrfvfxb1xkk23p5m9iirvwsi0zdmhpnwm8"

     

       13
       13
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "03ml9xv19km99f0z7fpr21b1zkxvw7q39kjzd8wpb2pds51wnc62"

     

       14
       14
        
           else throwSystem;

     

       15
       15
        
         libraries = stdenv.lib.makeLibraryPath [ stdenv.cc.cc ];

     

       16
       16

+1 -1

pkgs/tools/networking/ngrok-2/default.nix

···

       15
       15
        
         } else if stdenv.isDarwin then fetchurl {

     

       16
       16
        
           url = "https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-darwin-386.zip";

     

       17
       17
        
           sha256 = "0yfd250b55wcpgqd00rqfaa7a82f35fmybb31q5xwdbgc2i47pbh";

     

       18
       18
       -
         } else throw "platform ${stdenv.system} not supported!";

     

       18
       18
       +
         } else throw "platform ${stdenv.hostPlatform.system} not supported!";

     

       19
       19
        
       

     

       20
       20
        
         sourceRoot = ".";

     

       21
       21

+1 -1

pkgs/tools/networking/s6-dns/default.nix

···

       33
       33
        
           "--with-dynlib=${skalibs.lib}/lib"

     

       34
       34
        
         ]

     

       35
       35
        
         ++ (if stdenv.isDarwin then [ "--disable-shared" ] else [ "--enable-shared" ])

     

       36
       36
       -
         ++ (stdenv.lib.optional stdenv.isDarwin "--build=${stdenv.system}");

     

       36
       36
       +
         ++ (stdenv.lib.optional stdenv.isDarwin "--build=${stdenv.hostPlatform.system}");

     

       37
       37
        
       

     

       38
       38
        
         postInstall = ''

     

       39
       39
        
           mkdir -p $doc/share/doc/s6-dns/

+1 -1

pkgs/tools/networking/s6-networking/default.nix

···

       61
       61
        
              "--with-include=${lib.getDev sslLibs.${sslSupport}}/include"

     

       62
       62
        
              "--with-lib=${lib.getLib sslLibs.${sslSupport}}/lib"

     

       63
       63
        
            ])

     

       64
       64
       -
         ++ (lib.optional stdenv.isDarwin "--build=${stdenv.system}");

     

       64
       64
       +
         ++ (lib.optional stdenv.isDarwin "--build=${stdenv.hostPlatform.system}");

     

       65
       65
        
       

     

       66
       66
        
         postInstall = ''

     

       67
       67
        
           mkdir -p $doc/share/doc/s6-networking/

+1 -1

pkgs/tools/networking/strongswan/default.nix

···

       68
       68
        
             "--enable-af-alg" "--enable-xauth-pam" "--enable-chapoly"

     

       69
       69
        
             "--enable-curl" ]

     

       70
       70
        
           ++ optionals stdenv.isx86_64 [ "--enable-aesni" "--enable-rdrand" ]

     

       71
       71
       -
           ++ optional (stdenv.system == "i686-linux") "--enable-padlock"

     

       71
       71
       +
           ++ optional (stdenv.hostPlatform.system == "i686-linux") "--enable-padlock"

     

       72
       72
        
           ++ optionals enableTNC [

     

       73
       73
        
                "--disable-gmp" "--disable-aes" "--disable-md5" "--disable-sha1" "--disable-sha2" "--disable-fips-prf"

     

       74
       74
        
                "--enable-eap-tnc" "--enable-eap-ttls" "--enable-eap-dynamic" "--enable-tnccs-20"

+1 -1

pkgs/tools/package-management/checkinstall/default.nix

···

       37
       37
        
           ./set-buildroot.patch

     

       38
       38
        
         ]

     

       39
       39
        
       

     

       40
       40
       -
         ++ stdenv.lib.optional (stdenv.system == "x86_64-linux") 

     

       40
       40
       +
         ++ stdenv.lib.optional (stdenv.hostPlatform.system == "x86_64-linux") 

     

       41
       41
        
           # Force use of old memcpy so that installwatch works on Glibc <

     

       42
       42
        
           # 2.14.

     

       43
       43
        
           ./use-old-memcpy.patch;

+1 -1

pkgs/tools/package-management/nixui/default.nix

···

       9
       9
        
         };

     

       10
       10
        
         nixui = (import ./nixui.nix {

     

       11
       11
        
           inherit pkgs;

     

       12
       12
       -
           inherit (stdenv) system;

     

       12
       12
       +
           inherit (stdenv.hostPlatform) system;

     

       13
       13
        
         })."nixui-git://github.com/matejc/nixui.git#0.2.1";

     

       14
       14
        
         script = writeScript "nixui" ''

     

       15
       15
        
           #! ${stdenv.shell}

+3 -3

pkgs/tools/security/afl/default.nix

···

       4
       4
        
       

     

       5
       5
        
       let

     

       6
       6
        
         afl-qemu = callPackage ./qemu.nix {};

     

       7
       7
       -
         qemu-exe-name = if stdenv.system == "x86_64-linux" then "qemu-x86_64"

     

       8
       8
       -
           else if stdenv.system == "i686-linux" then "qemu-i386"

     

       9
       9
       -
           else throw "afl: no support for ${stdenv.system}!";

     

       7
       7
       +
         qemu-exe-name = if stdenv.hostPlatform.system == "x86_64-linux" then "qemu-x86_64"

     

       8
       8
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "qemu-i386"

     

       9
       9
       +
           else throw "afl: no support for ${stdenv.hostPlatform.system}!";

     

       10
       10
        
       in

     

       11
       11
        
       

     

       12
       12
        
       stdenv.mkDerivation rec {

+4 -4

pkgs/tools/security/afl/qemu.nix

···

       16
       16
        
         aflTypesFile = writeText "afl-types.h"

     

       17
       17
        
           (builtins.readFile ./qemu-patches/afl-types.h);

     

       18
       18
        
       

     

       19
       19
       -
         cpuTarget = if stdenv.system == "x86_64-linux" then "x86_64-linux-user"

     

       20
       20
       -
           else if stdenv.system == "i686-linux" then "i386-linux-user"

     

       21
       21
       -
           else throw "afl: no support for ${stdenv.system}!";

     

       19
       19
       +
         cpuTarget = if stdenv.hostPlatform.system == "x86_64-linux" then "x86_64-linux-user"

     

       20
       20
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "i386-linux-user"

     

       21
       21
       +
           else throw "afl: no support for ${stdenv.hostPlatform.system}!";

     

       22
       22
        
       in

     

       23
       23
        
       stdenv.mkDerivation rec {

     

       24
       24
        
         name = "afl-${n}";

     
···

       33
       33
        
             vde2 texinfo libuuid flex bison lzo snappy autoconf

     

       34
       34
        
             libcap_ng gnutls

     

       35
       35
        
           ]

     

       36
       36
       -
           ++ optionals (hasSuffix "linux" stdenv.system) [ libaio ];

     

       36
       36
       +
           ++ optionals (hasSuffix "linux" stdenv.hostPlatform.system) [ libaio ];

     

       37
       37
        
       

     

       38
       38
        
         enableParallelBuilding = true;

     

       39
       39

+6 -6

pkgs/tools/security/encryptr/default.nix

···

       5
       5
        
       }:

     

       6
       6
        
       

     

       7
       7
        
       let

     

       8
       8
       -
         arch = if stdenv.system == "x86_64-linux" then "amd"

     

       9
       9
       -
           else if stdenv.system == "i686-linux" then "i386"

     

       10
       10
       -
           else throw "Encryptr for ${stdenv.system} not supported!";

     

       8
       8
       +
         arch = if stdenv.hostPlatform.system == "x86_64-linux" then "amd"

     

       9
       9
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "i386"

     

       10
       10
       +
           else throw "Encryptr for ${stdenv.hostPlatform.system} not supported!";

     

       11
       11
        
       

     

       12
       12
       -
         sha256 = if stdenv.system == "x86_64-linux" then "1j3g467g7ar86hpnh6q9mf7mh2h4ia94mwhk1283zh739s2g53q2"

     

       13
       13
       -
           else if stdenv.system == "i686-linux" then "02j9hg9b1jlv25q1sjfhv8d46mii33f94dj0ccn83z9z18q4y2cm"

     

       14
       14
       -
           else throw "Encryptr for ${stdenv.system} not supported!";

     

       12
       12
       +
         sha256 = if stdenv.hostPlatform.system == "x86_64-linux" then "1j3g467g7ar86hpnh6q9mf7mh2h4ia94mwhk1283zh739s2g53q2"

     

       13
       13
       +
           else if stdenv.hostPlatform.system == "i686-linux" then "02j9hg9b1jlv25q1sjfhv8d46mii33f94dj0ccn83z9z18q4y2cm"

     

       14
       14
       +
           else throw "Encryptr for ${stdenv.hostPlatform.system} not supported!";

     

       15
       15
        
       

     

       16
       16
        
       in stdenv.mkDerivation rec {

     

       17
       17
        
         name = "encryptr-${version}";

+4 -3

pkgs/tools/security/enpass/default.nix

···

       1
       1
       -
       {stdenv, system, fetchurl, dpkg, openssl, xorg

     

       1
       1
       +
       { stdenv, fetchurl, dpkg, openssl, xorg

     

       2
       2
        
       , glib, libGLU_combined, libpulseaudio, zlib, dbus, fontconfig, freetype

     

       3
       3
        
       , gtk2, pango, atk, cairo, gdk_pixbuf, jasper, xkeyboardconfig

     

       4
       4
        
       , makeWrapper , python, pythonPackages, lib

     

       5
       5
       -
       , libredirect, lsof}:

     

       5
       5
       +
       , libredirect, lsof

     

       6
       6
       +
       }:

     

       6
       7
        
       

     

       7
       8
        
       let

     

       8
       9
        
         all_data = builtins.fromJSON (builtins.readFile ./data.json);

     
···

       11
       12
        
           x86_64-linux = "amd64";

     

       12
       13
        
         };

     

       13
       14
        
       

     

       14
       14
       -
         data = all_data.${system_map.${system} or (throw "Unsupported platform")};

     

       15
       15
       +
         data = all_data.${system_map.${stdenv.hostPlatform.system} or (throw "Unsupported platform")};

     

       15
       16
        
       

     

       16
       17
        
         baseUrl = http://repo.sinew.in;

     

       17
       18

+3 -3

pkgs/tools/security/pcsc-scm-scl011/default.nix

···

       1
       1
        
       { stdenv, fetchurl, unzip, libusb }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         arch = if stdenv.system == "i686-linux" then "32"

     

       5
       5
       -
         else if stdenv.system == "x86_64-linux" then "64"

     

       6
       6
       -
         else throw "Unsupported system: ${stdenv.system}";

     

       4
       4
       +
         arch = if stdenv.hostPlatform.system == "i686-linux" then "32"

     

       5
       5
       +
         else if stdenv.hostPlatform.system == "x86_64-linux" then "64"

     

       6
       6
       +
         else throw "Unsupported system: ${stdenv.hostPlatform.system}";

     

       7
       7
        
       in

     

       8
       8
        
       stdenv.mkDerivation rec {

     

       9
       9
        
         name = "pcsc-scm-scl-${version}";

+1 -1

pkgs/tools/security/sshuttle/default.nix

···

       12
       12
        
       

     

       13
       13
        
         patches = [ ./sudo.patch ];

     

       14
       14
        
       

     

       15
       15
       -
         nativeBuildInputs = [ makeWrapper python3Packages.setuptools_scm ] ++ stdenv.lib.optional (stdenv.system != "i686-linux") pandoc;

     

       15
       15
       +
         nativeBuildInputs = [ makeWrapper python3Packages.setuptools_scm ] ++ stdenv.lib.optional (stdenv.hostPlatform.system != "i686-linux") pandoc;

     

       16
       16
        
         buildInputs =

     

       17
       17
        
           [ coreutils openssh procps nettools ]

     

       18
       18
        
           ++ stdenv.lib.optionals stdenv.isLinux [ iptables ];

+1 -1

pkgs/tools/system/s6-rc/default.nix

···

       39
       39
        
           "--with-dynlib=${s6.out}/lib"

     

       40
       40
        
         ]

     

       41
       41
        
         ++ (if stdenv.isDarwin then [ "--disable-shared" ] else [ "--enable-shared" ])

     

       42
       42
       -
         ++ (stdenv.lib.optional stdenv.isDarwin "--build=${stdenv.system}");

     

       42
       42
       +
         ++ (stdenv.lib.optional stdenv.isDarwin "--build=${stdenv.hostPlatform.system}");

     

       43
       43
        
       

     

       44
       44
        
         postInstall = ''

     

       45
       45
        
           mkdir -p $doc/share/doc/s6-rc/

+1 -1

pkgs/tools/system/s6/default.nix

···

       40
       40
        
           "--with-dynlib=${execline.lib}/lib"

     

       41
       41
        
         ]

     

       42
       42
        
         ++ (if stdenv.isDarwin then [ "--disable-shared" ] else [ "--enable-shared" ])

     

       43
       43
       -
         ++ (stdenv.lib.optional stdenv.isDarwin "--build=${stdenv.system}");

     

       43
       43
       +
         ++ (stdenv.lib.optional stdenv.isDarwin "--build=${stdenv.hostPlatform.system}");

     

       44
       44
        
       

     

       45
       45
        
         postInstall = ''

     

       46
       46
        
           mkdir -p $doc/share/doc/s6/

+1 -1

pkgs/tools/system/storebrowse/default.nix

···

       21
       21
        
           mkdir $TMPDIR/go

     

       22
       22
        
           export GOPATH=$TMPDIR/go

     

       23
       23
        
       

     

       24
       24
       -
           ${stdenv.lib.optionalString (stdenv.system == "armv5tel-linux") "export GOARM=5"}

     

       24
       24
       +
           ${stdenv.lib.optionalString (stdenv.hostPlatform.system == "armv5tel-linux") "export GOARM=5"}

     

       25
       25
        
       

     

       26
       26
        
           GOSQLITE=$GOPATH/src/code.google.com/p/gosqlite

     

       27
       27
        
           mkdir -p $GOSQLITE

+1 -1

pkgs/tools/text/gawk/default.nix

···

       1
       1
        
       { stdenv, fetchurl

     

       2
       2
        
       # TODO: links -lsigsegv but loses the reference for some reason

     

       3
       3
       -
       , withSigsegv ? (false && stdenv.system != "x86_64-cygwin"), libsigsegv

     

       3
       3
       +
       , withSigsegv ? (false && stdenv.hostPlatform.system != "x86_64-cygwin"), libsigsegv

     

       4
       4
        
       , interactive ? false, readline

     

       5
       5
        
       

     

       6
       6
        
       /* Test suite broke on:

+3 -3

pkgs/tools/text/xidel/default.nix

···

       11
       11
        
         #};

     

       12
       12
        
       

     

       13
       13
        
         src =

     

       14
       14
       -
           if stdenv.system == "x86_64-linux" then

     

       14
       14
       +
           if stdenv.hostPlatform.system == "x86_64-linux" then

     

       15
       15
        
             fetchurl {

     

       16
       16
        
               url = "mirror://sourceforge/videlibri/Xidel/Xidel%20${version}/xidel_${version}-1_amd64.deb";

     

       17
       17
        
               sha256 = "0hskc74y7p4j1x33yx0w4fvr610p2yimas8pxhr6bs7mb9b300h7";

     

       18
       18
        
             }

     

       19
       19
       -
           else if stdenv.system == "i686-linux" then

     

       19
       19
       +
           else if stdenv.hostPlatform.system == "i686-linux" then

     

       20
       20
        
             fetchurl {

     

       21
       21
        
               url = "mirror://sourceforge/videlibri/Xidel/Xidel%20${version}/xidel_${version}-1_i386.deb";

     

       22
       22
        
               sha256 = "07yk5sk1p4jm0jmgjwdm2wq8d2wybi1wkn1qq5j5y03z1pdc3fi6";

     

       23
       23
        
             }

     

       24
       24
       -
           else throw "xidel is not supported on ${stdenv.system}";

     

       24
       24
       +
           else throw "xidel is not supported on ${stdenv.hostPlatform.system}";

     

       25
       25
        
       

     

       26
       26
        
         buildInputs = [ dpkg ];

     

       27
       27

+2 -2

pkgs/tools/typesetting/kindlegen/default.nix

···

       11
       11
        
           "i686-darwin"   = "0zniyn0s41fxqrajbgwxbcsj5vzf9m7a6yvdz2b11mphr00kpbbs";

     

       12
       12
        
           "x86_64-cygwin" = "02slfh1bbpijay4skj85cjiv7z43ha8vm5aa1lwiqjk86qbl1f3h";

     

       13
       13
        
           "i686-cygwin"   = "02slfh1bbpijay4skj85cjiv7z43ha8vm5aa1lwiqjk86qbl1f3h";

     

       14
       14
       -
         }."${stdenv.system}" or (throw "system #{stdenv.system.} is not supported");

     

       14
       14
       +
         }."${stdenv.hostPlatform.system}" or (throw "system #{stdenv.hostPlatform.system.} is not supported");

     

       15
       15
        
       

     

       16
       16
        
         url = {

     

       17
       17
        
           "x86_64-linux"  = "http://kindlegen.s3.amazonaws.com/kindlegen_linux_2.6_i386_v${fileVersion}.tar.gz";

     
···

       20
       20
        
           "i686-darwin"   = "http://kindlegen.s3.amazonaws.com/KindleGen_Mac_i386_v${fileVersion}.zip";

     

       21
       21
        
           "x86_64-cygwin" = "http://kindlegen.s3.amazonaws.com/kindlegen_win32_v${fileVersion}.zip";

     

       22
       22
        
           "i686-cygwin"   = "http://kindlegen.s3.amazonaws.com/kindlegen_win32_v${fileVersion}.zip";

     

       23
       23
       -
         }."${stdenv.system}" or (throw "system #{stdenv.system.} is not supported");

     

       23
       23
       +
         }."${stdenv.hostPlatform.system}" or (throw "system #{stdenv.hostPlatform.system.} is not supported");

     

       24
       24
        
       

     

       25
       25
        
       in stdenv.mkDerivation rec {

     

       26
       26
        
         name = "kindlegen-${version}";

+15 -15

pkgs/top-level/all-packages.nix

···

       1744
       1744
        
         chunksync = callPackage ../tools/backup/chunksync { };

     

       1745
       1745
        
       

     

       1746
       1746
        
         cipherscan = callPackage ../tools/security/cipherscan {

     

       1747
       1747
       -
           openssl = if stdenv.system == "x86_64-linux"

     

       1747
       1747
       +
           openssl = if stdenv.hostPlatform.system == "x86_64-linux"

     

       1748
       1748
        
             then openssl-chacha

     

       1749
       1749
        
             else openssl;

     

       1750
       1750
        
         };

     
···

       6428
       6428
        
         gcc8Stdenv = overrideCC gccStdenv gcc8;

     

       6429
       6429
        
       

     

       6430
       6430
        
         wrapCCMulti = cc:

     

       6431
       6431
       -
           if system == "x86_64-linux" then let

     

       6431
       6431
       +
           if stdenv.targetPlatform.system == "x86_64-linux" then let

     

       6432
       6432
        
             # Binutils with glibc multi

     

       6433
       6433
        
             bintools = cc.bintools.override {

     

       6434
       6434
        
               libc = glibc_multi;

     
···

       6448
       6448
        
             extraBuildCommands = ''

     

       6449
       6449
        
               echo "dontMoveLib64=1" >> $out/nix-support/setup-hook

     

       6450
       6450
        
             '';

     

       6451
       6451
       -
         }) else throw "Multilib ${cc.name} not supported on ‘${system}’";

     

       6451
       6451
       +
         }) else throw "Multilib ${cc.name} not supported for ‘${stdenv.targetPlatform.system}’";

     

       6452
       6452
        
       

     

       6453
       6453
        
         wrapClangMulti = clang:

     

       6454
       6454
       -
           if system == "x86_64-linux" then

     

       6454
       6454
       +
           if stdenv.targetPlatform.system == "x86_64-linux" then

     

       6455
       6455
        
             callPackage ../development/compilers/llvm/multi.nix {

     

       6456
       6456
        
               inherit clang;

     

       6457
       6457
        
               gcc32 = pkgsi686Linux.gcc;

     

       6458
       6458
        
               gcc64 = pkgs.gcc;

     

       6459
       6459
        
             }

     

       6460
       6460
       -
           else throw "Multilib ${clang.cc.name} not supported on '${system}'";

     

       6460
       6460
       +
           else throw "Multilib ${clang.cc.name} not supported for '${stdenv.targetPlatform.system}'";

     

       6461
       6461
        
       

     

       6462
       6462
        
         gcc_multi = wrapCCMulti gcc;

     

       6463
       6463
        
         clang_multi = wrapClangMulti clang;

     
···

       11137
       11137
        
         # Default derivation with libGL.so.1 to link into /run/opengl-drivers (if need)

     

       11138
       11138
        
         libGL_driver = libGLDarwinOr mesa_drivers;

     

       11139
       11139
        
       

     

       11140
       11140
       -
         libGLSupported = lib.elem system lib.platforms.mesaPlatforms;

     

       11140
       11140
       +
         libGLSupported = lib.elem stdenv.hostPlatform.system lib.platforms.mesaPlatforms;

     

       11141
       11141
        
       

     

       11142
       11142
        
         libGLDarwin = callPackage ../development/libraries/mesa-darwin {

     

       11143
       11143
        
           inherit (darwin.apple_sdk.frameworks) OpenGL;

     
···

       12410
       12410
        
       

     

       12411
       12411
        
         wxGTK28 = callPackage ../development/libraries/wxwidgets/2.8 {

     

       12412
       12412
        
           inherit (gnome2) GConf;

     

       12413
       12413
       -
           withMesa = lib.elem system lib.platforms.mesaPlatforms;

     

       12413
       12413
       +
           withMesa = lib.elem stdenv.hostPlatform.system lib.platforms.mesaPlatforms;

     

       12414
       12414
        
         };

     

       12415
       12415
        
       

     

       12416
       12416
        
         wxGTK29 = callPackage ../development/libraries/wxwidgets/2.9 {

     

       12417
       12417
        
           inherit (gnome2) GConf;

     

       12418
       12418
        
           inherit (darwin.stubs) setfile;

     

       12419
       12419
        
           inherit (darwin.apple_sdk.frameworks) AGL Carbon Cocoa Kernel QuickTime;

     

       12420
       12420
       -
           withMesa = lib.elem system lib.platforms.mesaPlatforms;

     

       12420
       12420
       +
           withMesa = lib.elem stdenv.hostPlatform.system lib.platforms.mesaPlatforms;

     

       12421
       12421
        
         };

     

       12422
       12422
        
       

     

       12423
       12423
        
         wxGTK30 = callPackage ../development/libraries/wxwidgets/3.0 {

     

       12424
       12424
        
           inherit (gnome2) GConf;

     

       12425
       12425
        
           inherit (darwin.stubs) setfile;

     

       12426
       12426
        
           inherit (darwin.apple_sdk.frameworks) AGL Carbon Cocoa Kernel QTKit;

     

       12427
       12427
       -
           withMesa = lib.elem system lib.platforms.mesaPlatforms;

     

       12427
       12427
       +
           withMesa = lib.elem stdenv.hostPlatform.system lib.platforms.mesaPlatforms;

     

       12428
       12428
        
         };

     

       12429
       12429
        
       

     

       12430
       12430
        
         wxGTK31 = callPackage ../development/libraries/wxwidgets/3.1 {};

     
···

       17648
       17648
        
           }) murmur_git;

     

       17649
       17649
        
       

     

       17650
       17650
        
         mumble_overlay = callPackage ../applications/networking/mumble/overlay.nix {

     

       17651
       17651
       -
           mumble_i686 = if system == "x86_64-linux"

     

       17651
       17651
       +
           mumble_i686 = if stdenv.hostPlatform.system == "x86_64-linux"

     

       17652
       17652
        
             then pkgsi686Linux.mumble

     

       17653
       17653
        
             else null;

     

       17654
       17654
        
         };

     
···

       19049
       19049
        
         };

     

       19050
       19050
        
       

     

       19051
       19051
        
         virtualgl = callPackage ../tools/X11/virtualgl {

     

       19052
       19052
       -
           virtualglLib_i686 = if system == "x86_64-linux"

     

       19052
       19052
       +
           virtualglLib_i686 = if stdenv.hostPlatform.system == "x86_64-linux"

     

       19053
       19053
        
             then pkgsi686Linux.virtualglLib

     

       19054
       19054
        
             else null;

     

       19055
       19055
        
         };

     
···

       19062
       19062
        
       

     

       19063
       19063
        
         primus = callPackage ../tools/X11/primus {

     

       19064
       19064
        
           stdenv_i686 = pkgsi686Linux.stdenv;

     

       19065
       19065
       -
           primusLib_i686 = if system == "x86_64-linux"

     

       19065
       19065
       +
           primusLib_i686 = if stdenv.hostPlatform.system == "x86_64-linux"

     

       19066
       19066
        
             then pkgsi686Linux.primusLib

     

       19067
       19067
        
             else null;

     

       19068
       19068
        
         };

     

       19069
       19069
        
       

     

       19070
       19070
        
         bumblebee = callPackage ../tools/X11/bumblebee {

     

       19071
       19071
        
           nvidia_x11 = linuxPackages.nvidia_x11;

     

       19072
       19072
       -
           nvidia_x11_i686 = if system == "x86_64-linux"

     

       19072
       19072
       +
           nvidia_x11_i686 = if stdenv.hostPlatform.system == "x86_64-linux"

     

       19073
       19073
        
             then pkgsi686Linux.linuxPackages.nvidia_x11.override { libsOnly = true; }

     

       19074
       19074
        
             else null;

     

       19075
       19075
       -
           libglvnd_i686 = if system == "x86_64-linux"

     

       19075
       19075
       +
           libglvnd_i686 = if stdenv.hostPlatform.system == "x86_64-linux"

     

       19076
       19076
        
             then pkgsi686Linux.libglvnd

     

       19077
       19077
        
             else null;

     

       19078
       19078
        
         };

     
···

       21629
       21629
        
          */

     

       21630
       21630
        
         nixos = configuration:

     

       21631
       21631
        
           (import (self.path + "/nixos/lib/eval-config.nix") {

     

       21632
       21632
       -
             inherit (pkgs) system;

     

       21632
       21632
       +
             inherit (pkgs.stdenv.hostPlatform) system;

     

       21633
       21633
        
             modules = [(

     

       21634
       21634
        
                         { lib, ... }: {

     

       21635
       21635
        
                           config.nixpkgs.pkgs = lib.mkDefault pkgs;

+3 -1

pkgs/top-level/ocaml-packages.nix

···

       1
       1
       -
       { lib, callPackage, newScope, pkgs, config, system }:

     

       1
       1
       +
       { lib, callPackage, newScope, pkgs, config }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       +
         inherit (pkgs.stdenv.hostPlatform) system;

     

       5
       5
       +
       

     

       4
       6
        
         mkOcamlPackages = ocaml: overrides:

     

       5
       7
        
           let

     

       6
       8
        
             packageSet = self:

+3 -3

pkgs/top-level/python-packages.nix

···

       2792
       2792
        
           };

     

       2793
       2793
        
         };

     

       2794
       2794
        
       

     

       2795
       2795
       -
         gurobipy = if stdenv.system == "x86_64-darwin"

     

       2795
       2795
       +
         gurobipy = if stdenv.hostPlatform.system == "x86_64-darwin"

     

       2796
       2796
        
         then callPackage ../development/python-modules/gurobipy/darwin.nix {

     

       2797
       2797
        
           inherit (pkgs.darwin) cctools insert_dylib;

     

       2798
       2798
        
         }

     

       2799
       2799
       -
         else if stdenv.system == "x86_64-linux"

     

       2799
       2799
       +
         else if stdenv.hostPlatform.system == "x86_64-linux"

     

       2800
       2800
        
         then callPackage ../development/python-modules/gurobipy/linux.nix {}

     

       2801
       2801
       -
         else throw "gurobipy not yet supported on ${stdenv.system}";

     

       2801
       2801
       +
         else throw "gurobipy not yet supported on ${stdenv.hostPlatform.system}";

     

       2802
       2802
        
       

     

       2803
       2803
        
         hbmqtt = callPackage ../development/python-modules/hbmqtt { };

     

       2804
       2804