Merge remote-tracking branch 'upstream/master' into staging

lib/systems/inspect.nix

@@ -16,6 +16,7 @@ rec {
     isAarch64      = { cpu = { family = "arm"; bits = 64; }; };
     isMips         = { cpu = { family = "mips"; }; };
     isRiscV        = { cpu = { family = "riscv"; }; };
+    isSparc        = { cpu = { family = "sparc"; }; };
     isWasm         = { cpu = { family = "wasm"; }; };
 
     is32bit        = { cpu = { bits = 32; }; };

lib/systems/parse.nix

@@ -93,6 +93,9 @@ rec {
     riscv32  = { bits = 32; significantByte = littleEndian; family = "riscv"; };
     riscv64  = { bits = 64; significantByte = littleEndian; family = "riscv"; };
 
+    sparc    = { bits = 32; significantByte = bigEndian;    family = "sparc"; };
+    sparc64  = { bits = 64; significantByte = bigEndian;    family = "sparc"; };
+
     wasm32   = { bits = 32; significantByte = littleEndian; family = "wasm"; };
     wasm64   = { bits = 64; significantByte = littleEndian; family = "wasm"; };
   };

lib/trivial.nix

@@ -1,43 +1,9 @@
 { lib }:
-let
-  zipIntBits = f: x: y:
-    let
-      # (intToBits 6) -> [ 0 1 1 ]
-      intToBits = x:
-        if x == 0 || x == -1 then
-          []
-        else
-          let
-            headbit  = if (x / 2) * 2 != x then 1 else 0;          # x & 1
-            tailbits = if x < 0 then ((x + 1) / 2) - 1 else x / 2; # x >> 1
-          in
-            [headbit] ++ (intToBits tailbits);
 
-      # (bitsToInt [ 0 1 1 ] 0) -> 6
-      # (bitsToInt [ 0 1 0 ] 1) -> -6
-      bitsToInt = l: signum:
-        if l == [] then
-          (if signum == 0 then 0 else -1)
-        else
-          (builtins.head l) + (2 * (bitsToInt (builtins.tail l) signum));
-
-      xsignum = if x < 0 then 1 else 0;
-      ysignum = if y < 0 then 1 else 0;
-      zipListsWith' = fst: snd:
-        if fst==[] && snd==[] then
-          []
-        else if fst==[] then
-          [(f xsignum             (builtins.head snd))] ++ (zipListsWith' []                  (builtins.tail snd))
-        else if snd==[] then
-          [(f (builtins.head fst) ysignum            )] ++ (zipListsWith' (builtins.tail fst) []                 )
-        else
-          [(f (builtins.head fst) (builtins.head snd))] ++ (zipListsWith' (builtins.tail fst) (builtins.tail snd));
-    in
-      assert (builtins.isInt x) && (builtins.isInt y);
-      bitsToInt (zipListsWith' (intToBits x) (intToBits y)) (f xsignum ysignum);
-in
 rec {
 
+  ## Simple (higher order) functions
+
   /* The identity function
      For when you need a function that does “nothing”.
 
@@ -59,7 +25,7 @@ rec {
 
   ## Named versions corresponding to some builtin operators.
 
-  /* Concat two strings */
+  /* Concatenate two lists */
   concat = x: y: x ++ y;
 
   /* boolean “or” */
@@ -69,13 +35,19 @@ rec {
   and = x: y: x && y;
 
   /* bitwise “and” */
-  bitAnd = builtins.bitAnd or zipIntBits (a: b: if a==1 && b==1 then 1 else 0);
+  bitAnd = builtins.bitAnd
+    or import ./zip-int-bits.nix
+      (a: b: if a==1 && b==1 then 1 else 0);
 
   /* bitwise “or” */
-  bitOr = builtins.bitOr or zipIntBits (a: b: if a==1 || b==1 then 1 else 0);
+  bitOr = builtins.bitOr
+    or import ./zip-int-bits.nix
+      (a: b: if a==1 || b==1 then 1 else 0);
 
   /* bitwise “xor” */
-  bitXor = builtins.bitXor or zipIntBits (a: b: if a!=b then 1 else 0);
+  bitXor = builtins.bitXor
+    or import ./zip-int-bits.nix
+      (a: b: if a!=b then 1 else 0);
 
   /* bitwise “not” */
   bitNot = builtins.sub (-1);
@@ -93,10 +65,22 @@ rec {
   */
   mergeAttrs = x: y: x // y;
 
-  # Flip the order of the arguments of a binary function.
+  /* Flip the order of the arguments of a binary function.
+
+     Example:
+       flip concat [1] [2]
+       => [ 2 1 ]
+  */
   flip = f: a: b: f b a;
 
-  # Apply function if argument is non-null
+  /* Apply function if argument is non-null.
+
+     Example:
+       mapNullable (x: x+1) null
+       => null
+       mapNullable (x: x+1) 22
+       => 23
+  */
   mapNullable = f: a: if isNull a then a else f a;
 
   # Pull in some builtins not included elsewhere.
@@ -105,20 +89,30 @@ rec {
     isInt isFloat add sub lessThan
     seq deepSeq genericClosure;
 
-  inherit (lib.strings) fileContents;
 
-  release = fileContents ../.version;
-  versionSuffix = let suffixFile = ../.version-suffix; in
-    if pathExists suffixFile then fileContents suffixFile else "pre-git";
+  ## nixpks version strings
 
-  # Return the Nixpkgs version number.
+  # The current full nixpkgs version number.
   version = release + versionSuffix;
 
+  # The current nixpkgs version number as string.
+  release = lib.strings.fileContents ../.version;
+
+  # The current nixpkgs version suffix as string.
+  versionSuffix =
+    let suffixFile = ../.version-suffix;
+    in if pathExists suffixFile
+    then lib.strings.fileContents suffixFile
+    else "pre-git";
+
   nixpkgsVersion = builtins.trace "`lib.nixpkgsVersion` is deprecated, use `lib.version` instead!" version;
 
   # Whether we're being called by nix-shell.
   inNixShell = builtins.getEnv "IN_NIX_SHELL" != "";
 
+
+  ## Integer operations
+
   # Return minimum/maximum of two numbers.
   min = x: y: if x < y then x else y;
   max = x: y: if x > y then x else y;
@@ -133,6 +127,9 @@ rec {
   */
   mod = base: int: base - (int * (builtins.div base int));
 
+
+  ## Comparisons
+
   /* C-style comparisons
 
      a < b,  compare a b => -1
@@ -162,17 +159,20 @@ rec {
        cmp "fooa" "a" => -1
        # while
        compare "fooa" "a" => 1
-
   */
   splitByAndCompare = p: yes: no: a: b:
     if p a
     then if p b then yes a b else -1
     else if p b then 1 else no a b;
 
+
   /* Reads a JSON file. */
   importJSON = path:
     builtins.fromJSON (builtins.readFile path);
 
+
+  ## Warnings and asserts
+
   /* See https://github.com/NixOS/nix/issues/749. Eventually we'd like these
      to expand to Nix builtins that carry metadata so that Nix can filter out
      the INFO messages without parsing the message string.
@@ -188,28 +188,36 @@ rec {
   warn = msg: builtins.trace "WARNING: ${msg}";
   info = msg: builtins.trace "INFO: ${msg}";
 
-  # | Add metadata about expected function arguments to a function.
-  # The metadata should match the format given by
-  # builtins.functionArgs, i.e. a set from expected argument to a bool
-  # representing whether that argument has a default or not.
-  # setFunctionArgs : (a → b) → Map String Bool → (a → b)
-  #
-  # This function is necessary because you can't dynamically create a
-  # function of the { a, b ? foo, ... }: format, but some facilities
-  # like callPackage expect to be able to query expected arguments.
+
+  ## Function annotations
+
+  /* Add metadata about expected function arguments to a function.
+     The metadata should match the format given by
+     builtins.functionArgs, i.e. a set from expected argument to a bool
+     representing whether that argument has a default or not.
+     setFunctionArgs : (a → b) → Map String Bool → (a → b)
+
+     This function is necessary because you can't dynamically create a
+     function of the { a, b ? foo, ... }: format, but some facilities
+     like callPackage expect to be able to query expected arguments.
+  */
   setFunctionArgs = f: args:
     { # TODO: Should we add call-time "type" checking like built in?
       __functor = self: f;
       __functionArgs = args;
     };
 
-  # | Extract the expected function arguments from a function.
-  # This works both with nix-native { a, b ? foo, ... }: style
-  # functions and functions with args set with 'setFunctionArgs'. It
-  # has the same return type and semantics as builtins.functionArgs.
-  # setFunctionArgs : (a → b) → Map String Bool.
+  /* Extract the expected function arguments from a function.
+     This works both with nix-native { a, b ? foo, ... }: style
+     functions and functions with args set with 'setFunctionArgs'. It
+     has the same return type and semantics as builtins.functionArgs.
+     setFunctionArgs : (a → b) → Map String Bool.
+  */
   functionArgs = f: f.__functionArgs or (builtins.functionArgs f);
 
+  /* Check whether something is a function or something
+     annotated with function args.
+  */
   isFunction = f: builtins.isFunction f ||
     (f ? __functor && isFunction (f.__functor f));
 }

lib/zip-int-bits.nix

@@ -0,0 +1,39 @@
+/* Helper function to implement a fallback for the bit operators
+   `bitAnd`, `bitOr` and `bitXOr` on older nix version.
+   See ./trivial.nix
+*/
+f: x: y:
+  let
+    # (intToBits 6) -> [ 0 1 1 ]
+    intToBits = x:
+      if x == 0 || x == -1 then
+        []
+      else
+        let
+          headbit  = if (x / 2) * 2 != x then 1 else 0;          # x & 1
+          tailbits = if x < 0 then ((x + 1) / 2) - 1 else x / 2; # x >> 1
+        in
+          [headbit] ++ (intToBits tailbits);
+
+    # (bitsToInt [ 0 1 1 ] 0) -> 6
+    # (bitsToInt [ 0 1 0 ] 1) -> -6
+    bitsToInt = l: signum:
+      if l == [] then
+        (if signum == 0 then 0 else -1)
+      else
+        (builtins.head l) + (2 * (bitsToInt (builtins.tail l) signum));
+
+    xsignum = if x < 0 then 1 else 0;
+    ysignum = if y < 0 then 1 else 0;
+    zipListsWith' = fst: snd:
+      if fst==[] && snd==[] then
+        []
+      else if fst==[] then
+        [(f xsignum             (builtins.head snd))] ++ (zipListsWith' []                  (builtins.tail snd))
+      else if snd==[] then
+        [(f (builtins.head fst) ysignum            )] ++ (zipListsWith' (builtins.tail fst) []                 )
+      else
+        [(f (builtins.head fst) (builtins.head snd))] ++ (zipListsWith' (builtins.tail fst) (builtins.tail snd));
+  in
+    assert (builtins.isInt x) && (builtins.isInt y);
+    bitsToInt (zipListsWith' (intToBits x) (intToBits y)) (f xsignum ysignum)

pkgs/applications/editors/eclipse/plugins.nix

@@ -555,12 +555,12 @@ rec {
 
   spotbugs = buildEclipseUpdateSite rec {
     name = "spotbugs-${version}";
-    version = "3.1.5";
+    version = "3.1.6";
 
     src = fetchzip {
       stripRoot = false;
       url = "https://github.com/spotbugs/spotbugs/releases/download/${version}/eclipsePlugin.zip";
-      sha256 = "0fxdirz6ik9rqykm2lcr720apsaqgngr4c7q793rjb9b3bn30c85";
+      sha256 = "1qsams12n64slp00nfc9v943sy9bzffzm7anqqaz2hjw64iia7fh";
     };
 
     meta = with stdenv.lib; {

pkgs/build-support/bintools-wrapper/default.nix

@@ -185,6 +185,8 @@ stdenv.mkDerivation {
           "mips64"   = "btsmip";
           "mips64el" = "ltsmip";
         }.${targetPlatform.parsed.cpu.name}
+      else if targetPlatform.isPowerPC then "powerpc"
+      else if targetPlatform.isSparc then "sparc"
       else throw "unknown emulation for platform: " + targetPlatform.config;
     in targetPlatform.platform.bfdEmulation or (fmt + sep + arch);
 

pkgs/development/python-modules/rfc7464/default.nix

@@ -0,0 +1,19 @@
+{ buildPythonPackage, fetchPypi, lib }:
+
+buildPythonPackage rec {
+  pname = "rfc7464";
+  version = "17.7.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "1hcn6h38qplfcmq392cs58r01k16k202bqyap4br02376pr4ik7a";
+    extension = "zip";
+  };
+
+  meta = with lib; {
+    homepage = https://github.com/moshez/rfc7464;
+    description = "RFC 7464 is a proposed standard for streaming JSON documents.";
+    license = [ licenses.mit ];
+    maintainers = with maintainers; [ shlevy ];
+  };
+}

pkgs/development/ruby-modules/gem-config/default.nix

@@ -206,6 +206,13 @@ in
     buildFlags = [ "--with-system-v8=true" ];
   };
 
+  libxml-ruby = attrs: {
+    buildFlags = [
+      "--with-xml2-lib=${libxml2.out}/lib"
+      "--with-xml2-include=${libxml2.dev}/include/libxml2"
+    ];
+  };
+
   msgpack = attrs: {
     buildInputs = [ libmsgpack ];
   };
@@ -395,4 +402,8 @@ in
     '';
   };
 
+   zookeeper = attrs: {
+     buildInputs = stdenv.lib.optionals stdenv.isDarwin [ darwin.cctools ];
+   };
+
 }

pkgs/top-level/python-packages.nix

@@ -17728,6 +17728,8 @@ EOF
   z3 = (toPythonModule (pkgs.z3.override {
     inherit python;
   })).python;
+
+  rfc7464 = callPackage ../development/python-modules/rfc7464 { };
 });
 
 in fix' (extends overrides packages)