@@ -1,798 +1,7 @@
1−{ nixpkgsFunc ? import ./nixpkgs
2−, system ? builtins.currentSystem
3−, config ? {}
4−, enableLibraryProfiling ? false
5−, enableExposeAllUnfoldings ? true
6−, enableTraceReflexEvents ? false
7−, useFastWeak ? true
8−, useReflexOptimizer ? false
9−, useTextJSString ? true
10−, __useLegacyCompilers ? false # Interface unstable
11−, iosSdkVersion ? "10.2"
12−, nixpkgsOverlays ? []
13−, haskellOverlays ? []
14−}:
15−let iosSupport = system == "x86_64-darwin";
16− androidSupport = lib.elem system [ "x86_64-linux" ];
17−
18− # Overlay for GHC with -load-splices & -save-splices option
19− splicesEval = self: super: {
20− haskell = super.haskell // {
21− compiler = super.haskell.compiler // {
22− ghcSplices-8_4 = super.haskell.compiler.ghc843.overrideAttrs (drv: {
23− enableParallelBuilding = false;
24− patches = (drv.patches or [])
25− ++ [ ./splices-load-save.patch ./haddock.patch ];
26− });
27− };
28− packages = super.haskell.packages // {
29− ghcSplices-8_4 = super.haskell.packages.ghc843.override {
30− buildHaskellPackages = self.buildPackages.haskell.packages.ghcSplices-8_4;
31− ghc = self.buildPackages.haskell.compiler.ghcSplices-8_4;
32− };
33− };
34− };
35− };
36−
37− bindHaskellOverlays = self: super: {
38− haskell = super.haskell // {
39− overlays = super.overlays or {} // import ./haskell-overlays {
40− nixpkgs = self;
41− inherit
42− haskellLib
43− fetchFromGitHub hackGet
44− ghcjsBaseSrc ghcjsBaseTextJSStringSrc
45− useFastWeak useReflexOptimizer enableLibraryProfiling enableTraceReflexEvents
46− useTextJSString enableExposeAllUnfoldings
47− stage2Script
48− optionalExtension
49− haskellOverlays;
50− inherit ghcSavedSplices;
51− inherit (self) lib;
52− androidActivity = hackGet ./android-activity;
53− };
54− };
55− };
56−
57− forceStaticLibs = self: super: {
58− darwin = super.darwin // {
59− libiconv = super.darwin.libiconv.overrideAttrs (_:
60− lib.optionalAttrs (self.stdenv.hostPlatform != self.stdenv.buildPlatform) {
61− postInstall = "rm $out/include/libcharset.h $out/include/localcharset.h";
62− configureFlags = ["--disable-shared" "--enable-static"];
63− });
64− };
65− zlib = super.zlib.override (lib.optionalAttrs
66− (self.stdenv.hostPlatform != self.stdenv.buildPlatform)
67− { static = true; });
68− };
69−
70− mobileGhcOverlay = import ./nixpkgs-overlays/mobile-ghc { inherit lib; };
71−
72− nixpkgsArgs = {
73− inherit system;
74− overlays = [
75− bindHaskellOverlays
76− forceStaticLibs
77− mobileGhcOverlay
78− splicesEval
79− ] ++ nixpkgsOverlays;
80− config = {
81− permittedInsecurePackages = [
82− "webkitgtk-2.4.11"
83− ];
84− packageOverrides = pkgs: {
85− webkitgtk = pkgs.webkitgtk220x;
86− };
87−
88− # XCode needed for native macOS app
89− # Obelisk needs it to for some reason
90− allowUnfree = true;
91− } // config;
92− };
93−
94− nixpkgs = nixpkgsFunc nixpkgsArgs;
95−
96− inherit (nixpkgs) lib fetchurl fetchgit fetchgitPrivate fetchFromGitHub;
97−
98− nixpkgsCross = {
99− android = lib.mapAttrs (_: args: nixpkgsFunc (nixpkgsArgs // args)) rec {
100− aarch64 = {
101− crossSystem = lib.systems.examples.aarch64-android-prebuilt;
102− };
103− aarch32 = {
104− crossSystem = lib.systems.examples.armv7a-android-prebuilt // {
105− # Hard to find newer 32-bit phone to test with that's newer than
106− # this. Concretely, doing so resulted in:
107− # https://android.googlesource.com/platform/bionic/+/master/libc/arch-common/bionic/pthread_atfork.h#19
108− sdkVer = "22";
109− };
110− };
111− # Back compat
112− arm64 = lib.warn "nixpkgsCross.android.arm64 has been deprecated, using nixpkgsCross.android.aarch64 instead." aarch64;
113− armv7a = lib.warn "nixpkgsCross.android.armv7a has been deprecated, using nixpkgsCross.android.aarch32 instead." aarch32;
114− arm64Impure = lib.warn "nixpkgsCross.android.arm64Impure has been deprecated, using nixpkgsCross.android.aarch64 instead." aarch64;
115− armv7aImpure = lib.warn "nixpkgsCross.android.armv7aImpure has been deprecated, using nixpkgsCross.android.aarch32 instead." aarch32;
116− };
117− ios = lib.mapAttrs (_: args: nixpkgsFunc (nixpkgsArgs // args)) rec {
118− simulator64 = {
119− crossSystem = lib.systems.examples.iphone64-simulator // {
120− sdkVer = iosSdkVersion;
121− };
122− };
123− aarch64 = {
124− crossSystem = lib.systems.examples.iphone64 // {
125− sdkVer = iosSdkVersion;
126− };
127− };
128− aarch32 = {
129− crossSystem = lib.systems.examples.iphone32 // {
130− sdkVer = iosSdkVersion;
131− };
132− };
133− # Back compat
134− arm64 = lib.warn "nixpkgsCross.ios.arm64 has been deprecated, using nixpkgsCross.ios.aarch64 instead." aarch64;
135− };
136− };
137−
138− haskellLib = nixpkgs.haskell.lib;
139−
140− filterGit = builtins.filterSource (path: type: !(builtins.any (x: x == baseNameOf path) [".git" "tags" "TAGS" "dist"]));
141−
142− # Retrieve source that is controlled by the hack-* scripts; it may be either a stub or a checked-out git repo
143− hackGet = p:
144− let filterArgs = x: removeAttrs x [ "branch" ];
145− in if builtins.pathExists (p + "/git.json") then (
146− let gitArgs = filterArgs (builtins.fromJSON (builtins.readFile (p + "/git.json")));
147− in if builtins.elem "@" (lib.stringToCharacters gitArgs.url)
148− then fetchgitPrivate gitArgs
149− else fetchgit gitArgs)
150− else if builtins.pathExists (p + "/github.json") then fetchFromGitHub (filterArgs (builtins.fromJSON (builtins.readFile (p + "/github.json"))))
151− else {
152− name = baseNameOf p;
153− outPath = filterGit p;
154− };
155−
156− # All imports of sources need to go here, so that they can be explicitly cached
157− sources = {
158− ghcjs8_0 = {
159− boot = hackGet ./ghcjs-8.0/boot;
160− shims = hackGet ./ghcjs-8.0/shims;
161− ghcjs = hackGet ./ghcjs-8.0/ghcjs;
162− };
163− };
164−
165− optionalExtension = cond: overlay: if cond then overlay else _: _: {};
166−
167− applyPatch = patch: src: nixpkgs.runCommand "applyPatch" {
168− inherit src patch;
169− } ''
170− cp -r "$src" "$out"
171−
172− cd "$out"
173− chmod -R +w .
174− patch -p1 <"$patch"
175− '';
176−
177− overrideCabal = pkg: f: if pkg == null then null else haskellLib.overrideCabal pkg f;
178−
179− replaceSrc = pkg: src: version: overrideCabal pkg (drv: {
180− inherit src version;
181− sha256 = null;
182− revision = null;
183− editedCabalFile = null;
184− });
185−
186− combineOverrides = old: new: old // new // lib.optionalAttrs (old ? overrides && new ? overrides) {
187− overrides = lib.composeExtensions old.overrides new.overrides;
188− };
189−
190− # Makes sure that old `overrides` from a previous call to `override` are not
191− # forgotten, but composed. Do this by overriding `override` and passing a
192− # function which takes the old argument set and combining it. What a tongue
193− # twister!
194− makeRecursivelyOverridable = x: x // {
195− override = new: makeRecursivelyOverridable (x.override (old: (combineOverrides old new)));
196− };
197−
198− foreignLibSmuggleHeaders = pkg: overrideCabal pkg (drv: {
199− postInstall = ''
200− cd dist/build/${pkg.pname}/${pkg.pname}-tmp
201− for header in $(find . | grep '\.h'$); do
202− local dest_dir=$out/include/$(dirname "$header")
203− mkdir -p "$dest_dir"
204− cp "$header" "$dest_dir"
205− done
206− '';
207− });
208−
209− cabal2nixResult = src: builtins.trace "cabal2nixResult is deprecated; use ghc.haskellSrc2nix or ghc.callCabal2nix instead" (ghc.haskellSrc2nix {
210− name = "for-unknown-package";
211− src = "file://${src}";
212− sha256 = null;
213− });
214−
215− stage2Script = nixpkgs.runCommand "stage2.nix" {
216− GEN_STAGE2 = builtins.readFile (nixpkgs.path + "/pkgs/development/compilers/ghcjs/gen-stage2.rb");
217− buildCommand = ''
218− echo "$GEN_STAGE2" > gen-stage2.rb && chmod +x gen-stage2.rb
219− patchShebangs .
220− ./gen-stage2.rb "${sources.ghcjs8_0.boot}" >"$out"
221− '';
222− nativeBuildInputs = with nixpkgs; [
223− ruby cabal2nix
224− ];
225− } "";
226−
227− ghcjsApplyFastWeak = ghcjs: ghcjs.overrideAttrs (drv: {
228− patches = (drv.patches or [])
229− ++ lib.optional useFastWeak ./fast-weak.patch;
230− phases = [ "unpackPhase" "patchPhase" "buildPhase" ];
231− });
232− useTextJSStringAsBootPkg = ghcjs: if !useTextJSString then ghcjs else ghcjs.overrideAttrs (_: {
233− postUnpack = ''
234− set -x
235− (
236− echo $sourceRoot
237− cd $sourceRoot
238− rm -r lib/boot/pkg/text
239− cp --no-preserve=mode -r "${textSrc}" lib/boot/pkg/text
240− cp --no-preserve=mode -r "${ghcjsBaseTextJSStringSrc}" lib/boot/pkg/ghcjs-base
241− cp --no-preserve=mode -r "${dlistSrc}" lib/boot/pkg/dlist
242− rm -r lib/boot/pkg/vector
243− cp --no-preserve=mode -r "${vectorSrc}" lib/boot/pkg/vector
244− sed -i 's/.\/pkg\/mtl/.\/pkg\/mtl\n - .\/pkg\/ghcjs-base\n - .\/pkg\/dlist\n - .\/pkg\/primitive\n - .\/pkg\/vector/' lib/boot/boot.yaml
245− cat lib/boot/boot.yaml
246− )
247− '';
248− });
249− ghcjsBaseSrc = fetchgit {
250− url = "https://github.com/ghcjs/ghcjs-base.git";
251− rev = "01014ade3f8f5ae677df192d7c2a208bd795b96c";
252− sha256 = "173h98m7namxj0kfy8fj29qcxmcz6ilg04x8mwkc3ydjqrvk77hh";
253− postFetch = ''
254− ( cd $out
255− patch -p1 < ${nixpkgs.fetchpatch {
256− url = "https://github.com/ghcjs/ghcjs-base/commit/2d0d674e54c273ed5fcb9a13f588819c3303a865.patch"; #ghcjs-base/114
257− sha256 = "15vbxnxa1fpdcmmx5zx1z92bzsxyb0cbs3hs3g7fb1rkds5qbvgp";
258− }}
259− patch -p1 < ${nixpkgs.fetchpatch {
260− url = "https://github.com/ghcjs/ghcjs-base/commit/8eccb8d937041ba323d62dea6fe8eb1b04b3cc47.patch"; #ghcjs-base/116
261− sha256 = "1lqjpg46ydpm856wcq1g7c97d69qcnnqs5jxp2b788z9cfd5n64c";
262− }}
263− patch -p1 < ${nixpkgs.fetchpatch {
264− url = "https://github.com/ghcjs/ghcjs-base/commit/ce91c525b5d4377ba4aefd0d8072dc1659f75ef1.patch"; #ghcjs-base/118
265− sha256 = "0f6qca1i60cjzpbq4bc74baa7xrf417cja8nmhfims1fflvsx3wy";
266− }}
267− patch -p1 < ${nixpkgs.fetchpatch {
268− url = "https://github.com/ghcjs/ghcjs-base/commit/213bfc74a051242668edf0533e11a3fafbbb1bfe.patch"; #ghcjs-base/120
269− sha256 = "0d5dwy22hxa79l8b4y6nn53nbcs74686s0rmfr5l63sdvqxhdy3x";
270− }}
271− patch -p1 < ${nixpkgs.fetchpatch {
272− url = "https://github.com/ghcjs/ghcjs-base/commit/82d76814ab40dc9116990f69f16df330462f27d4.patch"; #ghcjs-base/121
273− sha256 = "0qa74h6w8770csad0bky4hhss1b1s86i6ccpd3ky4ljx00272gqh";
274− }}
275− patch -p1 < ${nixpkgs.fetchpatch {
276− url = "https://github.com/ghcjs/ghcjs-base/commit/5eb34b3dfc6fc9196931178a7a6e2c8a331a8e53.patch"; #ghcjs-base/122
277− sha256 = "1wrfi0rscy8qa9pi4siv54pq5alplmy56ym1fbs8n93xwlqhddii";
278− }}
279− patch -p1 < ${nixpkgs.fetchpatch {
280− url = "https://github.com/ghcjs/ghcjs-base/commit/0cf64df77cdd6275d86ec6276fcf947fa58e548b.patch"; #ghcjs-base/122
281− sha256 = "16wdghfsrzrb1y7lscbf9aawgxi3kvbgdjwvl1ga2zzm4mq139dr";
282− }}
283− cat ghcjs-base.cabal
284− )
285− '';
286− };
287− ghcjsBaseTextJSStringSrc = ghcjsBaseSrc.overrideAttrs (drv: {
288− outputHash = "1ggfklrmawqh54ins98rpr7qy3zbcqaqp1w7qmh90mq5jf711x9r";
289− postFetch = (drv.postFetch or "") + ''
290− ( cd $out
291− patch -p1 < ${./haskell-overlays/text-jsstring/ghcjs-base-text-jsstring.patch}
292− )
293− '';
294− });
295−
296− textSrc = fetchgit {
297− url = "https://github.com/obsidiansystems/text.git";
298− rev = "50076be0262203f0d2afdd0b190a341878a08e21";
299− sha256 = "1vy7a81b1vcbfhv7l3m7p4hx365ss13mzbzkjn9751bn4n7x2ydd";
300− };
301− dlistSrc = fetchgit {
302− url = "https://github.com/spl/dlist.git";
303− rev = "03d91a3000cba49bd2c8588cf1b0d71e229ad3b0"; #v0.8.0.4
304− sha256 = "0asvz1a2rp174r3vvgs1qaidxbdxly4mnlra33dipd0gxrrk15sq";
305− };
306− vectorSrc = fetchgit {
307− url = "https://github.com/haskell/vector.git";
308− rev = "1d208ee9e3a252941ebd112e14e8cd5a982ac2bb"; #v0.12.0.1
309− sha256 = "18qm1c2zqr8h150917djfc0xk62hv99b1clxfs9a79aavrsqi5hs";
310− postFetch = ''
311− substituteInPlace $out/vector.cabal --replace 'base >= 4.5 && < 4.10' 'base >= 4.5 && < 5'
312− '';
313− };
314−
315− ghcSavedSplices = ghcSavedSplices-8_4;
316− ghcSavedSplices-8_4 = (makeRecursivelyOverridable nixpkgs.haskell.packages.integer-simple.ghcSplices-8_4).override {
317− overrides = lib.foldr lib.composeExtensions (_: _: {}) (let
318− haskellOverlays = nixpkgs.haskell.overlays;
319− in [
320− haskellOverlays.combined
321− haskellOverlays.saveSplices
322− (self: super: with haskellLib; {
323− cryptonite = disableCabalFlag super.cryptonite "integer-gmp";
324− integer-logarithms = disableCabalFlag super.integer-logarithms "integer-gmp";
325− scientific = enableCabalFlag super.scientific "integer-simple";
326− dependent-sum-template = dontCheck super.dependent-sum-template;
327− generic-deriving = dontCheck super.generic-deriving;
328− })
329− ]);
330− };
331− ghcjs = if __useLegacyCompilers then ghcjs8_0 else ghcjs8_4;
332− ghcjs8_4 = (makeRecursivelyOverridable (nixpkgs.haskell.packages.ghcjs84.override (old: {
333− ghc = useTextJSStringAsBootPkg (ghcjsApplyFastWeak (old.ghc.override {
334− ghcjsSrc = fetchgit {
335− url = "https://github.com/obsidiansystems/ghcjs.git";
336− rev = "584eaa138c32c5debb3aae571c4153d537ff58f1";
337− sha256 = "1ib0vsv2wrwf5iivnq6jw2l9g5izs0fjpp80jrd71qyywx4xcm66";
338− fetchSubmodules = true;
339− };
340− }));
341− }))).override {
342− overrides = nixpkgs.haskell.overlays.combined;
343− };
344− ghcjs8_2 = (makeRecursivelyOverridable (nixpkgs.haskell.packages.ghcjs82.override (old: {
345− ghc = ghcjsApplyFastWeak (old.ghc.override {
346− ghcjsDepOverrides = self: super: {
347− haddock-library-ghcjs = haskellLib.doJailbreak super.haddock-library-ghcjs;
348− };
349− });
350− }))).override {
351− overrides = nixpkgs.haskell.overlays.combined;
352− };
353− ghcjs8_0 = (makeRecursivelyOverridable (nixpkgs.haskell.packages.ghcjs80.override (old: {
354− ghc = (import "${nixpkgs.path}/pkgs/development/compilers/ghcjs/8.0" {
355− bootPkgs = nixpkgs.haskell.packages.ghc802.override {
356− overrides = self: super: {
357− # Newer versions no longer export `(<>)`, because that is now
358− # understand to be monoid/semigroup append.
359− wl-pprint-text = haskellLib.doJailbreak (self.callHackage "wl-pprint-text" "1.1.1.0" {});
360− # Old `wl-pprint-text` in turn doesn't expect `base-compat` to provide
361− # a `(<>)`, since it is defining its own.
362− base-compat = self.callHackage "base-compat" "0.9.3" {};
363− # relax bounds for newer process
364− concurrent-output = haskellLib.doJailbreak super.concurrent-output;
365− # missing semigroups pkg
366− ListLike = haskellLib.addBuildDepend super.ListLike self.semigroups;
367− };
368− };
369− inherit (nixpkgs) cabal-install;
370− inherit (nixpkgs.buildPackages) fetchgit fetchFromGitHub;
371− }).override {
372− ghcjsSrc = sources.ghcjs8_0.ghcjs;
373− ghcjsBootSrc = sources.ghcjs8_0.boot;
374− shims = sources.ghcjs8_0.shims;
375− stage2 = import stage2Script;
376− };
377− }))).override {
378− overrides = nixpkgs.haskell.overlays.combined;
379− };
380−
381− ghc = if __useLegacyCompilers then ghc8_0 else ghc8_4;
382− ghcHEAD = (makeRecursivelyOverridable nixpkgs.haskell.packages.ghcHEAD).override {
383− overrides = nixpkgs.haskell.overlays.combined;
384− };
385− ghc8_4 = (makeRecursivelyOverridable nixpkgs.haskell.packages.ghc843).override {
386− overrides = nixpkgs.haskell.overlays.combined;
387− };
388− ghc8_2 = (makeRecursivelyOverridable nixpkgs.haskell.packages.ghc822).override {
389− overrides = nixpkgs.haskell.overlays.combined;
390− };
391− ghc8_0 = (makeRecursivelyOverridable nixpkgs.haskell.packages.ghc802).override {
392− overrides = nixpkgs.haskell.overlays.combined;
393− };
394− ghc7 = (makeRecursivelyOverridable nixpkgs.haskell.packages.ghc7103).override {
395− overrides = nixpkgs.haskell.overlays.combined;
396− };
397−
398− # Takes a package set with `makeRecursivelyOverridable` and ensures that any
399− # future overrides will be applied to both the package set itself and it's
400− # build-time package set (`buildHaskellPackages`).
401− makeRecursivelyOverridableBHPToo = x: x // {
402− override = new: makeRecursivelyOverridableBHPToo (x.override
403− (combineOverrides
404− {
405− overrides = self: super: {
406− buildHaskellPackages = super.buildHaskellPackages.override new;
407− };
408− }
409− new));
410− };
411−
412− ghcAndroidAarch64 = if __useLegacyCompilers then ghcAndroidAarch64-8_2 else ghcAndroidAarch64-8_4;
413− ghcAndroidAarch64-8_4 = makeRecursivelyOverridableBHPToo ((makeRecursivelyOverridable nixpkgsCross.android.aarch64.haskell.packages.integer-simple.ghcSplices-8_4).override {
414− overrides = nixpkgsCross.android.aarch64.haskell.overlays.combined;
415− });
416− ghcAndroidAarch64-8_2 = (makeRecursivelyOverridable nixpkgsCross.android.aarch64.haskell.packages.integer-simple.ghc822).override {
417− overrides = nixpkgsCross.android.aarch64.haskell.overlays.combined;
418− };
419− ghcAndroidAarch32 = if __useLegacyCompilers then ghcAndroidAarch32-8_2 else ghcAndroidAarch32-8_4;
420− ghcAndroidAarch32-8_4 = makeRecursivelyOverridableBHPToo ((makeRecursivelyOverridable nixpkgsCross.android.aarch32.haskell.packages.integer-simple.ghcSplices-8_4).override {
421− overrides = nixpkgsCross.android.aarch32.haskell.overlays.combined;
422− });
423− ghcAndroidAarch32-8_2 = (makeRecursivelyOverridable nixpkgsCross.android.aarch32.haskell.packages.integer-simple.ghc822).override {
424− overrides = nixpkgsCross.android.aarch32.haskell.overlays.combined;
425− };
426−
427− ghcIosSimulator64 = if __useLegacyCompilers then ghcIosSimulator64-8_2 else ghcIosSimulator64-8_4;
428− ghcIosSimulator64-8_4 = makeRecursivelyOverridableBHPToo ((makeRecursivelyOverridable nixpkgsCross.ios.simulator64.haskell.packages.integer-simple.ghcSplices-8_4).override {
429− overrides = nixpkgsCross.ios.simulator64.haskell.overlays.combined;
430− });
431− ghcIosSimulator64-8_2 = (makeRecursivelyOverridable nixpkgsCross.ios.simulator64.haskell.packages.integer-simple.ghc822).override {
432− overrides = nixpkgsCross.ios.simulator64.haskell.overlays.combined;
433− };
434− ghcIosAarch64 = if __useLegacyCompilers then ghcIosAarch64-8_2 else ghcIosAarch64-8_4;
435− ghcIosAarch64-8_4 = makeRecursivelyOverridableBHPToo ((makeRecursivelyOverridable nixpkgsCross.ios.aarch64.haskell.packages.integer-simple.ghcSplices-8_4).override {
436− overrides = nixpkgsCross.ios.aarch64.haskell.overlays.combined;
437− });
438− ghcIosAarch64-8_2 = (makeRecursivelyOverridable nixpkgsCross.ios.aarch64.haskell.packages.integer-simple.ghc822).override {
439− overrides = nixpkgsCross.ios.aarch64.haskell.overlays.combined;
440− };
441− ghcIosAarch32 = if __useLegacyCompilers then ghcIosAarch32-8_2 else ghcIosAarch32-8_4;
442− ghcIosAarch32-8_4 = makeRecursivelyOverridableBHPToo ((makeRecursivelyOverridable nixpkgsCross.ios.aarch32.haskell.packages.integer-simple.ghcSplices-8_4).override {
443− overrides = nixpkgsCross.ios.aarch32.haskell.overlays.combined;
444− });
445− ghcIosAarch32-8_2 = (makeRecursivelyOverridable nixpkgsCross.ios.aarch32.haskell.packages.integer-simple.ghc822).override {
446− overrides = nixpkgsCross.ios.aarch32.haskell.overlays.combined;
447− };
448−
449− #TODO: Separate debug and release APKs
450− #TODO: Warn the user that the android app name can't include dashes
451− android = androidWithHaskellPackages {
452− inherit ghcAndroidAarch64 ghcAndroidAarch32;
453− };
454− android-8_4 = androidWithHaskellPackages {
455− ghcAndroidAarch64 = ghcAndroidAarch64-8_4;
456− ghcAndroidAarch32 = ghcAndroidAarch32-8_4;
457− };
458− android-8_2 = androidWithHaskellPackages {
459− ghcAndroidAarch64 = ghcAndroidAarch64-8_2;
460− ghcAndroidAarch32 = ghcAndroidAarch32-8_2;
461− };
462− androidWithHaskellPackages = { ghcAndroidAarch64, ghcAndroidAarch32 }: import ./android {
463− inherit nixpkgs nixpkgsCross ghcAndroidAarch64 ghcAndroidAarch32 overrideCabal;
464− };
465− iosAarch64 = iosWithHaskellPackages ghcIosAarch64;
466− iosAarch64-8_4 = iosWithHaskellPackages ghcIosAarch64-8_4;
467− iosAarch64-8_2 = iosWithHaskellPackages ghcIosAarch64-8_2;
468− iosAarch32 = iosWithHaskellPackages ghcIosAarch32;
469− iosAarch32-8_4 = iosWithHaskellPackages ghcIosAarch32-8_4;
470− iosAarch32-8_2 = iosWithHaskellPackages ghcIosAarch32-8_2;
471− iosWithHaskellPackages = ghc: {
472− buildApp = import ./ios { inherit nixpkgs ghc; };
473− };
474−
475−in let this = rec {
476− inherit nixpkgs
477− nixpkgsCross
478− overrideCabal
479− hackGet
480− foreignLibSmuggleHeaders
481− stage2Script
482− ghc
483− ghcHEAD
484− ghc8_4
485− ghc8_2
486− ghc8_0
487− ghc7
488− ghcIosSimulator64
489− ghcIosAarch64
490− ghcIosAarch64-8_4
491− ghcIosAarch64-8_2
492− ghcIosAarch32
493− ghcIosAarch32-8_4
494− ghcIosAarch32-8_2
495− ghcAndroidAarch64
496− ghcAndroidAarch64-8_4
497− ghcAndroidAarch64-8_2
498− ghcAndroidAarch32
499− ghcAndroidAarch32-8_4
500− ghcAndroidAarch32-8_2
501− ghcjs
502− ghcjs8_0
503− ghcjs8_2
504− ghcjs8_4
505− ghcSavedSplices
506− android
507− androidWithHaskellPackages
508− iosAarch32
509− iosAarch64
510− iosWithHaskellPackages
511− filterGit;
512−
513− # Back compat
514− ios = iosAarch64;
515− ghcAndroidArm64 = lib.warn "ghcAndroidArm64 has been deprecated, using ghcAndroidAarch64 instead." ghcAndroidAarch64;
516− ghcAndroidArmv7a = lib.warn "ghcAndroidArmv7a has been deprecated, using ghcAndroidAarch32 instead." ghcAndroidAarch32;
517− ghcIosArm64 = lib.warn "ghcIosArm64 has been deprecated, using ghcIosAarch64 instead." ghcIosAarch64;
518−
519− androidReflexTodomvc = android.buildApp {
520− package = p: p.reflex-todomvc;
521− executableName = "reflex-todomvc";
522− applicationId = "org.reflexfrp.todomvc";
523− displayName = "Reflex TodoMVC";
524− };
525− androidReflexTodomvc-8_4 = android-8_4.buildApp {
526− package = p: p.reflex-todomvc;
527− executableName = "reflex-todomvc";
528− applicationId = "org.reflexfrp.todomvc.via_8_4";
529− displayName = "Reflex TodoMVC via GHC 8.4";
530− };
531− androidReflexTodomvc-8_2 = android-8_2.buildApp {
532− package = p: p.reflex-todomvc;
533− executableName = "reflex-todomvc";
534− applicationId = "org.reflexfrp.todomvc.via_8_2";
535− displayName = "Reflex TodoMVC via GHC 8.2";
536− };
537− iosReflexTodomvc = ios.buildApp {
538− package = p: p.reflex-todomvc;
539− executableName = "reflex-todomvc";
540− bundleIdentifier = "org.reflexfrp.todomvc";
541− bundleName = "Reflex TodoMVC";
542− };
543− iosReflexTodomvc-8_4 = iosAarch64-8_4.buildApp {
544− package = p: p.reflex-todomvc;
545− executableName = "reflex-todomvc";
546− bundleIdentifier = "org.reflexfrp.todomvc.via_8_4";
547− bundleName = "Reflex TodoMVC via GHC 8.4";
548− };
549− iosReflexTodomvc-8_2 = iosAarch64-8_2.buildApp {
550− package = p: p.reflex-todomvc;
551− executableName = "reflex-todomvc";
552− bundleIdentifier = "org.reflexfrp.todomvc.via_8_2";
553− bundleName = "Reflex TodoMVC via GHC 8.2";
554− };
555− setGhcLibdir = ghcLibdir: inputGhcjs:
556− let libDir = "$out/lib/ghcjs-${inputGhcjs.version}";
557− ghcLibdirLink = nixpkgs.stdenv.mkDerivation {
558− name = "ghc_libdir";
559− inherit ghcLibdir;
560− buildCommand = ''
561− mkdir -p ${libDir}
562− echo "$ghcLibdir" > ${libDir}/ghc_libdir_override
563− '';
564− };
565− in inputGhcjs // {
566− outPath = nixpkgs.buildEnv {
567− inherit (inputGhcjs) name;
568− paths = [ inputGhcjs ghcLibdirLink ];
569− postBuild = ''
570− mv ${libDir}/ghc_libdir_override ${libDir}/ghc_libdir
571− '';
572− };
573− };
574−
575− platforms = [
576− "ghcjs"
577− "ghc"
578− ];
579−
580− attrsToList = s: map (name: { inherit name; value = builtins.getAttr name s; }) (builtins.attrNames s);
581− mapSet = f: s: builtins.listToAttrs (map ({name, value}: {
582− inherit name;
583− value = f value;
584− }) (attrsToList s));
585− mkSdist = pkg: pkg.override (oldArgs: {
586− mkDerivation = drv: oldArgs.mkDerivation (drv // {
587− postConfigure = ''
588− ./Setup sdist
589− mkdir "$out"
590− mv dist/*.tar.gz "$out/${drv.pname}-${drv.version}.tar.gz"
591− exit 0
592− '';
593− doHaddock = false;
594− });
595− });
596− sdists = mapSet mkSdist ghc;
597− mkHackageDocs = pkg: pkg.override (oldArgs: {
598− mkDerivation = drv: oldArgs.mkDerivation (drv // {
599− postConfigure = ''
600− ./Setup haddock --hoogle --hyperlink-source --html --for-hackage --haddock-option=--built-in-themes
601− cd dist/doc/html
602− mkdir "$out"
603− tar cz --format=ustar -f "$out/${drv.pname}-${drv.version}-docs.tar.gz" "${drv.pname}-${drv.version}-docs"
604− exit 0
605− '';
606− doHaddock = false;
607− });
608− });
609− hackageDocs = mapSet mkHackageDocs ghc;
610− mkReleaseCandidate = pkg: nixpkgs.stdenv.mkDerivation (rec {
611− name = pkg.name + "-rc";
612− sdist = mkSdist pkg + "/${pkg.pname}-${pkg.version}.tar.gz";
613− docs = mkHackageDocs pkg + "/${pkg.pname}-${pkg.version}-docs.tar.gz";
614−
615− builder = builtins.toFile "builder.sh" ''
616− source $stdenv/setup
617−
618− mkdir "$out"
619− echo -n "${pkg.pname}-${pkg.version}" >"$out/pkgname"
620− ln -s "$sdist" "$docs" "$out"
621− '';
622−
623− # 'checked' isn't used, but it is here so that the build will fail
624− # if tests fail
625− checked = overrideCabal pkg (drv: {
626− doCheck = true;
627− src = sdist;
628− });
629− });
630− releaseCandidates = mapSet mkReleaseCandidate ghc;
631−
632− androidDevTools = [
633− ghc.haven
634− nixpkgs.maven
635− nixpkgs.androidsdk
636− ];
637−
638− # Tools that are useful for development under both ghc and ghcjs
639− generalDevToolsAttrs = haskellPackages:
640− let nativeHaskellPackages = ghc;
641− in {
642− inherit (nativeHaskellPackages)
643− Cabal
644− cabal-install
645− ghcid
646− hasktags
647− hlint;
648− inherit (nixpkgs)
649− cabal2nix
650− curl
651− nix-prefetch-scripts
652− nodejs
653− pkgconfig
654− closurecompiler;
655− } // (lib.optionalAttrs (!(haskellPackages.ghc.isGhcjs or false) && builtins.compareVersions haskellPackages.ghc.version "8.2" < 0) {
656− # ghc-mod doesn't currently work on ghc 8.2.2; revisit when https://github.com/DanielG/ghc-mod/pull/911 is closed
657− # When ghc-mod is included in the environment without being wrapped in justStaticExecutables, it prevents ghc-pkg from seeing the libraries we install
658− ghc-mod = (nixpkgs.haskell.lib.justStaticExecutables haskellPackages.ghc-mod);
659− inherit (haskellPackages) hdevtools;
660− }) // (lib.optionalAttrs (builtins.compareVersions haskellPackages.ghc.version "7.10" >= 0) {
661− inherit (nativeHaskellPackages) stylish-haskell; # Recent stylish-haskell only builds with AMP in place
662− });
663−
664− generalDevTools = haskellPackages: builtins.attrValues (generalDevToolsAttrs haskellPackages);
665−
666− nativeHaskellPackages = haskellPackages:
667− if haskellPackages.isGhcjs or false
668− then haskellPackages.ghc
669− else haskellPackages;
670−
671− workOn = haskellPackages: package: (overrideCabal package (drv: {
672− buildDepends = (drv.buildDepends or []) ++ generalDevTools (nativeHaskellPackages haskellPackages);
673− })).env;
674−
675− workOnMulti' = { env, packageNames, tools ? _: [], shellToolOverrides ? _: _: {} }:
676− let inherit (builtins) listToAttrs filter attrValues all concatLists;
677− combinableAttrs = [
678− "benchmarkDepends"
679− "benchmarkFrameworkDepends"
680− "benchmarkHaskellDepends"
681− "benchmarkPkgconfigDepends"
682− "benchmarkSystemDepends"
683− "benchmarkToolDepends"
684− "buildDepends"
685− "buildTools"
686− "executableFrameworkDepends"
687− "executableHaskellDepends"
688− "executablePkgconfigDepends"
689− "executableSystemDepends"
690− "executableToolDepends"
691− "extraLibraries"
692− "libraryFrameworkDepends"
693− "libraryHaskellDepends"
694− "libraryPkgconfigDepends"
695− "librarySystemDepends"
696− "libraryToolDepends"
697− "pkgconfigDepends"
698− "setupHaskellDepends"
699− "testDepends"
700− "testFrameworkDepends"
701− "testHaskellDepends"
702− "testPkgconfigDepends"
703− "testSystemDepends"
704− "testToolDepends"
705− ];
706− concatCombinableAttrs = haskellConfigs: lib.filterAttrs (n: v: v != []) (lib.listToAttrs (map (name: { inherit name; value = concatLists (map (haskellConfig: haskellConfig.${name} or []) haskellConfigs); }) combinableAttrs));
707− getHaskellConfig = p: (overrideCabal p (args: {
708− passthru = (args.passthru or {}) // {
709− out = args;
710− };
711− })).out;
712− notInTargetPackageSet = p: all (pname: (p.pname or "") != pname) packageNames;
713− baseTools = generalDevToolsAttrs env;
714− overriddenTools = attrValues (baseTools // shellToolOverrides env baseTools);
715− depAttrs = lib.mapAttrs (_: v: filter notInTargetPackageSet v) (concatCombinableAttrs (concatLists [
716− (map getHaskellConfig (lib.attrVals packageNames env))
717− [{
718− buildTools = overriddenTools ++ tools env;
719− }]
720− ]));
721−
722− in (env.mkDerivation (depAttrs // {
723− pname = "work-on-multi--combined-pkg";
724− version = "0";
725− license = null;
726− })).env;
727−
728− workOnMulti = env: packageNames: workOnMulti' { inherit env packageNames; };
729−
730− # A simple derivation that just creates a file with the names of all
731− # of its inputs. If built, it will have a runtime dependency on all
732− # of the given build inputs.
733− pinBuildInputs = name: buildInputs: otherDeps: (nixpkgs.releaseTools.aggregate {
734− inherit name;
735− constituents = buildInputs ++ otherDeps;
736− }).overrideAttrs (old: {
737− buildCommand = old.buildCommand + ''
738− echo "$propagatedBuildInputs $buildInputs $nativeBuildInputs $propagatedNativeBuildInputs $otherDeps" > "$out/deps"
739− '';
740− inherit buildInputs otherDeps;
741− });
742−
743− # The systems that we want to build for on the current system
744− cacheTargetSystems = lib.warn "cacheTargetSystems has been deprecated, use cacheBuildSystems" cacheBuildSystems;
745− cacheBuildSystems = [
746− "x86_64-linux"
747− # "i686-linux"
748− "x86_64-darwin"
749− ];
750−
751− isSuffixOf = suffix: s:
752− let suffixLen = builtins.stringLength suffix;
753− in builtins.substring (builtins.stringLength s - suffixLen) suffixLen s == suffix;
754−
755− reflexEnv = platform:
756− let haskellPackages = builtins.getAttr platform this;
757− ghcWithStuff = if platform == "ghc" || platform == "ghcjs"
758− then haskellPackages.ghcWithHoogle
759− else haskellPackages.ghcWithPackages;
760− in ghcWithStuff (p: import ./packages.nix {
761− haskellPackages = p;
762− inherit platform;
763− });
764−
765− tryReflexPackages = generalDevTools ghc
766− ++ builtins.map reflexEnv platforms;
767−
768− cachePackages =
769− let otherPlatforms = lib.optionals androidSupport [
770− "ghcAndroidAarch64"
771− "ghcAndroidAarch32"
772− ] ++ lib.optional iosSupport "ghcIosAarch64";
773− in tryReflexPackages
774− ++ builtins.map reflexEnv otherPlatforms
775− ++ lib.optionals androidSupport [
776− androidDevTools
777− androidReflexTodomvc
778− ] ++ lib.optionals iosSupport [
779− iosReflexTodomvc
780− ];
781−
782− demoVM = (import "${nixpkgs.path}/nixos" {
783− configuration = {
784− imports = [
785− "${nixpkgs.path}/nixos/modules/virtualisation/virtualbox-image.nix"
786− "${nixpkgs.path}/nixos/modules/profiles/demo.nix"
787− ];
788− environment.systemPackages = tryReflexPackages;
789− nixpkgs = { localSystem.system = "x86_64-linux"; };
790− };
791− }).config.system.build.virtualBoxOVA;
792−
793− inherit cabal2nixResult sources system androidSupport iosSupport;
794− project = args: import ./project this (args ({ pkgs = nixpkgs; } // this));
795− tryReflexShell = pinBuildInputs ("shell-" + system) tryReflexPackages [];
796− js-framework-benchmark-src = hackGet ./js-framework-benchmark;
797− ghcjsExternsJs = ./ghcjs.externs.js;
798−}; in this
1+# DO NOT HAND-EDIT THIS FILE
2+import ((import <nixpkgs> {}).fetchFromGitHub (
3+ let json = builtins.fromJSON (builtins.readFile ./github.json);
4+ in { inherit (json) owner repo rev sha256;
5+ private = json.private or false;
6+ }
7+))