From 7b82b1e2c32b6e041712e54887de673283196da2 Mon Sep 17 00:00:00 2001 From: cydparser Date: Thu, 2 Mar 2023 19:00:49 -0800 Subject: [PATCH 1/2] Add GHC 9.2.7 --- ci.nix | 8 +++---- docs/reference/supported-ghc-versions.md | 11 +++++----- docs/tutorials/development/default.nix | 2 +- .../getting-started-flakes/flake.nix | 2 +- docs/tutorials/getting-started/default.nix | 2 +- flake.nix | 4 ++-- modules/component-driver.nix | 6 ++--- modules/flake.nix | 6 ++--- modules/hackage-quirks.nix | 4 ++-- overlays/bootstrap.nix | 22 ++++++++++++++++++- release.nix | 2 +- test/cabal-simple-debug/default.nix | 2 +- test/cabal-simple/default.nix | 2 +- test/haskell-language-server/stack.nix | 2 +- test/index-state/default.nix | 2 +- test/shell-for-setup-deps/default.nix | 2 +- 16 files changed, 50 insertions(+), 29 deletions(-) diff --git a/ci.nix b/ci.nix index c6d69afa5a..ac62d8616b 100644 --- a/ci.nix +++ b/ci.nix @@ -54,14 +54,14 @@ ghc865 = false; ghc8107 = false; ghc902 = false; - ghc926 = false; + ghc927 = false; ghc944 = false; } // nixpkgs.lib.optionalAttrs (nixpkgsName == "unstable") { ghc865 = false; ghc884 = false; # Native version is used to boot 9.0.1 ghc8107 = true; ghc902 = false; - ghc926 = true; + ghc927 = true; ghc944 = true; })); crossSystems = nixpkgsName: nixpkgs: compiler-nix-name: @@ -73,10 +73,10 @@ || (system == "x86_64-darwin" && __elem compiler-nix-name ["ghc8107"]))) { inherit (lib.systems.examples) ghcjs; } // lib.optionalAttrs (nixpkgsName == "unstable" - && ((system == "x86_64-linux" && __elem compiler-nix-name ["ghc8107" "ghc902" "ghc926" "ghc944"]) + && ((system == "x86_64-linux" && __elem compiler-nix-name ["ghc8107" "ghc902" "ghc927" "ghc944"]) || (system == "x86_64-darwin" && __elem compiler-nix-name []))) { # TODO add ghc versions when we have more darwin build capacity inherit (lib.systems.examples) mingwW64; - } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && __elem compiler-nix-name ["ghc8107" "ghc902" "ghc922" "ghc923" "ghc924" "ghc926"]) { + } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && __elem compiler-nix-name ["ghc8107" "ghc902" "ghc927"]) { # Musl cross only works on linux # aarch64 cross only works on linux inherit (lib.systems.examples) musl64 aarch64-multiplatform; diff --git a/docs/reference/supported-ghc-versions.md b/docs/reference/supported-ghc-versions.md index 38d0b5df0b..9f47829be1 100644 --- a/docs/reference/supported-ghc-versions.md +++ b/docs/reference/supported-ghc-versions.md @@ -5,10 +5,10 @@ for each, though not all are cached or tested by CI): - 8.4.4 - 8.6.{1,2,3,4,5} - 8.8.{1,2,3,4} -- 8.10.{1,2,3,4,5} -- 9.0.1 -- 9.2.1 -- 9.2.2 +- 8.10.{1,2,3,4,5,6,7} +- 9.0.{1,2} +- 9.2.{1,2,3,4,5,6,7} +- 9.4.{1,2,3,4} The following table shows the Nixpkgs/GHC versions which are built/cached, and which of those are further tested. If you use a combination of Nixpkgs version @@ -27,7 +27,8 @@ really should use an instance of Nixpkgs provided by `haskell.nix` itself. | unstable | `nixpkgs-unstable` | 8.8.4 | `ghc884` | No | | unstable | `nixpkgs-unstable` | 8.10.7 | `ghc8107` | Yes | | unstable | `nixpkgs-unstable` | 9.0.2 | `ghc902` | No | -| unstable | `nixpkgs-unstable` | 9.2.4 | `ghc924` | Yes | +| unstable | `nixpkgs-unstable` | 9.2.7 | `ghc927` | Yes | +| unstable | `nixpkgs-unstable` | 9.4.4 | `ghc944` | Yes | See [ci.nix](https://github.com/input-output-hk/haskell.nix/blob/master/ci.nix) for the source of truth about what is built and tested (in the off chance this diff --git a/docs/tutorials/development/default.nix b/docs/tutorials/development/default.nix index 9dfe17a7c1..7ca905e9ed 100644 --- a/docs/tutorials/development/default.nix +++ b/docs/tutorials/development/default.nix @@ -26,5 +26,5 @@ in pkgs.haskell-nix.project { src = ./.; }; # Specify the GHC version to use. - compiler-nix-name = "ghc926"; # Not required for `stack.yaml` based projects. + compiler-nix-name = "ghc927"; # Not required for `stack.yaml` based projects. } diff --git a/docs/tutorials/getting-started-flakes/flake.nix b/docs/tutorials/getting-started-flakes/flake.nix index e7b6f2edd3..a5d3e5e91c 100644 --- a/docs/tutorials/getting-started-flakes/flake.nix +++ b/docs/tutorials/getting-started-flakes/flake.nix @@ -12,7 +12,7 @@ helloProject = final.haskell-nix.project' { src = ./.; - compiler-nix-name = "ghc926"; + compiler-nix-name = "ghc927"; # This is used by `nix develop .` to open a shell for use with # `cabal`, `hlint` and `haskell-language-server` shell.tools = { diff --git a/docs/tutorials/getting-started/default.nix b/docs/tutorials/getting-started/default.nix index 9dfe17a7c1..7ca905e9ed 100644 --- a/docs/tutorials/getting-started/default.nix +++ b/docs/tutorials/getting-started/default.nix @@ -26,5 +26,5 @@ in pkgs.haskell-nix.project { src = ./.; }; # Specify the GHC version to use. - compiler-nix-name = "ghc926"; # Not required for `stack.yaml` based projects. + compiler-nix-name = "ghc927"; # Not required for `stack.yaml` based projects. } diff --git a/flake.nix b/flake.nix index 9b23b26f0a..b3e22adc4c 100644 --- a/flake.nix +++ b/flake.nix @@ -68,7 +68,7 @@ }; outputs = { self, nixpkgs, nixpkgs-unstable, nixpkgs-2105, nixpkgs-2111, nixpkgs-2205, nixpkgs-2211, flake-utils, tullia, ... }@inputs: - let compiler = "ghc926"; + let compiler = "ghc927"; config = import ./config.nix; traceNames = prefix: builtins.mapAttrs (n: v: @@ -215,7 +215,7 @@ "ghc881" "ghc882" "ghc883" "ghc8101" "ghc8102" "ghc8103" "ghc8104" "ghc8105" "ghc8106" "ghc810420210212" "ghc901" - "ghc921" "ghc922" "ghc923"]); + "ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926"]); } // tullia.fromSimple system (import ./tullia.nix))); # --- Flake Local Nix Configuration ---------------------------- diff --git a/modules/component-driver.nix b/modules/component-driver.nix index 7b9d58e689..7c86b9cc64 100644 --- a/modules/component-driver.nix +++ b/modules/component-driver.nix @@ -61,10 +61,10 @@ in ] # TODO make this unconditional ++ lib.optionals ( - __elem config.compiler.nix-name ["ghc901" "ghc902" "ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926" "ghc941" "ghc942" "ghc943" "ghc944"]) [ + __elem config.compiler.nix-name ["ghc901" "ghc902" "ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926" "ghc927" "ghc941" "ghc942" "ghc943" "ghc944"]) [ "ghc-bignum" ] ++ lib.optionals ( - __elem config.compiler.nix-name ["ghc925" "ghc926" "ghc941" "ghc942" "ghc943" "ghc944"]) [ + __elem config.compiler.nix-name ["ghc925" "ghc926" "ghc927" "ghc941" "ghc942" "ghc943" "ghc944"]) [ "system-cxx-std-lib" ] ++ lib.optionals (!config.reinstallableLibGhc) [ "ghc-boot" @@ -89,7 +89,7 @@ in "ghcjs-prim" ] ++ lib.optional (!config.reinstallableLibGhc) "ghc" ++ lib.optionals ( - __elem config.compiler.nix-name ["ghc901" "ghc902" "ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926" "ghc941" "ghc942" "ghc943" "ghc944"]) [ + __elem config.compiler.nix-name ["ghc901" "ghc902" "ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926" "ghc927" "ghc941" "ghc942" "ghc943" "ghc944"]) [ "ghc-bignum" ] ++ lib.optionals ( __elem config.compiler.nix-name ["ghc941" "ghc942" "ghc943" "ghc944"]) [ diff --git a/modules/flake.nix b/modules/flake.nix index 3c4a50a064..ad650d2d3f 100644 --- a/modules/flake.nix +++ b/modules/flake.nix @@ -16,13 +16,13 @@ This allows flakes to easily include variations of the project by with different project arguments. Anything you can pass to `project.addModule` can be used. - For instance to include variants using ghc 9.2.6: + For instance to include variants using ghc 9.2.7: ``` - flake.variants.ghc926.compiler-nix-name = pkgs.lib.mkForce "ghc926"; + flake.variants.ghc927.compiler-nix-name = pkgs.lib.mkForce "ghc927"; ``` Then use it with: ``` - nix build .#ghc926:hello:exe:hello + nix build .#ghc927:hello:exe:hello ``` ''; }; diff --git a/modules/hackage-quirks.nix b/modules/hackage-quirks.nix index e3c237e867..8d1a29f239 100644 --- a/modules/hackage-quirks.nix +++ b/modules/hackage-quirks.nix @@ -56,14 +56,14 @@ in [ package haskell-language-server flags: -qualifyimportednames${ # Stylish haskell is broken for GHC 9.2 - lib.optionalString (__elem config.compiler-nix-name ["ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926"]) " -stylishhaskell" + lib.optionalString (__elem config.compiler-nix-name ["ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926" "ghc927"]) " -stylishhaskell" # Hlint with this HLS only compiles for GHC 9.0 + lib.optionalString (!__elem config.compiler-nix-name ["ghc901" "ghc902"]) " -hlint" } constraints: hls-fourmolu-plugin <1.1.1.0, hls-rename-plugin <1.0.2.0, hls-stan-plugin <1.0.1.0 '' # TODO Remove this flag once the hls-call-hierarchy-plugin is updated in hackage to work with ghc 9.2 - + lib.optionalString (__elem config.compiler-nix-name ["ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926"]) '' + + lib.optionalString (__elem config.compiler-nix-name ["ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926" "ghc927"]) '' package haskell-language-server flags: -callhierarchy ''); diff --git a/overlays/bootstrap.nix b/overlays/bootstrap.nix index 3be600c0ee..00561bab25 100644 --- a/overlays/bootstrap.nix +++ b/overlays/bootstrap.nix @@ -63,7 +63,7 @@ let "8.8" = "8.8.4"; "8.10" = "8.10.7"; "9.0" = "9.0.2"; - "9.2" = "9.2.6"; + "9.2" = "9.2.7"; "9.4" = "9.4.4"; }; traceWarnOld = v: x: @@ -726,6 +726,26 @@ in { ghc-patches = ghc-patches "9.2.6"; }); + ghc927 = final.callPackage ../compiler/ghc (traceWarnOld "9.2" { + extra-passthru = { buildGHC = final.buildPackages.haskell-nix.compiler.ghc927; }; + + bootPkgs = bootPkgs // { + ghc = final.buildPackages.buildPackages.haskell-nix.compiler.ghc8107; + }; + inherit sphinx installDeps; + + useLLVM = !final.stdenv.targetPlatform.isx86 && !final.stdenv.targetPlatform.isAarch64; + buildLlvmPackages = final.buildPackages.llvmPackages_12; + llvmPackages = final.llvmPackages_12; + + src-spec = rec { + version = "9.2.7"; + url = "https://downloads.haskell.org/~ghc/${version}/ghc-${version}-src.tar.xz"; + sha256 = "sha256-olNWehe3NKTA3Q/6KW0zwqW1pUp335iIBqKh4cp+iLg="; + }; + + ghc-patches = ghc-patches "9.2.7"; + }); ghc941 = final.callPackage ../compiler/ghc (traceWarnOld "9.4" { extra-passthru = { buildGHC = final.buildPackages.haskell-nix.compiler.ghc941; }; diff --git a/release.nix b/release.nix index 7d91f24099..39fc54d3f2 100644 --- a/release.nix +++ b/release.nix @@ -49,7 +49,7 @@ let constituents = lib.collect lib.isDerivation ( lib.optionalAttrs (jobs ? x86_64-darwin) { darwin-ghc8107 = jobs.x86_64-darwin.required-unstable-ghc8107-native; - darwin-ghc926 = jobs.x86_64-darwin.required-unstable-ghc926-native; + darwin-ghc927 = jobs.x86_64-darwin.required-unstable-ghc927-native; } ); }; diff --git a/test/cabal-simple-debug/default.nix b/test/cabal-simple-debug/default.nix index b53d30e2e8..51ded930d0 100644 --- a/test/cabal-simple-debug/default.nix +++ b/test/cabal-simple-debug/default.nix @@ -18,7 +18,7 @@ let in recurseIntoAttrs { # DWARF only works on linux with GHC 8.10.2 and newer # GHC 9.2.1 disabled because of https://github.com/input-output-hk/haskell.nix/issues/1332 - meta.disabled = __elem compiler-nix-name ["ghc865" "ghc884" "ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926" "ghc941" "ghc942" "ghc943" "ghc944"] + meta.disabled = __elem compiler-nix-name ["ghc865" "ghc884" "ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926" "ghc927" "ghc941" "ghc942" "ghc943" "ghc944"] || !stdenv.hostPlatform.isLinux || haskellLib.isCrossHost || stdenv.hostPlatform.isMusl || stdenv.hostPlatform.isAarch64; ifdInputs = { inherit (project) plan-nix; diff --git a/test/cabal-simple/default.nix b/test/cabal-simple/default.nix index ced786256a..d1f2a96a0c 100644 --- a/test/cabal-simple/default.nix +++ b/test/cabal-simple/default.nix @@ -30,7 +30,7 @@ in recurseIntoAttrs { }; # Used for testing externally with nix-shell (../tests.sh). - test-shell = project.shellFor { tools = { cabal = "latest"; }; withHoogle = !__elem compiler-nix-name ["ghc901" "ghc902" "ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926"]; }; + test-shell = project.shellFor { tools = { cabal = "latest"; }; withHoogle = !__elem compiler-nix-name ["ghc901" "ghc902" "ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926" "ghc927"]; }; run = stdenv.mkDerivation { name = "cabal-simple-test"; diff --git a/test/haskell-language-server/stack.nix b/test/haskell-language-server/stack.nix index dd0ccc8786..b2ac3cc2aa 100644 --- a/test/haskell-language-server/stack.nix +++ b/test/haskell-language-server/stack.nix @@ -22,5 +22,5 @@ in recurseIntoAttrs { build = project.hsPkgs.haskell-language-server.components.exes.haskell-language-server; # Haskell Language Server does not build for GHC 9 or 8.10.7 yet - meta.disabled = __elem compiler-nix-name ["ghc944" "ghc943" "ghc942" "ghc941" "ghc926" "ghc925" "ghc924" "ghc923" "ghc922" "ghc921" "ghc901" "ghc902" "ghc8107" "ghc810420210212" ]; + meta.disabled = __elem compiler-nix-name ["ghc944" "ghc943" "ghc942" "ghc941" "ghc927" "ghc926" "ghc925" "ghc924" "ghc923" "ghc922" "ghc921" "ghc901" "ghc902" "ghc8107" "ghc810420210212" ]; } diff --git a/test/index-state/default.nix b/test/index-state/default.nix index 9d5057f2e4..59bc228858 100644 --- a/test/index-state/default.nix +++ b/test/index-state/default.nix @@ -40,7 +40,7 @@ in # This test will need to be updated to use newer hackage index-state for it # to work with GHC 9 and above. # Does not work for GHCJS - meta.disabled = stdenv.hostPlatform.isGhcjs || __elem compiler-nix-name ["ghc901" "ghc902" "ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926"]; + meta.disabled = stdenv.hostPlatform.isGhcjs || __elem compiler-nix-name ["ghc901" "ghc902" "ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926" "ghc927"]; passthru = { diff --git a/test/shell-for-setup-deps/default.nix b/test/shell-for-setup-deps/default.nix index ab89ff5c0a..16b22e9462 100644 --- a/test/shell-for-setup-deps/default.nix +++ b/test/shell-for-setup-deps/default.nix @@ -14,7 +14,7 @@ let }; env = project.shellFor { - withHoogle = !__elem compiler-nix-name ["ghc901" "ghc902" "ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926"]; + withHoogle = !__elem compiler-nix-name ["ghc901" "ghc902" "ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926" "ghc927"]; }; in recurseIntoAttrs ({ From 847fc227cf0c7fca146c2a83ef37a881111b96f1 Mon Sep 17 00:00:00 2001 From: cydparser Date: Thu, 2 Mar 2023 19:01:16 -0800 Subject: [PATCH 2/2] Add GHC 9.2.7 materialized files --- .../ghc-boot-packages-nix/ghc927/Win32.nix | 48 ++ .../ghc-boot-packages-nix/ghc927/base.nix | 48 ++ .../ghc927/bytestring.nix | 65 ++ .../ghc-boot-packages-nix/ghc927/deepseq.nix | 47 ++ .../ghc927/ghc-bignum.nix | 37 + .../ghc-boot-packages-nix/ghc927/ghc-boot.nix | 40 ++ .../ghc-boot-packages-nix/ghc927/ghc-heap.nix | 36 + .../ghc-boot-packages-nix/ghc927/ghc-prim.nix | 43 ++ .../ghc-boot-packages-nix/ghc927/ghc.nix | 60 ++ .../ghc-boot-packages-nix/ghc927/ghci.nix | 45 ++ .../ghc-boot-packages-nix/ghc927/hpc.nix | 38 + .../ghc927/integer-gmp.nix | 35 + .../ghc927/iserv-proxy.nix | 45 ++ .../ghc-boot-packages-nix/ghc927/iserv.nix | 42 ++ .../ghc-boot-packages-nix/ghc927/libiserv.nix | 42 ++ .../ghc-boot-packages-nix/ghc927/pretty.nix | 56 ++ .../ghc927/remote-iserv.nix | 36 + .../ghc927/template-haskell.nix | 36 + .../default/ghc927/.plan.nix/Win32.nix | 158 +++++ .../default/ghc927/.plan.nix/ghc-boot.nix | 64 ++ .../default/ghc927/.plan.nix/ghc.nix | 662 ++++++++++++++++++ .../default/ghc927/.plan.nix/ghci.nix | 70 ++ .../default/ghc927/.plan.nix/hpc.nix | 52 ++ .../default/ghc927/.plan.nix/iserv-proxy.nix | 55 ++ .../default/ghc927/.plan.nix/iserv.nix | 54 ++ .../default/ghc927/.plan.nix/libiserv.nix | 58 ++ .../default/ghc927/.plan.nix/remote-iserv.nix | 46 ++ .../default/ghc927/cabal-files/network.nix | 64 ++ .../default/ghc927/default.nix | 138 ++++ .../windows/ghc927/.plan.nix/Win32.nix | 158 +++++ .../windows/ghc927/.plan.nix/ghc-boot.nix | 64 ++ .../windows/ghc927/.plan.nix/ghc.nix | 662 ++++++++++++++++++ .../windows/ghc927/.plan.nix/ghci.nix | 70 ++ .../windows/ghc927/.plan.nix/hpc.nix | 52 ++ .../windows/ghc927/.plan.nix/iserv-proxy.nix | 55 ++ .../windows/ghc927/.plan.nix/iserv.nix | 54 ++ .../windows/ghc927/.plan.nix/libiserv.nix | 58 ++ .../windows/ghc927/.plan.nix/remote-iserv.nix | 46 ++ .../windows/ghc927/cabal-files/Win32.nix | 53 ++ .../windows/ghc927/cabal-files/directory.nix | 57 ++ .../windows/ghc927/cabal-files/hsc2hs.nix | 57 ++ .../windows/ghc927/cabal-files/network.nix | 64 ++ .../windows/ghc927/cabal-files/process.nix | 61 ++ .../windows/ghc927/cabal-files/time.nix | 94 +++ .../windows/ghc927/default.nix | 134 ++++ .../cabal-install/.plan.nix/cabal-install.nix | 385 ++++++++++ .../cabal-files/Cabal-syntax.nix | 55 ++ .../cabal-install/cabal-files/Cabal.nix | 56 ++ .../ghc927/cabal-install/cabal-files/HTTP.nix | 98 +++ .../cabal-install/cabal-files/async.nix | 81 +++ .../cabal-files/base16-bytestring.nix | 68 ++ .../cabal-files/base64-bytestring.nix | 68 ++ .../cabal-files/cabal-install-solver.nix | 68 ++ .../cabal-files/cryptohash-sha256.nix | 84 +++ .../ghc927/cabal-install/cabal-files/echo.nix | 53 ++ .../cabal-install/cabal-files/ed25519.nix | 86 +++ .../cabal-files/edit-distance.nix | 73 ++ .../cabal-files/hackage-security.nix | 126 ++++ .../cabal-install/cabal-files/hashable.nix | 90 +++ .../cabal-install/cabal-files/hsc2hs.nix | 57 ++ .../cabal-install/cabal-files/lukko.nix | 65 ++ .../cabal-install/cabal-files/network-uri.nix | 70 ++ .../cabal-install/cabal-files/network.nix | 80 +++ .../cabal-install/cabal-files/random.nix | 113 +++ .../cabal-install/cabal-files/regex-base.nix | 47 ++ .../cabal-install/cabal-files/regex-posix.nix | 44 ++ .../cabal-install/cabal-files/resolv.nix | 58 ++ .../cabal-files/safe-exceptions.nix | 55 ++ .../cabal-install/cabal-files/splitmix.nix | 140 ++++ .../ghc927/cabal-install/cabal-files/tar.nix | 106 +++ .../cabal-install/cabal-files/th-compat.nix | 63 ++ .../ghc927/cabal-install/cabal-files/zlib.nix | 60 ++ materialized/ghc927/cabal-install/default.nix | 190 +++++ 73 files changed, 6498 insertions(+) create mode 100644 materialized/ghc-boot-packages-nix/ghc927/Win32.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc927/base.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc927/bytestring.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc927/deepseq.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc927/ghc-bignum.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc927/ghc-boot.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc927/ghc-heap.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc927/ghc-prim.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc927/ghc.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc927/ghci.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc927/hpc.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc927/integer-gmp.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc927/iserv-proxy.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc927/iserv.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc927/libiserv.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc927/pretty.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc927/remote-iserv.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc927/template-haskell.nix create mode 100644 materialized/ghc-extra-projects/default/ghc927/.plan.nix/Win32.nix create mode 100644 materialized/ghc-extra-projects/default/ghc927/.plan.nix/ghc-boot.nix create mode 100644 materialized/ghc-extra-projects/default/ghc927/.plan.nix/ghc.nix create mode 100644 materialized/ghc-extra-projects/default/ghc927/.plan.nix/ghci.nix create mode 100644 materialized/ghc-extra-projects/default/ghc927/.plan.nix/hpc.nix create mode 100644 materialized/ghc-extra-projects/default/ghc927/.plan.nix/iserv-proxy.nix create mode 100644 materialized/ghc-extra-projects/default/ghc927/.plan.nix/iserv.nix create mode 100644 materialized/ghc-extra-projects/default/ghc927/.plan.nix/libiserv.nix create mode 100644 materialized/ghc-extra-projects/default/ghc927/.plan.nix/remote-iserv.nix create mode 100644 materialized/ghc-extra-projects/default/ghc927/cabal-files/network.nix create mode 100644 materialized/ghc-extra-projects/default/ghc927/default.nix create mode 100644 materialized/ghc-extra-projects/windows/ghc927/.plan.nix/Win32.nix create mode 100644 materialized/ghc-extra-projects/windows/ghc927/.plan.nix/ghc-boot.nix create mode 100644 materialized/ghc-extra-projects/windows/ghc927/.plan.nix/ghc.nix create mode 100644 materialized/ghc-extra-projects/windows/ghc927/.plan.nix/ghci.nix create mode 100644 materialized/ghc-extra-projects/windows/ghc927/.plan.nix/hpc.nix create mode 100644 materialized/ghc-extra-projects/windows/ghc927/.plan.nix/iserv-proxy.nix create mode 100644 materialized/ghc-extra-projects/windows/ghc927/.plan.nix/iserv.nix create mode 100644 materialized/ghc-extra-projects/windows/ghc927/.plan.nix/libiserv.nix create mode 100644 materialized/ghc-extra-projects/windows/ghc927/.plan.nix/remote-iserv.nix create mode 100644 materialized/ghc-extra-projects/windows/ghc927/cabal-files/Win32.nix create mode 100644 materialized/ghc-extra-projects/windows/ghc927/cabal-files/directory.nix create mode 100644 materialized/ghc-extra-projects/windows/ghc927/cabal-files/hsc2hs.nix create mode 100644 materialized/ghc-extra-projects/windows/ghc927/cabal-files/network.nix create mode 100644 materialized/ghc-extra-projects/windows/ghc927/cabal-files/process.nix create mode 100644 materialized/ghc-extra-projects/windows/ghc927/cabal-files/time.nix create mode 100644 materialized/ghc-extra-projects/windows/ghc927/default.nix create mode 100644 materialized/ghc927/cabal-install/.plan.nix/cabal-install.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/Cabal-syntax.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/Cabal.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/HTTP.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/async.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/base16-bytestring.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/base64-bytestring.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/cabal-install-solver.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/cryptohash-sha256.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/echo.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/ed25519.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/edit-distance.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/hackage-security.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/hashable.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/hsc2hs.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/lukko.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/network-uri.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/network.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/random.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/regex-base.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/regex-posix.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/resolv.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/safe-exceptions.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/splitmix.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/tar.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/th-compat.nix create mode 100644 materialized/ghc927/cabal-install/cabal-files/zlib.nix create mode 100644 materialized/ghc927/cabal-install/default.nix diff --git a/materialized/ghc-boot-packages-nix/ghc927/Win32.nix b/materialized/ghc-boot-packages-nix/ghc927/Win32.nix new file mode 100644 index 0000000000..ac7f51280b --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc927/Win32.nix @@ -0,0 +1,48 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "2.0"; + identifier = { name = "Win32"; version = "2.12.0.1"; }; + license = "BSD-3-Clause"; + copyright = "Alastair Reid, 1999-2003; shelarcy, 2012-2013; Tamar Christina, 2016-2020"; + maintainer = "Haskell Libraries "; + author = "Alastair Reid, shelarcy, Tamar Christina"; + homepage = "https://github.com/haskell/win32"; + url = ""; + synopsis = "A binding to Windows Win32 API."; + description = "This library contains direct bindings to the Windows Win32 APIs for Haskell."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + ] ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unbuildable" or (errorHandler.buildDepError "unbuildable")); + libs = [ + (pkgs."user32" or (errorHandler.sysDepError "user32")) + (pkgs."gdi32" or (errorHandler.sysDepError "gdi32")) + (pkgs."winmm" or (errorHandler.sysDepError "winmm")) + (pkgs."advapi32" or (errorHandler.sysDepError "advapi32")) + (pkgs."shell32" or (errorHandler.sysDepError "shell32")) + (pkgs."shfolder" or (errorHandler.sysDepError "shfolder")) + (pkgs."shlwapi" or (errorHandler.sysDepError "shlwapi")) + (pkgs."msimg32" or (errorHandler.sysDepError "msimg32")) + (pkgs."imm32" or (errorHandler.sysDepError "imm32")) + ]; + build-tools = [ + (hsPkgs.buildPackages.hsc2hs.components.exes.hsc2hs or (pkgs.buildPackages.hsc2hs or (errorHandler.buildToolDepError "hsc2hs:hsc2hs"))) + ]; + buildable = if !system.isWindows then false else true; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc927/base.nix b/materialized/ghc-boot-packages-nix/ghc927/base.nix new file mode 100644 index 0000000000..51df28d6f9 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc927/base.nix @@ -0,0 +1,48 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "base"; version = "4.16.4.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Basic libraries"; + description = "This package contains the Standard Haskell \"Prelude\" and its support libraries,\nand a large collection of useful libraries ranging from data\nstructures to parsing combinators and debugging utilities."; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) + ]; + libs = (pkgs.lib).optionals (system.isWindows) [ + (pkgs."wsock32" or (errorHandler.sysDepError "wsock32")) + (pkgs."user32" or (errorHandler.sysDepError "user32")) + (pkgs."shell32" or (errorHandler.sysDepError "shell32")) + (pkgs."msvcrt" or (errorHandler.sysDepError "msvcrt")) + (pkgs."mingw32" or (errorHandler.sysDepError "mingw32")) + (pkgs."mingwex" or (errorHandler.sysDepError "mingwex")) + (pkgs."ws2_32" or (errorHandler.sysDepError "ws2_32")) + (pkgs."shlwapi" or (errorHandler.sysDepError "shlwapi")) + (pkgs."ole32" or (errorHandler.sysDepError "ole32")) + (pkgs."rpcrt4" or (errorHandler.sysDepError "rpcrt4")) + (pkgs."ntdll" or (errorHandler.sysDepError "ntdll")) + ]; + buildable = true; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc927/bytestring.nix b/materialized/ghc-boot-packages-nix/ghc927/bytestring.nix new file mode 100644 index 0000000000..aab037fd8c --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc927/bytestring.nix @@ -0,0 +1,65 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "bytestring"; version = "0.11.4.0"; }; + license = "BSD-3-Clause"; + copyright = "Copyright (c) Don Stewart 2005-2009,\n(c) Duncan Coutts 2006-2015,\n(c) David Roundy 2003-2005,\n(c) Jasper Van der Jeugt 2010,\n(c) Simon Meier 2010-2013."; + maintainer = "Haskell Bytestring Team , Core Libraries Committee"; + author = "Don Stewart,\nDuncan Coutts"; + homepage = "https://github.com/haskell/bytestring"; + url = ""; + synopsis = "Fast, compact, strict and lazy byte strings with a list interface"; + description = "An efficient compact, immutable byte string type (both strict and lazy)\nsuitable for binary or 8-bit character data.\n\nThe 'ByteString' type represents sequences of bytes or 8-bit characters.\nIt is suitable for high performance use, both in terms of large data\nquantities, or high speed requirements. The 'ByteString' functions follow\nthe same style as Haskell\\'s ordinary lists, so it is easy to convert code\nfrom using 'String' to 'ByteString'.\n\nTwo 'ByteString' variants are provided:\n\n* Strict 'ByteString's keep the string as a single large array. This\nmakes them convenient for passing data between C and Haskell.\n\n* Lazy 'ByteString's use a lazy list of strict chunks which makes it\nsuitable for I\\/O streaming tasks.\n\nThe @Char8@ modules provide a character-based view of the same\nunderlying 'ByteString' types. This makes it convenient to handle mixed\nbinary and 8-bit character content (which is common in many file formats\nand network protocols).\n\nThe 'Builder' module provides an efficient way to build up 'ByteString's\nin an ad-hoc way by repeated concatenation. This is ideal for fast\nserialisation or pretty printing.\n\nThere is also a 'ShortByteString' type which has a lower memory overhead\nand can be converted to or from a 'ByteString'. It is suitable for keeping\nmany short strings in memory.\n\n'ByteString's are not designed for Unicode. For Unicode strings you should\nuse the 'Text' type from the @text@ package.\n\nThese modules are intended to be imported qualified, to avoid name clashes\nwith \"Prelude\" functions, e.g.\n\n> import qualified Data.ByteString as BS"; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + ]; + libs = (pkgs.lib).optional (system.isWindows && (compiler.isGhc && (compiler.version).lt "9.3")) (pkgs."gcc" or (errorHandler.sysDepError "gcc")); + buildable = true; + }; + tests = { + "bytestring-tests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + ]; + buildable = true; + }; + }; + benchmarks = { + "bytestring-bench" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."tasty-bench" or (errorHandler.buildDepError "tasty-bench")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + ]; + buildable = true; + }; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc927/deepseq.nix b/materialized/ghc-boot-packages-nix/ghc927/deepseq.nix new file mode 100644 index 0000000000..709f51ac31 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc927/deepseq.nix @@ -0,0 +1,47 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.12"; + identifier = { name = "deepseq"; version = "1.4.6.1"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Deep evaluation of data structures"; + description = "This package provides methods for fully evaluating data structures\n(\\\"deep evaluation\\\"). Deep evaluation is often used for adding\nstrictness to a program, e.g. in order to force pending exceptions,\nremove space leaks, or force lazy I/O to happen. It is also useful\nin parallel programs, to ensure pending work does not migrate to the\nwrong thread.\n\nThe primary use of this package is via the 'deepseq' function, a\n\\\"deep\\\" version of 'seq'. It is implemented on top of an 'NFData'\ntypeclass (\\\"Normal Form Data\\\", data structures with no unevaluated\ncomponents) which defines strategies for fully evaluating different\ndata types. See module documentation in \"Control.DeepSeq\" for more\ndetails."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + ] ++ (pkgs.lib).optional (compiler.isGhc && ((compiler.version).ge "7.4" && (compiler.version).lt "7.5")) (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")); + buildable = true; + }; + tests = { + "deepseq-generics-tests" = { + depends = [ + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."test-framework" or (errorHandler.buildDepError "test-framework")) + (hsPkgs."test-framework-hunit" or (errorHandler.buildDepError "test-framework-hunit")) + (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) + ]; + buildable = true; + }; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc927/ghc-bignum.nix b/materialized/ghc-boot-packages-nix/ghc927/ghc-bignum.nix new file mode 100644 index 0000000000..fa71fb0035 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc927/ghc-bignum.nix @@ -0,0 +1,37 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { native = false; ffi = false; gmp = false; check = false; }; + package = { + specVersion = "2.0"; + identifier = { name = "ghc-bignum"; version = "1.2"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = "Sylvain Henry"; + homepage = ""; + url = ""; + synopsis = "GHC BigNum library"; + description = "This package provides the low-level implementation of the standard\n'BigNat', 'Natural' and 'Integer' types."; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + ]; + buildable = (if !flags.native && !flags.gmp && !flags.ffi + then false + else true) && (if flags.native && (flags.gmp || flags.ffi) + then false + else true) && (if flags.gmp && flags.ffi then false else true); + }; + }; + } // rec { src = (pkgs.lib).mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc927/ghc-boot.nix b/materialized/ghc-boot-packages-nix/ghc927/ghc-boot.nix new file mode 100644 index 0000000000..4fde0e1f57 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc927/ghc-boot.nix @@ -0,0 +1,40 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "ghc-boot"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Shared functionality between GHC and its boot libraries"; + description = "This library is shared between GHC, ghc-pkg, and other boot\nlibraries.\n.\nA note about \"GHC.Unit.Database\": it only deals with the subset of\nthe package database that the compiler cares about: modules\npaths etc and not package metadata like description, authors\netc. It is thus not a library interface to ghc-pkg and is *not*\nsuitable for modifying GHC package databases.\n.\nThe package database format and this library are constructed in\nsuch a way that while ghc-pkg depends on Cabal, the GHC library\nand program do not have to depend on Cabal."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghc-boot-th" or (errorHandler.buildDepError "ghc-boot-th")) + ] ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc927/ghc-heap.nix b/materialized/ghc-boot-packages-nix/ghc927/ghc-heap.nix new file mode 100644 index 0000000000..8712f61c60 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc927/ghc-heap.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "ghc-heap"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Functions for walking GHC's heap"; + description = "This package provides functions for walking the GHC heap data structures\nand retrieving information about those data structures."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + ]; + buildable = true; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc927/ghc-prim.nix b/materialized/ghc-boot-packages-nix/ghc927/ghc-prim.nix new file mode 100644 index 0000000000..965489d7bf --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc927/ghc-prim.nix @@ -0,0 +1,43 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "2.2"; + identifier = { name = "ghc-prim"; version = "0.8.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "GHC primitives"; + description = "This package contains the primitive types and operations supplied by GHC."; + buildType = "Custom"; + setup-depends = [ + (hsPkgs.buildPackages.base or (pkgs.buildPackages.base or (errorHandler.setupDepError "base"))) + (hsPkgs.buildPackages.Cabal or (pkgs.buildPackages.Cabal or (errorHandler.setupDepError "Cabal"))) + ]; + }; + components = { + "library" = { + depends = [ (hsPkgs."rts" or (errorHandler.buildDepError "rts")) ]; + libs = (pkgs.lib).optionals (system.isWindows) [ + (pkgs."user32" or (errorHandler.sysDepError "user32")) + (pkgs."mingw32" or (errorHandler.sysDepError "mingw32")) + (pkgs."mingwex" or (errorHandler.sysDepError "mingwex")) + ] ++ (pkgs.lib).optionals (system.isLinux) [ + (pkgs."c" or (errorHandler.sysDepError "c")) + (pkgs."m" or (errorHandler.sysDepError "m")) + ]; + buildable = true; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc927/ghc.nix b/materialized/ghc-boot-packages-nix/ghc927/ghc.nix new file mode 100644 index 0000000000..84985d9eb8 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc927/ghc.nix @@ -0,0 +1,60 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { + internal-interpreter = false; + stage1 = false; + stage2 = false; + stage3 = false; + terminfo = true; + dynamic-system-linker = true; + }; + package = { + specVersion = "1.22"; + identifier = { name = "ghc"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "glasgow-haskell-users@haskell.org"; + author = "The GHC Team"; + homepage = "http://www.haskell.org/ghc/"; + url = ""; + synopsis = "The GHC API"; + description = "GHC's functionality can be useful for more things than just\ncompiling Haskell programs. Important use cases are programs\nthat analyse (and perhaps transform) Haskell code. Others\ninclude loading Haskell code dynamically in a GHCi-like manner.\nFor this reason, a lot of GHC's functionality is made available\nthrough this package.\n\nSee \nfor more information."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."hpc" or (errorHandler.buildDepError "hpc")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."exceptions" or (errorHandler.buildDepError "exceptions")) + (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot")) + (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ] ++ (if system.isWindows + then [ (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) ] + else [ + (hsPkgs."unix" or (errorHandler.buildDepError "unix")) + ] ++ (pkgs.lib).optional (flags.terminfo) (hsPkgs."terminfo" or (errorHandler.buildDepError "terminfo"))); + buildable = true; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc927/ghci.nix b/materialized/ghc-boot-packages-nix/ghc927/ghci.nix new file mode 100644 index 0000000000..6ecae49ae0 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc927/ghci.nix @@ -0,0 +1,45 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { internal-interpreter = false; }; + package = { + specVersion = "1.10"; + identifier = { name = "ghci"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "The library supporting GHC's interactive interpreter"; + description = "This library offers interfaces which mediate interactions between the\n@ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter\nbackend."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot")) + (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + ] ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc927/hpc.nix b/materialized/ghc-boot-packages-nix/ghc927/hpc.nix new file mode 100644 index 0000000000..ddd3aa6beb --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc927/hpc.nix @@ -0,0 +1,38 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "hpc"; version = "0.6.1.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = "Andy Gill"; + homepage = ""; + url = ""; + synopsis = "Code Coverage Library for Haskell"; + description = "This package provides the code coverage library for Haskell.\n\nSee for more\ninformation."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + ]; + buildable = true; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc927/integer-gmp.nix b/materialized/ghc-boot-packages-nix/ghc927/integer-gmp.nix new file mode 100644 index 0000000000..ba91559964 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc927/integer-gmp.nix @@ -0,0 +1,35 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "2.0"; + identifier = { name = "integer-gmp"; version = "1.1"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "hvr@gnu.org"; + author = "Herbert Valerio Riedel"; + homepage = ""; + url = ""; + synopsis = "Integer library based on GMP"; + description = "This package used to provide an implementation of the standard 'Integer'\ntype based on the\n.\n\nIt is now deprecated in favor of the 'ghc-bignum' package.\n\nIts purpose is to provide backward compatibility for codes directly\ndepending on the `integer-gmp` package."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) + ]; + buildable = true; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc927/iserv-proxy.nix b/materialized/ghc-boot-packages-nix/ghc927/iserv-proxy.nix new file mode 100644 index 0000000000..f6bbd6f868 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc927/iserv-proxy.nix @@ -0,0 +1,45 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "iserv-proxy"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "GHC can be provided with a path to the iserv binary with\n@-pgmi=/path/to/iserv-bin@, and will in combination with\n@-fexternal-interpreter@, compile Template Haskell though the\n@iserv-bin@ delegate. This is very similar to how ghcjs has been\ncompiling Template Haskell, by spawning a separate delegate (so\ncalled runner on the javascript vm) and evaluating the splices\nthere.\n\niserv can also be used in combination with cross compilation. For\nthis, the @iserv-proxy@ needs to be built on the host, targeting the\nhost (as it is running on the host). @cabal install -flibrary\n-fproxy@ will yield the proxy.\n\nUsing the cabal for the target @arch-platform-target-cabal install\n-flibrary@ will build the required library that contains the ffi\n@startSlave@ function, which needs to be invoked on the target\n(e.g. in an iOS application) to start the remote iserv slave.\n\ncalling the GHC cross compiler with @-fexternal-interpreter\n-pgmi=$HOME/.cabal/bin/iserv-proxy -opti\\ -opti\\@\nwill cause it to compile Template Haskell via the remote at \\.\n\nThus to get cross compilation with Template Haskell follow the\nfollowing receipt:\n\n* compile the iserv library for your target\n\n> iserv $ arch-platform-target-cabal install -flibrary\n\n* setup an application for your target that calls the\n* startSlave function. This could be either haskell or your\n* targets ffi capable language, if needed.\n\n> void startSlave(false /* verbose */, 5000 /* port */,\n> \"/path/to/storagelocation/on/target\");\n\n* build the iserv-proxy\n\n> iserv $ cabal install -flibrary -fproxy\n* Start your iserv-slave app on your target running on say @10.0.0.1:5000@\n* compiler your sources with -fexternal-interpreter and the proxy\n\n> project $ arch-platform-target-ghc ModuleContainingTH.hs \\\n> -fexternal-interpreter \\\n> -pgmi=$HOME/.cabal/bin/iserv-proxy \\\n> -opti10.0.0.1 -opti5000\n\nShould something not work as expected, provide @-opti-v@ for verbose\nlogging of the @iserv-proxy@."; + buildType = "Simple"; + }; + components = { + exes = { + "iserv-proxy" = { + depends = [ + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."network" or (errorHandler.buildDepError "network")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + (hsPkgs."libiserv" or (errorHandler.buildDepError "libiserv")) + ]; + buildable = true; + }; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc927/iserv.nix b/materialized/ghc-boot-packages-nix/ghc927/iserv.nix new file mode 100644 index 0000000000..7549191839 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc927/iserv.nix @@ -0,0 +1,42 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "iserv"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "GHC can be provided with a path to the iserv binary with\n@-pgmi=/path/to/iserv-bin@, and will in combination with\n@-fexternal-interpreter@, compile Template Haskell though the\n@iserv-bin@ delegate. This is very similar to how ghcjs has been\ncompiling Template Haskell, by spawning a separate delegate (so\ncalled runner on the javascript vm) and evaluating the splices\nthere.\n\nTo use iserv with cross compilers, please see @libraries/libiserv@\nand @utils/iserv-proxy@."; + buildType = "Simple"; + }; + components = { + exes = { + "iserv" = { + depends = [ + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + (hsPkgs."libiserv" or (errorHandler.buildDepError "libiserv")) + ] ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc927/libiserv.nix b/materialized/ghc-boot-packages-nix/ghc927/libiserv.nix new file mode 100644 index 0000000000..0525058a17 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc927/libiserv.nix @@ -0,0 +1,42 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { network = false; }; + package = { + specVersion = "1.10"; + identifier = { name = "libiserv"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "Provides shared functionality between iserv and iserv-proxy."; + description = "Provides shared functionality between iserv and iserv-proxy."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = ([ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ] ++ (pkgs.lib).optionals (flags.network) [ + (hsPkgs."network" or (errorHandler.buildDepError "network")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + ]) ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc927/pretty.nix b/materialized/ghc-boot-packages-nix/ghc927/pretty.nix new file mode 100644 index 0000000000..df71370d97 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc927/pretty.nix @@ -0,0 +1,56 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.8"; + identifier = { name = "pretty"; version = "1.1.3.6"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "David Terei "; + author = ""; + homepage = "http://github.com/haskell/pretty"; + url = ""; + synopsis = "Pretty-printing library"; + description = "This package contains a pretty-printing library, a set of API's\nthat provides a way to easily print out text in a consistent\nformat of your choosing. This is useful for compilers and related\ntools.\n\nThis library was originally designed by John Hughes's and has since\nbeen heavily modified by Simon Peyton Jones."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + ]; + buildable = true; + }; + tests = { + "test-pretty" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + ]; + buildable = true; + }; + }; + benchmarks = { + "pretty-bench" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."criterion" or (errorHandler.buildDepError "criterion")) + (hsPkgs."pretty" or (errorHandler.buildDepError "pretty")) + ]; + buildable = true; + }; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc927/remote-iserv.nix b/materialized/ghc-boot-packages-nix/ghc927/remote-iserv.nix new file mode 100644 index 0000000000..085b4cec0d --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc927/remote-iserv.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "remote-iserv"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "Moritz Angermann "; + author = "Moritz Angermann "; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "This is a very simple remote runner for iserv, to be used together\nwith iserv-proxy. The foundamental idea is that this this wrapper\nstarts running libiserv on a given port to which iserv-proxy will\nthen connect."; + buildType = "Simple"; + }; + components = { + exes = { + "remote-iserv" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."libiserv" or (errorHandler.buildDepError "libiserv")) + ]; + buildable = true; + }; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc927/template-haskell.nix b/materialized/ghc-boot-packages-nix/ghc927/template-haskell.nix new file mode 100644 index 0000000000..50cba533b7 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc927/template-haskell.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "template-haskell"; version = "2.18.0.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Support library for Template Haskell"; + description = "This package provides modules containing facilities for manipulating\nHaskell source code using Template Haskell.\n\nSee for more\ninformation."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-boot-th" or (errorHandler.buildDepError "ghc-boot-th")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."pretty" or (errorHandler.buildDepError "pretty")) + ]; + buildable = true; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ./.; } diff --git a/materialized/ghc-extra-projects/default/ghc927/.plan.nix/Win32.nix b/materialized/ghc-extra-projects/default/ghc927/.plan.nix/Win32.nix new file mode 100644 index 0000000000..fb9671c831 --- /dev/null +++ b/materialized/ghc-extra-projects/default/ghc927/.plan.nix/Win32.nix @@ -0,0 +1,158 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "2.0"; + identifier = { name = "Win32"; version = "2.12.0.1"; }; + license = "BSD-3-Clause"; + copyright = "Alastair Reid, 1999-2003; shelarcy, 2012-2013; Tamar Christina, 2016-2020"; + maintainer = "Haskell Libraries "; + author = "Alastair Reid, shelarcy, Tamar Christina"; + homepage = "https://github.com/haskell/win32"; + url = ""; + synopsis = "A binding to Windows Win32 API."; + description = "This library contains direct bindings to the Windows Win32 APIs for Haskell."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = [ "LICENSE" ]; + dataDir = "."; + dataFiles = []; + extraSrcFiles = [ + "include/diatemp.h" + "include/dumpBMP.h" + "include/ellipse.h" + "include/errors.h" + "include/Win32Aux.h" + "include/win32debug.h" + "include/alignment.h" + "changelog.md" + ]; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + ] ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unbuildable" or (errorHandler.buildDepError "unbuildable")); + libs = [ + (pkgs."user32" or (errorHandler.sysDepError "user32")) + (pkgs."gdi32" or (errorHandler.sysDepError "gdi32")) + (pkgs."winmm" or (errorHandler.sysDepError "winmm")) + (pkgs."advapi32" or (errorHandler.sysDepError "advapi32")) + (pkgs."shell32" or (errorHandler.sysDepError "shell32")) + (pkgs."shfolder" or (errorHandler.sysDepError "shfolder")) + (pkgs."shlwapi" or (errorHandler.sysDepError "shlwapi")) + (pkgs."msimg32" or (errorHandler.sysDepError "msimg32")) + (pkgs."imm32" or (errorHandler.sysDepError "imm32")) + ]; + build-tools = [ + (hsPkgs.buildPackages.hsc2hs.components.exes.hsc2hs or (pkgs.buildPackages.hsc2hs or (errorHandler.buildToolDepError "hsc2hs:hsc2hs"))) + ]; + buildable = if !system.isWindows then false else true; + modules = [ + "Graphics/Win32/GDI" + "Graphics/Win32/GDI/Bitmap" + "Graphics/Win32/GDI/Brush" + "Graphics/Win32/GDI/Clip" + "Graphics/Win32/GDI/Font" + "Graphics/Win32/GDI/Graphics2D" + "Graphics/Win32/GDI/HDC" + "Graphics/Win32/GDI/Palette" + "Graphics/Win32/GDI/Path" + "Graphics/Win32/GDI/Pen" + "Graphics/Win32/GDI/Region" + "Graphics/Win32/GDI/Types" + "Graphics/Win32" + "Graphics/Win32/Control" + "Graphics/Win32/Dialogue" + "Graphics/Win32/Icon" + "Graphics/Win32/Key" + "Graphics/Win32/Menu" + "Graphics/Win32/Message" + "Graphics/Win32/Misc" + "Graphics/Win32/Resource" + "Graphics/Win32/Window" + "Graphics/Win32/LayeredWindow" + "Graphics/Win32/GDI/AlphaBlend" + "Graphics/Win32/Window/AnimateWindow" + "Graphics/Win32/Window/HotKey" + "Graphics/Win32/Window/IMM" + "Graphics/Win32/Window/ForegroundWindow" + "Graphics/Win32/Window/PostMessage" + "Media/Win32" + "System/Win32" + "System/Win32/DebugApi" + "System/Win32/DLL" + "System/Win32/Event" + "System/Win32/File" + "System/Win32/FileMapping" + "System/Win32/Info" + "System/Win32/Path" + "System/Win32/Mem" + "System/Win32/MinTTY" + "System/Win32/NLS" + "System/Win32/Process" + "System/Win32/Registry" + "System/Win32/SimpleMAPI" + "System/Win32/Time" + "System/Win32/Console" + "System/Win32/Security" + "System/Win32/Types" + "System/Win32/Shell" + "System/Win32/Automation" + "System/Win32/Automation/Input" + "System/Win32/Automation/Input/Key" + "System/Win32/Automation/Input/Mouse" + "System/Win32/Console/CtrlHandler" + "System/Win32/Console/HWND" + "System/Win32/Console/Title" + "System/Win32/Encoding" + "System/Win32/Exception/Unsupported" + "System/Win32/HardLink" + "System/Win32/Info/Computer" + "System/Win32/Info/Version" + "System/Win32/String" + "System/Win32/SymbolicLink" + "System/Win32/Thread" + "System/Win32/Utils" + "System/Win32/Word" + ]; + cSources = [ + "cbits/HsGDI.c" + "cbits/HsWin32.c" + "cbits/WndProc.c" + "cbits/diatemp.c" + "cbits/dumpBMP.c" + "cbits/ellipse.c" + "cbits/errors.c" + "cbits/alphablend.c" + ]; + includeDirs = [ "include" ]; + includes = [ + "alphablend.h" + "diatemp.h" + "dumpBMP.h" + "ellipse.h" + "errors.h" + "HsGDI.h" + "HsWin32.h" + "Win32Aux.h" + "win32debug.h" + "windows_cconv.h" + "WndProc.h" + "alignment.h" + ]; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../libraries/Win32; } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/default/ghc927/.plan.nix/ghc-boot.nix b/materialized/ghc-extra-projects/default/ghc927/.plan.nix/ghc-boot.nix new file mode 100644 index 0000000000..d4fff2782c --- /dev/null +++ b/materialized/ghc-extra-projects/default/ghc927/.plan.nix/ghc-boot.nix @@ -0,0 +1,64 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "ghc-boot"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Shared functionality between GHC and its boot libraries"; + description = "This library is shared between GHC, ghc-pkg, and other boot\nlibraries.\n.\nA note about \"GHC.Unit.Database\": it only deals with the subset of\nthe package database that the compiler cares about: modules\npaths etc and not package metadata like description, authors\netc. It is thus not a library interface to ghc-pkg and is *not*\nsuitable for modifying GHC package databases.\n.\nThe package database format and this library are constructed in\nsuch a way that while ghc-pkg depends on Cabal, the GHC library\nand program do not have to depend on Cabal."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = [ "LICENSE" ]; + dataDir = "."; + dataFiles = []; + extraSrcFiles = [ "changelog.md" ]; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghc-boot-th" or (errorHandler.buildDepError "ghc-boot-th")) + ] ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + modules = [ + "GHC/BaseDir" + "GHC/Data/ShortText" + "GHC/Data/SizedSeq" + "GHC/Utils/Encoding" + "GHC/LanguageExtensions" + "GHC/Unit/Database" + "GHC/Serialized" + "GHC/ForeignSrcLang" + "GHC/HandleEncoding" + "GHC/Platform/ArchOS" + "GHC/Platform/Host" + "GHC/Settings/Utils" + "GHC/UniqueSubdir" + "GHC/Version" + ]; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../libraries/ghc-boot; } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/default/ghc927/.plan.nix/ghc.nix b/materialized/ghc-extra-projects/default/ghc927/.plan.nix/ghc.nix new file mode 100644 index 0000000000..071b71777b --- /dev/null +++ b/materialized/ghc-extra-projects/default/ghc927/.plan.nix/ghc.nix @@ -0,0 +1,662 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { + internal-interpreter = false; + stage1 = false; + stage2 = false; + stage3 = false; + terminfo = true; + dynamic-system-linker = true; + }; + package = { + specVersion = "1.22"; + identifier = { name = "ghc"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "glasgow-haskell-users@haskell.org"; + author = "The GHC Team"; + homepage = "http://www.haskell.org/ghc/"; + url = ""; + synopsis = "The GHC API"; + description = "GHC's functionality can be useful for more things than just\ncompiling Haskell programs. Important use cases are programs\nthat analyse (and perhaps transform) Haskell code. Others\ninclude loading Haskell code dynamically in a GHCi-like manner.\nFor this reason, a lot of GHC's functionality is made available\nthrough this package.\n\nSee \nfor more information."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = [ "LICENSE" ]; + dataDir = "."; + dataFiles = []; + extraSrcFiles = []; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."hpc" or (errorHandler.buildDepError "hpc")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."exceptions" or (errorHandler.buildDepError "exceptions")) + (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot")) + (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ] ++ (if system.isWindows + then [ (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) ] + else [ + (hsPkgs."unix" or (errorHandler.buildDepError "unix")) + ] ++ (pkgs.lib).optional (flags.terminfo) (hsPkgs."terminfo" or (errorHandler.buildDepError "terminfo"))); + buildable = true; + modules = [ + "GHC" + "GHC/Builtin/Names" + "GHC/Builtin/Names/TH" + "GHC/Builtin/PrimOps" + "GHC/Builtin/Types" + "GHC/Builtin/Types/Literals" + "GHC/Builtin/Types/Prim" + "GHC/Builtin/Uniques" + "GHC/Builtin/Utils" + "GHC/ByteCode/Asm" + "GHC/ByteCode/InfoTable" + "GHC/ByteCode/Instr" + "GHC/ByteCode/Linker" + "GHC/ByteCode/Types" + "GHC/Cmm" + "GHC/Cmm/BlockId" + "GHC/Cmm/CallConv" + "GHC/Cmm/CLabel" + "GHC/Cmm/CommonBlockElim" + "GHC/Cmm/ContFlowOpt" + "GHC/Cmm/Dataflow" + "GHC/Cmm/Dataflow/Block" + "GHC/Cmm/Dataflow/Collections" + "GHC/Cmm/Dataflow/Graph" + "GHC/Cmm/Dataflow/Label" + "GHC/Cmm/DebugBlock" + "GHC/Cmm/Expr" + "GHC/Cmm/Graph" + "GHC/Cmm/Info" + "GHC/Cmm/Info/Build" + "GHC/Cmm/LayoutStack" + "GHC/Cmm/Lexer" + "GHC/Cmm/Lint" + "GHC/Cmm/Liveness" + "GHC/Cmm/MachOp" + "GHC/Cmm/Node" + "GHC/Cmm/Opt" + "GHC/Cmm/Parser" + "GHC/Cmm/Parser/Monad" + "GHC/Cmm/Pipeline" + "GHC/Cmm/Ppr" + "GHC/Cmm/Ppr/Decl" + "GHC/Cmm/Ppr/Expr" + "GHC/Cmm/ProcPoint" + "GHC/Cmm/Sink" + "GHC/Cmm/Switch" + "GHC/Cmm/Switch/Implement" + "GHC/CmmToAsm" + "GHC/Cmm/LRegSet" + "GHC/CmmToAsm/AArch64" + "GHC/CmmToAsm/AArch64/CodeGen" + "GHC/CmmToAsm/AArch64/Cond" + "GHC/CmmToAsm/AArch64/Instr" + "GHC/CmmToAsm/AArch64/Ppr" + "GHC/CmmToAsm/AArch64/RegInfo" + "GHC/CmmToAsm/AArch64/Regs" + "GHC/CmmToAsm/BlockLayout" + "GHC/CmmToAsm/CFG" + "GHC/CmmToAsm/CFG/Dominators" + "GHC/CmmToAsm/CFG/Weight" + "GHC/CmmToAsm/Config" + "GHC/CmmToAsm/CPrim" + "GHC/CmmToAsm/Dwarf" + "GHC/CmmToAsm/Dwarf/Constants" + "GHC/CmmToAsm/Dwarf/Types" + "GHC/CmmToAsm/Format" + "GHC/CmmToAsm/Instr" + "GHC/CmmToAsm/Monad" + "GHC/CmmToAsm/PIC" + "GHC/CmmToAsm/PPC" + "GHC/CmmToAsm/PPC/CodeGen" + "GHC/CmmToAsm/PPC/Cond" + "GHC/CmmToAsm/PPC/Instr" + "GHC/CmmToAsm/PPC/Ppr" + "GHC/CmmToAsm/PPC/RegInfo" + "GHC/CmmToAsm/PPC/Regs" + "GHC/CmmToAsm/Ppr" + "GHC/CmmToAsm/Reg/Graph" + "GHC/CmmToAsm/Reg/Graph/Base" + "GHC/CmmToAsm/Reg/Graph/Coalesce" + "GHC/CmmToAsm/Reg/Graph/Spill" + "GHC/CmmToAsm/Reg/Graph/SpillClean" + "GHC/CmmToAsm/Reg/Graph/SpillCost" + "GHC/CmmToAsm/Reg/Graph/Stats" + "GHC/CmmToAsm/Reg/Graph/TrivColorable" + "GHC/CmmToAsm/Reg/Graph/X86" + "GHC/CmmToAsm/Reg/Linear" + "GHC/CmmToAsm/Reg/Linear/AArch64" + "GHC/CmmToAsm/Reg/Linear/Base" + "GHC/CmmToAsm/Reg/Linear/FreeRegs" + "GHC/CmmToAsm/Reg/Linear/JoinToTargets" + "GHC/CmmToAsm/Reg/Linear/PPC" + "GHC/CmmToAsm/Reg/Linear/SPARC" + "GHC/CmmToAsm/Reg/Linear/StackMap" + "GHC/CmmToAsm/Reg/Linear/State" + "GHC/CmmToAsm/Reg/Linear/Stats" + "GHC/CmmToAsm/Reg/Linear/X86" + "GHC/CmmToAsm/Reg/Linear/X86_64" + "GHC/CmmToAsm/Reg/Liveness" + "GHC/CmmToAsm/Reg/Target" + "GHC/CmmToAsm/Reg/Utils" + "GHC/CmmToAsm/SPARC" + "GHC/CmmToAsm/SPARC/AddrMode" + "GHC/CmmToAsm/SPARC/Base" + "GHC/CmmToAsm/SPARC/CodeGen" + "GHC/CmmToAsm/SPARC/CodeGen/Amode" + "GHC/CmmToAsm/SPARC/CodeGen/Base" + "GHC/CmmToAsm/SPARC/CodeGen/CondCode" + "GHC/CmmToAsm/SPARC/CodeGen/Expand" + "GHC/CmmToAsm/SPARC/CodeGen/Gen32" + "GHC/CmmToAsm/SPARC/CodeGen/Gen64" + "GHC/CmmToAsm/SPARC/CodeGen/Sanity" + "GHC/CmmToAsm/SPARC/Cond" + "GHC/CmmToAsm/SPARC/Imm" + "GHC/CmmToAsm/SPARC/Instr" + "GHC/CmmToAsm/SPARC/Ppr" + "GHC/CmmToAsm/SPARC/Regs" + "GHC/CmmToAsm/SPARC/ShortcutJump" + "GHC/CmmToAsm/SPARC/Stack" + "GHC/CmmToAsm/Types" + "GHC/CmmToAsm/Utils" + "GHC/CmmToAsm/X86" + "GHC/CmmToAsm/X86/CodeGen" + "GHC/CmmToAsm/X86/Cond" + "GHC/CmmToAsm/X86/Instr" + "GHC/CmmToAsm/X86/Ppr" + "GHC/CmmToAsm/X86/RegInfo" + "GHC/CmmToAsm/X86/Regs" + "GHC/CmmToC" + "GHC/CmmToLlvm" + "GHC/CmmToLlvm/Base" + "GHC/CmmToLlvm/CodeGen" + "GHC/CmmToLlvm/Data" + "GHC/CmmToLlvm/Mangler" + "GHC/CmmToLlvm/Ppr" + "GHC/CmmToLlvm/Regs" + "GHC/Cmm/Type" + "GHC/Cmm/Utils" + "GHC/Core" + "GHC/Core/Class" + "GHC/Core/Coercion" + "GHC/Core/Coercion/Axiom" + "GHC/Core/Coercion/Opt" + "GHC/Core/ConLike" + "GHC/Core/DataCon" + "GHC/Core/FamInstEnv" + "GHC/Core/FVs" + "GHC/Core/InstEnv" + "GHC/Core/Lint" + "GHC/Core/Make" + "GHC/Core/Map/Expr" + "GHC/Core/Map/Type" + "GHC/Core/Multiplicity" + "GHC/Core/Opt/Arity" + "GHC/Core/Opt/CallArity" + "GHC/Core/Opt/CallerCC" + "GHC/Core/Opt/ConstantFold" + "GHC/Core/Opt/CprAnal" + "GHC/Core/Opt/CSE" + "GHC/Core/Opt/DmdAnal" + "GHC/Core/Opt/Exitify" + "GHC/Core/Opt/FloatIn" + "GHC/Core/Opt/FloatOut" + "GHC/Core/Opt/LiberateCase" + "GHC/Core/Opt/Monad" + "GHC/Core/Opt/OccurAnal" + "GHC/Core/Opt/Pipeline" + "GHC/Core/Opt/SetLevels" + "GHC/Core/Opt/Simplify" + "GHC/Core/Opt/Simplify/Env" + "GHC/Core/Opt/Simplify/Monad" + "GHC/Core/Opt/Simplify/Utils" + "GHC/Core/Opt/SpecConstr" + "GHC/Core/Opt/Specialise" + "GHC/Core/Opt/StaticArgs" + "GHC/Core/Opt/WorkWrap" + "GHC/Core/Opt/WorkWrap/Utils" + "GHC/Core/PatSyn" + "GHC/Core/Ppr" + "GHC/Types/TyThing/Ppr" + "GHC/Core/Predicate" + "GHC/Core/Rules" + "GHC/Core/Seq" + "GHC/Core/SimpleOpt" + "GHC/Core/Stats" + "GHC/Core/Subst" + "GHC/Core/Tidy" + "GHC/CoreToIface" + "GHC/CoreToStg" + "GHC/CoreToStg/Prep" + "GHC/Core/TyCo/FVs" + "GHC/Core/TyCon" + "GHC/Core/TyCon/Env" + "GHC/Core/TyCon/RecWalk" + "GHC/Core/TyCon/Set" + "GHC/Core/TyCo/Ppr" + "GHC/Core/TyCo/Rep" + "GHC/Core/TyCo/Subst" + "GHC/Core/TyCo/Tidy" + "GHC/Core/Type" + "GHC/Core/Unfold" + "GHC/Core/Unfold/Make" + "GHC/Core/Unify" + "GHC/Core/UsageEnv" + "GHC/Core/Utils" + "GHC/Data/Bag" + "GHC/Data/Bitmap" + "GHC/Data/BooleanFormula" + "GHC/Data/EnumSet" + "GHC/Data/FastMutInt" + "GHC/Data/FastString" + "GHC/Data/FastString/Env" + "GHC/Data/FiniteMap" + "GHC/Data/Graph/Base" + "GHC/Data/Graph/Color" + "GHC/Data/Graph/Directed" + "GHC/Data/Graph/Ops" + "GHC/Data/Graph/Ppr" + "GHC/Data/Graph/UnVar" + "GHC/Data/IOEnv" + "GHC/Data/List/SetOps" + "GHC/Data/Maybe" + "GHC/Data/OrdList" + "GHC/Data/Pair" + "GHC/Data/Stream" + "GHC/Data/StringBuffer" + "GHC/Data/TrieMap" + "GHC/Data/UnionFind" + "GHC/Driver/Backend" + "GHC/Driver/Backpack" + "GHC/Driver/Backpack/Syntax" + "GHC/Driver/CmdLine" + "GHC/Driver/CodeOutput" + "GHC/Driver/Config" + "GHC/Driver/Env" + "GHC/Driver/Env/Types" + "GHC/Driver/Errors" + "GHC/Driver/Flags" + "GHC/Driver/Hooks" + "GHC/Driver/Main" + "GHC/Driver/Make" + "GHC/Driver/MakeFile" + "GHC/Driver/Monad" + "GHC/Driver/Phases" + "GHC/Driver/Pipeline" + "GHC/Driver/Pipeline/Monad" + "GHC/Driver/Plugins" + "GHC/Driver/Ppr" + "GHC/Driver/Session" + "GHC/Hs" + "GHC/Hs/Binds" + "GHC/Hs/Decls" + "GHC/Hs/Doc" + "GHC/Hs/Dump" + "GHC/Hs/Expr" + "GHC/Hs/Extension" + "GHC/Hs/ImpExp" + "GHC/Hs/Instances" + "GHC/Hs/Lit" + "GHC/Hs/Pat" + "GHC/Hs/Stats" + "GHC/HsToCore" + "GHC/HsToCore/Arrows" + "GHC/HsToCore/Binds" + "GHC/HsToCore/Coverage" + "GHC/HsToCore/Docs" + "GHC/HsToCore/Expr" + "GHC/HsToCore/Foreign/Call" + "GHC/HsToCore/Foreign/Decl" + "GHC/HsToCore/GuardedRHSs" + "GHC/HsToCore/ListComp" + "GHC/HsToCore/Match" + "GHC/HsToCore/Match/Constructor" + "GHC/HsToCore/Match/Literal" + "GHC/HsToCore/Monad" + "GHC/HsToCore/Pmc" + "GHC/HsToCore/Pmc/Check" + "GHC/HsToCore/Pmc/Desugar" + "GHC/HsToCore/Pmc/Ppr" + "GHC/HsToCore/Pmc/Solver" + "GHC/HsToCore/Pmc/Solver/Types" + "GHC/HsToCore/Pmc/Types" + "GHC/HsToCore/Pmc/Utils" + "GHC/HsToCore/Quote" + "GHC/HsToCore/Types" + "GHC/HsToCore/Usage" + "GHC/HsToCore/Utils" + "GHC/Hs/Type" + "GHC/Hs/Utils" + "GHC/Iface/Binary" + "GHC/Iface/Env" + "GHC/Iface/Ext/Ast" + "GHC/Iface/Ext/Binary" + "GHC/Iface/Ext/Debug" + "GHC/Iface/Ext/Fields" + "GHC/Iface/Ext/Types" + "GHC/Iface/Ext/Utils" + "GHC/Iface/Load" + "GHC/Iface/Make" + "GHC/Iface/Recomp" + "GHC/Iface/Recomp/Binary" + "GHC/Iface/Recomp/Flags" + "GHC/Iface/Rename" + "GHC/Iface/Syntax" + "GHC/Iface/Tidy" + "GHC/Iface/Tidy/StaticPtrTable" + "GHC/IfaceToCore" + "GHC/Iface/Type" + "GHC/Linker" + "GHC/Linker/Dynamic" + "GHC/Linker/ExtraObj" + "GHC/Linker/Loader" + "GHC/Linker/MacOS" + "GHC/Linker/Static" + "GHC/Linker/Types" + "GHC/Linker/Unit" + "GHC/Linker/Windows" + "GHC/Llvm" + "GHC/Llvm/MetaData" + "GHC/Llvm/Ppr" + "GHC/Llvm/Syntax" + "GHC/Llvm/Types" + "GHC/Parser" + "GHC/Parser/Annotation" + "GHC/Parser/CharClass" + "GHC/Parser/Errors" + "GHC/Parser/Errors/Ppr" + "GHC/Parser/Header" + "GHC/Parser/Lexer" + "GHC/Parser/PostProcess" + "GHC/Parser/PostProcess/Haddock" + "GHC/Parser/Types" + "GHC/Parser/Utils" + "GHC/Platform" + "GHC/Platform/ARM" + "GHC/Platform/AArch64" + "GHC/Platform/Constants" + "GHC/Platform/NoRegs" + "GHC/Platform/PPC" + "GHC/Platform/Profile" + "GHC/Platform/Reg" + "GHC/Platform/Reg/Class" + "GHC/Platform/Regs" + "GHC/Platform/RISCV64" + "GHC/Platform/S390X" + "GHC/Platform/SPARC" + "GHC/Platform/Ways" + "GHC/Platform/X86" + "GHC/Platform/X86_64" + "GHC/Plugins" + "GHC/Prelude" + "GHC/Rename/Bind" + "GHC/Rename/Env" + "GHC/Rename/Expr" + "GHC/Rename/Fixity" + "GHC/Rename/HsType" + "GHC/Rename/Module" + "GHC/Rename/Names" + "GHC/Rename/Pat" + "GHC/Rename/Splice" + "GHC/Rename/Unbound" + "GHC/Rename/Utils" + "GHC/Runtime/Context" + "GHC/Runtime/Debugger" + "GHC/Runtime/Eval" + "GHC/Runtime/Eval/Types" + "GHC/Runtime/Heap/Inspect" + "GHC/Runtime/Heap/Layout" + "GHC/Runtime/Interpreter" + "GHC/Runtime/Interpreter/Types" + "GHC/Runtime/Loader" + "GHC/Settings" + "GHC/Settings/Config" + "GHC/Settings/Constants" + "GHC/Settings/IO" + "GHC/Stg/CSE" + "GHC/Stg/Debug" + "GHC/Stg/DepAnal" + "GHC/Stg/FVs" + "GHC/Stg/Lift" + "GHC/Stg/Lift/Analysis" + "GHC/Stg/Lift/Monad" + "GHC/Stg/Lint" + "GHC/Stg/Pipeline" + "GHC/Stg/Stats" + "GHC/Stg/Subst" + "GHC/Stg/Syntax" + "GHC/StgToByteCode" + "GHC/StgToCmm" + "GHC/StgToCmm/ArgRep" + "GHC/StgToCmm/Bind" + "GHC/StgToCmm/CgUtils" + "GHC/StgToCmm/Closure" + "GHC/StgToCmm/DataCon" + "GHC/StgToCmm/Env" + "GHC/StgToCmm/Expr" + "GHC/StgToCmm/ExtCode" + "GHC/StgToCmm/Foreign" + "GHC/StgToCmm/Heap" + "GHC/StgToCmm/Hpc" + "GHC/StgToCmm/Layout" + "GHC/StgToCmm/Lit" + "GHC/StgToCmm/Monad" + "GHC/StgToCmm/Prim" + "GHC/StgToCmm/Prof" + "GHC/StgToCmm/Ticky" + "GHC/StgToCmm/Types" + "GHC/StgToCmm/Utils" + "GHC/Stg/Unarise" + "GHC/SysTools" + "GHC/SysTools/Ar" + "GHC/SysTools/BaseDir" + "GHC/SysTools/Elf" + "GHC/SysTools/Info" + "GHC/SysTools/Process" + "GHC/SysTools/Tasks" + "GHC/SysTools/Terminal" + "GHC/Tc/Deriv" + "GHC/Tc/Deriv/Functor" + "GHC/Tc/Deriv/Generate" + "GHC/Tc/Deriv/Generics" + "GHC/Tc/Deriv/Infer" + "GHC/Tc/Deriv/Utils" + "GHC/Tc/Errors" + "GHC/Tc/Errors/Hole" + "GHC/Tc/Errors/Hole/FitTypes" + "GHC/Tc/Gen/Annotation" + "GHC/Tc/Gen/App" + "GHC/Tc/Gen/Arrow" + "GHC/Tc/Gen/Bind" + "GHC/Tc/Gen/Default" + "GHC/Tc/Gen/Export" + "GHC/Tc/Gen/Expr" + "GHC/Tc/Gen/Foreign" + "GHC/Tc/Gen/Head" + "GHC/Tc/Gen/HsType" + "GHC/Tc/Gen/Match" + "GHC/Tc/Gen/Pat" + "GHC/Tc/Gen/Rule" + "GHC/Tc/Gen/Sig" + "GHC/Tc/Gen/Splice" + "GHC/Tc/Instance/Class" + "GHC/Tc/Instance/Family" + "GHC/Tc/Instance/FunDeps" + "GHC/Tc/Instance/Typeable" + "GHC/Tc/Module" + "GHC/Tc/Plugin" + "GHC/Tc/Solver" + "GHC/Tc/Solver/Canonical" + "GHC/Tc/Solver/Rewrite" + "GHC/Tc/Solver/Interact" + "GHC/Tc/Solver/Monad" + "GHC/Tc/TyCl" + "GHC/Tc/TyCl/Build" + "GHC/Tc/TyCl/Class" + "GHC/Tc/TyCl/Instance" + "GHC/Tc/TyCl/PatSyn" + "GHC/Tc/TyCl/Utils" + "GHC/Tc/Types" + "GHC/Tc/Types/Constraint" + "GHC/Tc/Types/Evidence" + "GHC/Tc/Types/EvTerm" + "GHC/Tc/Types/Origin" + "GHC/Tc/Utils/Backpack" + "GHC/Tc/Utils/Env" + "GHC/Tc/Utils/Instantiate" + "GHC/Tc/Utils/Monad" + "GHC/Tc/Utils/TcMType" + "GHC/Tc/Utils/TcType" + "GHC/Tc/Utils/Unify" + "GHC/Tc/Utils/Zonk" + "GHC/Tc/Validity" + "GHC/ThToHs" + "GHC/Types/Annotations" + "GHC/Types/Avail" + "GHC/Types/Basic" + "GHC/Types/CompleteMatch" + "GHC/Types/CostCentre" + "GHC/Types/CostCentre/State" + "GHC/Types/Cpr" + "GHC/Types/Demand" + "GHC/Types/Error" + "GHC/Types/FieldLabel" + "GHC/Types/Fixity" + "GHC/Types/Fixity/Env" + "GHC/Types/ForeignCall" + "GHC/Types/ForeignStubs" + "GHC/Types/HpcInfo" + "GHC/Types/Id" + "GHC/Types/IPE" + "GHC/Types/Id/Info" + "GHC/Types/Id/Make" + "GHC/Types/Literal" + "GHC/Types/Meta" + "GHC/Types/Name" + "GHC/Types/Name/Cache" + "GHC/Types/Name/Env" + "GHC/Types/Name/Occurrence" + "GHC/Types/Name/Reader" + "GHC/Types/Name/Set" + "GHC/Types/Name/Shape" + "GHC/Types/Name/Ppr" + "GHC/Types/RepType" + "GHC/Types/SafeHaskell" + "GHC/Types/SourceError" + "GHC/Types/SourceFile" + "GHC/Types/SourceText" + "GHC/Types/SrcLoc" + "GHC/Types/Target" + "GHC/Types/Tickish" + "GHC/Types/TypeEnv" + "GHC/Types/TyThing" + "GHC/Types/Unique" + "GHC/Types/Unique/DFM" + "GHC/Types/Unique/DSet" + "GHC/Types/Unique/FM" + "GHC/Types/Unique/Map" + "GHC/Types/Unique/SDFM" + "GHC/Types/Unique/Set" + "GHC/Types/Unique/Supply" + "GHC/Types/Var" + "GHC/Types/Var/Env" + "GHC/Types/Var/Set" + "GHC/Unit" + "GHC/Unit/Env" + "GHC/Unit/External" + "GHC/Unit/Finder" + "GHC/Unit/Finder/Types" + "GHC/Unit/Home" + "GHC/Unit/Home/ModInfo" + "GHC/Unit/Info" + "GHC/Unit/Module" + "GHC/Unit/Module/Deps" + "GHC/Unit/Module/Env" + "GHC/Unit/Module/Graph" + "GHC/Unit/Module/Imported" + "GHC/Unit/Module/Location" + "GHC/Unit/Module/ModDetails" + "GHC/Unit/Module/ModGuts" + "GHC/Unit/Module/ModIface" + "GHC/Unit/Module/ModSummary" + "GHC/Unit/Module/Name" + "GHC/Unit/Module/Status" + "GHC/Unit/Module/Warnings" + "GHC/Unit/Parser" + "GHC/Unit/Ppr" + "GHC/Unit/State" + "GHC/Unit/Types" + "GHC/Utils/Asm" + "GHC/Utils/Binary" + "GHC/Utils/Binary/Typeable" + "GHC/Utils/BufHandle" + "GHC/Utils/CliOption" + "GHC/Utils/Error" + "GHC/Utils/Exception" + "GHC/Utils/Fingerprint" + "GHC/Utils/FV" + "GHC/Utils/GlobalVars" + "GHC/Utils/IO/Unsafe" + "GHC/Utils/Json" + "GHC/Utils/Lexeme" + "GHC/Utils/Logger" + "GHC/Utils/Misc" + "GHC/Utils/Monad" + "GHC/Utils/Monad/State" + "GHC/Utils/Outputable" + "GHC/Utils/Panic" + "GHC/Utils/Panic/Plain" + "GHC/Utils/Ppr" + "GHC/Utils/Ppr/Colour" + "GHC/Utils/TmpFs" + "Language/Haskell/Syntax" + "Language/Haskell/Syntax/Binds" + "Language/Haskell/Syntax/Decls" + "Language/Haskell/Syntax/Expr" + "Language/Haskell/Syntax/Extension" + "Language/Haskell/Syntax/Lit" + "Language/Haskell/Syntax/Pat" + "Language/Haskell/Syntax/Type" + ]; + cSources = [ + "cbits/cutils.c" + "cbits/genSym.c" + "cbits/keepCAFsForGHCi.c" + ]; + hsSourceDirs = [ "." ]; + includeDirs = ([ + "." + ] ++ (pkgs.lib).optional (flags.internal-interpreter) "../rts/dist/build") ++ (if flags.stage1 + then [ "stage1" ] + else if flags.stage2 + then [ "stage2" ] + else (pkgs.lib).optional (flags.stage3) "stage2"); + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../compiler; } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/default/ghc927/.plan.nix/ghci.nix b/materialized/ghc-extra-projects/default/ghc927/.plan.nix/ghci.nix new file mode 100644 index 0000000000..e17d0ce030 --- /dev/null +++ b/materialized/ghc-extra-projects/default/ghc927/.plan.nix/ghci.nix @@ -0,0 +1,70 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { internal-interpreter = false; }; + package = { + specVersion = "1.10"; + identifier = { name = "ghci"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "The library supporting GHC's interactive interpreter"; + description = "This library offers interfaces which mediate interactions between the\n@ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter\nbackend."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = [ "LICENSE" ]; + dataDir = "."; + dataFiles = []; + extraSrcFiles = [ "changelog.md" ]; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + "library" = { + depends = [ + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot")) + (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + ] ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + modules = [ + "GHCi/BreakArray" + "GHCi/BinaryArray" + "GHCi/Message" + "GHCi/ResolvedBCO" + "GHCi/RemoteTypes" + "GHCi/FFI" + "GHCi/TH/Binary" + ] ++ (pkgs.lib).optionals (flags.internal-interpreter) [ + "GHCi/InfoTable" + "GHCi/Run" + "GHCi/CreateBCO" + "GHCi/ObjLink" + "GHCi/Signals" + "GHCi/StaticPtrTable" + "GHCi/TH" + ]; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../libraries/ghci; } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/default/ghc927/.plan.nix/hpc.nix b/materialized/ghc-extra-projects/default/ghc927/.plan.nix/hpc.nix new file mode 100644 index 0000000000..260c9b2b88 --- /dev/null +++ b/materialized/ghc-extra-projects/default/ghc927/.plan.nix/hpc.nix @@ -0,0 +1,52 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "hpc"; version = "0.6.1.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = "Andy Gill"; + homepage = ""; + url = ""; + synopsis = "Code Coverage Library for Haskell"; + description = "This package provides the code coverage library for Haskell.\n\nSee for more\ninformation."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = [ "LICENSE" ]; + dataDir = "."; + dataFiles = []; + extraSrcFiles = [ "changelog.md" ]; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + ]; + buildable = true; + modules = [ + "Trace/Hpc/Util" + "Trace/Hpc/Mix" + "Trace/Hpc/Tix" + "Trace/Hpc/Reflect" + ]; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../libraries/hpc; } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/default/ghc927/.plan.nix/iserv-proxy.nix b/materialized/ghc-extra-projects/default/ghc927/.plan.nix/iserv-proxy.nix new file mode 100644 index 0000000000..405c965d5c --- /dev/null +++ b/materialized/ghc-extra-projects/default/ghc927/.plan.nix/iserv-proxy.nix @@ -0,0 +1,55 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "iserv-proxy"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "GHC can be provided with a path to the iserv binary with\n@-pgmi=/path/to/iserv-bin@, and will in combination with\n@-fexternal-interpreter@, compile Template Haskell though the\n@iserv-bin@ delegate. This is very similar to how ghcjs has been\ncompiling Template Haskell, by spawning a separate delegate (so\ncalled runner on the javascript vm) and evaluating the splices\nthere.\n\niserv can also be used in combination with cross compilation. For\nthis, the @iserv-proxy@ needs to be built on the host, targeting the\nhost (as it is running on the host). @cabal install -flibrary\n-fproxy@ will yield the proxy.\n\nUsing the cabal for the target @arch-platform-target-cabal install\n-flibrary@ will build the required library that contains the ffi\n@startSlave@ function, which needs to be invoked on the target\n(e.g. in an iOS application) to start the remote iserv slave.\n\ncalling the GHC cross compiler with @-fexternal-interpreter\n-pgmi=$HOME/.cabal/bin/iserv-proxy -opti\\ -opti\\@\nwill cause it to compile Template Haskell via the remote at \\.\n\nThus to get cross compilation with Template Haskell follow the\nfollowing receipt:\n\n* compile the iserv library for your target\n\n> iserv $ arch-platform-target-cabal install -flibrary\n\n* setup an application for your target that calls the\n* startSlave function. This could be either haskell or your\n* targets ffi capable language, if needed.\n\n> void startSlave(false /* verbose */, 5000 /* port */,\n> \"/path/to/storagelocation/on/target\");\n\n* build the iserv-proxy\n\n> iserv $ cabal install -flibrary -fproxy\n* Start your iserv-slave app on your target running on say @10.0.0.1:5000@\n* compiler your sources with -fexternal-interpreter and the proxy\n\n> project $ arch-platform-target-ghc ModuleContainingTH.hs \\\n> -fexternal-interpreter \\\n> -pgmi=$HOME/.cabal/bin/iserv-proxy \\\n> -opti10.0.0.1 -opti5000\n\nShould something not work as expected, provide @-opti-v@ for verbose\nlogging of the @iserv-proxy@."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = []; + dataDir = "."; + dataFiles = []; + extraSrcFiles = []; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + exes = { + "iserv-proxy" = { + depends = [ + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."network" or (errorHandler.buildDepError "network")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + (hsPkgs."libiserv" or (errorHandler.buildDepError "libiserv")) + ]; + buildable = true; + hsSourceDirs = [ "src" ]; + mainPath = [ "Main.hs" ]; + }; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../utils/iserv-proxy; } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/default/ghc927/.plan.nix/iserv.nix b/materialized/ghc-extra-projects/default/ghc927/.plan.nix/iserv.nix new file mode 100644 index 0000000000..5807928dbc --- /dev/null +++ b/materialized/ghc-extra-projects/default/ghc927/.plan.nix/iserv.nix @@ -0,0 +1,54 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "iserv"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "GHC can be provided with a path to the iserv binary with\n@-pgmi=/path/to/iserv-bin@, and will in combination with\n@-fexternal-interpreter@, compile Template Haskell though the\n@iserv-bin@ delegate. This is very similar to how ghcjs has been\ncompiling Template Haskell, by spawning a separate delegate (so\ncalled runner on the javascript vm) and evaluating the splices\nthere.\n\nTo use iserv with cross compilers, please see @libraries/libiserv@\nand @utils/iserv-proxy@."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = []; + dataDir = "."; + dataFiles = []; + extraSrcFiles = []; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + exes = { + "iserv" = { + depends = [ + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + (hsPkgs."libiserv" or (errorHandler.buildDepError "libiserv")) + ] ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + cSources = [ "cbits/iservmain.c" ]; + hsSourceDirs = [ "src" ]; + includeDirs = [ "." ]; + mainPath = [ "Main.hs" ] ++ [ "" ]; + }; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../utils/iserv; } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/default/ghc927/.plan.nix/libiserv.nix b/materialized/ghc-extra-projects/default/ghc927/.plan.nix/libiserv.nix new file mode 100644 index 0000000000..f36b50c89a --- /dev/null +++ b/materialized/ghc-extra-projects/default/ghc927/.plan.nix/libiserv.nix @@ -0,0 +1,58 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { network = false; }; + package = { + specVersion = "1.10"; + identifier = { name = "libiserv"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "Provides shared functionality between iserv and iserv-proxy."; + description = "Provides shared functionality between iserv and iserv-proxy."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = [ "LICENSE" ]; + dataDir = "."; + dataFiles = []; + extraSrcFiles = []; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + "library" = { + depends = ([ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ] ++ (pkgs.lib).optionals (flags.network) [ + (hsPkgs."network" or (errorHandler.buildDepError "network")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + ]) ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + modules = [ + "Lib" + "GHCi/Utils" + ] ++ (pkgs.lib).optionals (flags.network) [ + "Remote/Message" + "Remote/Slave" + ]; + hsSourceDirs = [ "src" ]; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../libraries/libiserv; } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/default/ghc927/.plan.nix/remote-iserv.nix b/materialized/ghc-extra-projects/default/ghc927/.plan.nix/remote-iserv.nix new file mode 100644 index 0000000000..a484db7b90 --- /dev/null +++ b/materialized/ghc-extra-projects/default/ghc927/.plan.nix/remote-iserv.nix @@ -0,0 +1,46 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "remote-iserv"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "Moritz Angermann "; + author = "Moritz Angermann "; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "This is a very simple remote runner for iserv, to be used together\nwith iserv-proxy. The foundamental idea is that this this wrapper\nstarts running libiserv on a given port to which iserv-proxy will\nthen connect."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = []; + dataDir = "."; + dataFiles = []; + extraSrcFiles = []; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + exes = { + "remote-iserv" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."libiserv" or (errorHandler.buildDepError "libiserv")) + ]; + buildable = true; + hsSourceDirs = [ "src" ]; + mainPath = [ "Cli.hs" ]; + }; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../utils/remote-iserv; } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/default/ghc927/cabal-files/network.nix b/materialized/ghc-extra-projects/default/ghc927/cabal-files/network.nix new file mode 100644 index 0000000000..c0cb3c389e --- /dev/null +++ b/materialized/ghc-extra-projects/default/ghc927/cabal-files/network.nix @@ -0,0 +1,64 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "1.8"; + identifier = { name = "network"; version = "2.8.0.1"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "Kazu Yamamoto, Evan Borden"; + author = ""; + homepage = "https://github.com/haskell/network"; + url = ""; + synopsis = "Low-level networking interface"; + description = "This package provides a low-level networking interface.\n\nIn network-2.6 the @Network.URI@ module was split off into its own\npackage, network-uri-2.6. If you're using the @Network.URI@ module\nyou can automatically get it from the right package by adding this\nto your .cabal file:\n\n> library\n> build-depends: network-uri-flag"; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + ] ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + tests = { + "spec" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) + (hsPkgs."network" or (errorHandler.buildDepError "network")) + (hsPkgs."hspec" or (errorHandler.buildDepError "hspec")) + ]; + build-tools = [ + (hsPkgs.buildPackages.hspec-discover.components.exes.hspec-discover or (pkgs.buildPackages.hspec-discover or (errorHandler.buildToolDepError "hspec-discover:hspec-discover"))) + ]; + buildable = true; + }; + "doctest" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."doctest" or (errorHandler.buildDepError "doctest")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/network-2.8.0.1.tar.gz"; + sha256 = "61f55dbfed0f0af721a8ea36079e9309fcc5a1be20783b44ae500d9e4399a846"; + }); + }) // { + package-description-override = "name: network\nversion: 2.8.0.1\nlicense: BSD3\nlicense-file: LICENSE\nmaintainer: Kazu Yamamoto, Evan Borden\nsynopsis: Low-level networking interface\ndescription:\n This package provides a low-level networking interface.\n .\n In network-2.6 the @Network.URI@ module was split off into its own\n package, network-uri-2.6. If you're using the @Network.URI@ module\n you can automatically get it from the right package by adding this\n to your .cabal file:\n .\n > library\n > build-depends: network-uri-flag\ncategory: Network\nbuild-type: Configure\ncabal-version: >=1.8\nextra-tmp-files:\n config.log config.status autom4te.cache network.buildinfo\n include/HsNetworkConfig.h\nextra-source-files:\n README.md CHANGELOG.md\n examples/*.hs tests/*.hs config.guess config.sub install-sh\n configure.ac configure network.buildinfo.in\n include/HsNetworkConfig.h.in include/HsNet.h include/HsNetDef.h\n -- C sources only used on some systems\n cbits/ancilData.c cbits/asyncAccept.c cbits/initWinSock.c\n cbits/winSockErr.c\nhomepage: https://github.com/haskell/network\nbug-reports: https://github.com/haskell/network/issues\ntested-with: GHC == 7.8.4\n , GHC == 7.10.3\n , GHC == 8.0.2\n , GHC == 8.2.2\n , GHC == 8.4.3\n\nlibrary\n exposed-modules:\n Network\n Network.BSD\n Network.Socket\n Network.Socket.ByteString\n Network.Socket.ByteString.Lazy\n Network.Socket.Internal\n other-modules:\n Network.Socket.ByteString.Internal\n Network.Socket.Types\n\n if !os(windows)\n other-modules:\n Network.Socket.ByteString.IOVec\n Network.Socket.ByteString.Lazy.Posix\n Network.Socket.ByteString.MsgHdr\n if os(windows)\n other-modules:\n Network.Socket.ByteString.Lazy.Windows\n\n build-depends:\n base >= 4.7 && < 5,\n bytestring == 0.10.*\n\n if !os(windows)\n build-depends:\n unix >= 2\n\n extensions:\n CPP, DeriveDataTypeable, ForeignFunctionInterface, TypeSynonymInstances\n include-dirs: include\n includes: HsNet.h HsNetDef.h\n install-includes: HsNet.h HsNetDef.h\n c-sources: cbits/HsNet.c\n ghc-options: -Wall -fwarn-tabs\n\ntest-suite spec\n hs-source-dirs: tests\n main-is: Spec.hs\n other-modules:\n Network.Test.Common\n Network.SocketSpec\n Network.Socket.ByteStringSpec\n Network.Socket.ByteString.LazySpec\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded\n -- NB: make sure to versions of hspec and hspec-discover\n -- that work together; easiest way is to constraint\n -- both packages to a small enough version range.\n build-tools: hspec-discover >= 2.6\n build-depends:\n base >= 4.7 && < 5,\n bytestring,\n directory,\n HUnit,\n network,\n hspec >= 2.6\n\ntest-suite doctest\n hs-source-dirs: tests\n main-is: doctests.hs\n type: exitcode-stdio-1.0\n\n build-depends:\n base >= 4.7 && < 5,\n doctest >= 0.10.1\n\n ghc-options: -Wall\n\nsource-repository head\n type: git\n location: git://github.com/haskell/network.git\n"; + } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/default/ghc927/default.nix b/materialized/ghc-extra-projects/default/ghc927/default.nix new file mode 100644 index 0000000000..c820706b7c --- /dev/null +++ b/materialized/ghc-extra-projects/default/ghc927/default.nix @@ -0,0 +1,138 @@ +{ + pkgs = hackage: + { + packages = { + bytestring.revision = (((hackage.bytestring)."0.11.4.0").revisions).default; + exceptions.revision = (((hackage.exceptions)."0.10.4").revisions).default; + directory.revision = (((hackage.directory)."1.3.6.2").revisions).default; + filepath.revision = (((hackage.filepath)."1.4.2.2").revisions).default; + network.revision = import ./cabal-files/network.nix; + mtl.revision = (((hackage.mtl)."2.2.2").revisions).default; + ghc-bignum.revision = (((hackage.ghc-bignum)."1.2").revisions).default; + ghc-prim.revision = (((hackage.ghc-prim)."0.8.0").revisions).default; + ghc-heap.revision = (((hackage.ghc-heap)."9.2.7").revisions).default; + containers.revision = (((hackage.containers)."0.6.5.1").revisions).default; + stm.revision = (((hackage.stm)."2.5.0.2").revisions).default; + base.revision = (((hackage.base)."4.16.4.0").revisions).default; + time.revision = (((hackage.time)."1.11.1.1").revisions).default; + terminfo.revision = (((hackage.terminfo)."0.4.1.5").revisions).default; + deepseq.revision = (((hackage.deepseq)."1.4.6.1").revisions).default; + rts.revision = (((hackage.rts)."1.0.2").revisions).default; + template-haskell.revision = (((hackage.template-haskell)."2.18.0.0").revisions).default; + binary.revision = (((hackage.binary)."0.8.9.0").revisions).default; + process.revision = (((hackage.process)."1.6.16.0").revisions).default; + unix.revision = (((hackage.unix)."2.7.2.2").revisions).default; + transformers.revision = (((hackage.transformers)."0.5.6.2").revisions).default; + array.revision = (((hackage.array)."0.5.4.0").revisions).default; + ghc-boot-th.revision = (((hackage.ghc-boot-th)."9.2.7").revisions).default; + pretty.revision = (((hackage.pretty)."1.1.3.6").revisions).default; + }; + compiler = { + version = "9.2.7"; + nix-name = "ghc927"; + packages = { + "pretty" = "1.1.3.6"; + "array" = "0.5.4.0"; + "mtl" = "2.2.2"; + "bytestring" = "0.11.4.0"; + "filepath" = "1.4.2.2"; + "stm" = "2.5.0.2"; + "terminfo" = "0.4.1.5"; + "ghc-heap" = "9.2.7"; + "ghc-prim" = "0.8.0"; + "ghc-boot-th" = "9.2.7"; + "base" = "4.16.4.0"; + "time" = "1.11.1.1"; + "process" = "1.6.16.0"; + "ghc-bignum" = "1.2"; + "directory" = "1.3.6.2"; + "exceptions" = "0.10.4"; + "rts" = "1.0.2"; + "transformers" = "0.5.6.2"; + "template-haskell" = "2.18.0.0"; + "deepseq" = "1.4.6.1"; + "unix" = "2.7.2.2"; + "binary" = "0.8.9.0"; + "containers" = "0.6.5.1"; + }; + }; + }; + extras = hackage: + { + packages = { + iserv-proxy = ./.plan.nix/iserv-proxy.nix; + ghc = ./.plan.nix/ghc.nix; + Win32 = ./.plan.nix/Win32.nix; + remote-iserv = ./.plan.nix/remote-iserv.nix; + ghci = ./.plan.nix/ghci.nix; + ghc-boot = ./.plan.nix/ghc-boot.nix; + iserv = ./.plan.nix/iserv.nix; + libiserv = ./.plan.nix/libiserv.nix; + hpc = ./.plan.nix/hpc.nix; + }; + }; + modules = [ + ({ lib, ... }: + { + packages = { + "iserv-proxy" = { flags = {}; }; + "ghc" = { + flags = { + "dynamic-system-linker" = lib.mkOverride 900 true; + "stage2" = lib.mkOverride 900 false; + "terminfo" = lib.mkOverride 900 true; + "stage3" = lib.mkOverride 900 false; + "internal-interpreter" = lib.mkOverride 900 false; + "stage1" = lib.mkOverride 900 false; + }; + }; + "Win32" = { flags = {}; }; + "remote-iserv" = { flags = {}; }; + "ghci" = { + flags = { "internal-interpreter" = lib.mkOverride 900 true; }; + }; + "ghc-boot" = { flags = {}; }; + "iserv" = { flags = {}; }; + "libiserv" = { flags = { "network" = lib.mkOverride 900 true; }; }; + "hpc" = { flags = {}; }; + }; + }) + ({ lib, ... }: + { + packages = { + "filepath".components.library.planned = lib.mkOverride 900 true; + "pretty".components.library.planned = lib.mkOverride 900 true; + "bytestring".components.library.planned = lib.mkOverride 900 true; + "remote-iserv".components.exes."remote-iserv".planned = lib.mkOverride 900 true; + "exceptions".components.library.planned = lib.mkOverride 900 true; + "ghc-prim".components.library.planned = lib.mkOverride 900 true; + "array".components.library.planned = lib.mkOverride 900 true; + "binary".components.library.planned = lib.mkOverride 900 true; + "ghc-boot-th".components.library.planned = lib.mkOverride 900 true; + "rts".components.library.planned = lib.mkOverride 900 true; + "unix".components.library.planned = lib.mkOverride 900 true; + "directory".components.library.planned = lib.mkOverride 900 true; + "iserv".components.exes."iserv".planned = lib.mkOverride 900 true; + "time".components.library.planned = lib.mkOverride 900 true; + "network".components.library.planned = lib.mkOverride 900 true; + "ghc".components.library.planned = lib.mkOverride 900 true; + "ghc-bignum".components.library.planned = lib.mkOverride 900 true; + "process".components.library.planned = lib.mkOverride 900 true; + "template-haskell".components.library.planned = lib.mkOverride 900 true; + "stm".components.library.planned = lib.mkOverride 900 true; + "ghci".components.library.planned = lib.mkOverride 900 true; + "ghc-boot".components.library.planned = lib.mkOverride 900 true; + "hpc".components.library.planned = lib.mkOverride 900 true; + "ghc-heap".components.library.planned = lib.mkOverride 900 true; + "mtl".components.library.planned = lib.mkOverride 900 true; + "transformers".components.library.planned = lib.mkOverride 900 true; + "libiserv".components.library.planned = lib.mkOverride 900 true; + "deepseq".components.library.planned = lib.mkOverride 900 true; + "base".components.library.planned = lib.mkOverride 900 true; + "containers".components.library.planned = lib.mkOverride 900 true; + "iserv-proxy".components.exes."iserv-proxy".planned = lib.mkOverride 900 true; + "terminfo".components.library.planned = lib.mkOverride 900 true; + }; + }) + ]; + } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/Win32.nix b/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/Win32.nix new file mode 100644 index 0000000000..fb9671c831 --- /dev/null +++ b/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/Win32.nix @@ -0,0 +1,158 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "2.0"; + identifier = { name = "Win32"; version = "2.12.0.1"; }; + license = "BSD-3-Clause"; + copyright = "Alastair Reid, 1999-2003; shelarcy, 2012-2013; Tamar Christina, 2016-2020"; + maintainer = "Haskell Libraries "; + author = "Alastair Reid, shelarcy, Tamar Christina"; + homepage = "https://github.com/haskell/win32"; + url = ""; + synopsis = "A binding to Windows Win32 API."; + description = "This library contains direct bindings to the Windows Win32 APIs for Haskell."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = [ "LICENSE" ]; + dataDir = "."; + dataFiles = []; + extraSrcFiles = [ + "include/diatemp.h" + "include/dumpBMP.h" + "include/ellipse.h" + "include/errors.h" + "include/Win32Aux.h" + "include/win32debug.h" + "include/alignment.h" + "changelog.md" + ]; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + ] ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unbuildable" or (errorHandler.buildDepError "unbuildable")); + libs = [ + (pkgs."user32" or (errorHandler.sysDepError "user32")) + (pkgs."gdi32" or (errorHandler.sysDepError "gdi32")) + (pkgs."winmm" or (errorHandler.sysDepError "winmm")) + (pkgs."advapi32" or (errorHandler.sysDepError "advapi32")) + (pkgs."shell32" or (errorHandler.sysDepError "shell32")) + (pkgs."shfolder" or (errorHandler.sysDepError "shfolder")) + (pkgs."shlwapi" or (errorHandler.sysDepError "shlwapi")) + (pkgs."msimg32" or (errorHandler.sysDepError "msimg32")) + (pkgs."imm32" or (errorHandler.sysDepError "imm32")) + ]; + build-tools = [ + (hsPkgs.buildPackages.hsc2hs.components.exes.hsc2hs or (pkgs.buildPackages.hsc2hs or (errorHandler.buildToolDepError "hsc2hs:hsc2hs"))) + ]; + buildable = if !system.isWindows then false else true; + modules = [ + "Graphics/Win32/GDI" + "Graphics/Win32/GDI/Bitmap" + "Graphics/Win32/GDI/Brush" + "Graphics/Win32/GDI/Clip" + "Graphics/Win32/GDI/Font" + "Graphics/Win32/GDI/Graphics2D" + "Graphics/Win32/GDI/HDC" + "Graphics/Win32/GDI/Palette" + "Graphics/Win32/GDI/Path" + "Graphics/Win32/GDI/Pen" + "Graphics/Win32/GDI/Region" + "Graphics/Win32/GDI/Types" + "Graphics/Win32" + "Graphics/Win32/Control" + "Graphics/Win32/Dialogue" + "Graphics/Win32/Icon" + "Graphics/Win32/Key" + "Graphics/Win32/Menu" + "Graphics/Win32/Message" + "Graphics/Win32/Misc" + "Graphics/Win32/Resource" + "Graphics/Win32/Window" + "Graphics/Win32/LayeredWindow" + "Graphics/Win32/GDI/AlphaBlend" + "Graphics/Win32/Window/AnimateWindow" + "Graphics/Win32/Window/HotKey" + "Graphics/Win32/Window/IMM" + "Graphics/Win32/Window/ForegroundWindow" + "Graphics/Win32/Window/PostMessage" + "Media/Win32" + "System/Win32" + "System/Win32/DebugApi" + "System/Win32/DLL" + "System/Win32/Event" + "System/Win32/File" + "System/Win32/FileMapping" + "System/Win32/Info" + "System/Win32/Path" + "System/Win32/Mem" + "System/Win32/MinTTY" + "System/Win32/NLS" + "System/Win32/Process" + "System/Win32/Registry" + "System/Win32/SimpleMAPI" + "System/Win32/Time" + "System/Win32/Console" + "System/Win32/Security" + "System/Win32/Types" + "System/Win32/Shell" + "System/Win32/Automation" + "System/Win32/Automation/Input" + "System/Win32/Automation/Input/Key" + "System/Win32/Automation/Input/Mouse" + "System/Win32/Console/CtrlHandler" + "System/Win32/Console/HWND" + "System/Win32/Console/Title" + "System/Win32/Encoding" + "System/Win32/Exception/Unsupported" + "System/Win32/HardLink" + "System/Win32/Info/Computer" + "System/Win32/Info/Version" + "System/Win32/String" + "System/Win32/SymbolicLink" + "System/Win32/Thread" + "System/Win32/Utils" + "System/Win32/Word" + ]; + cSources = [ + "cbits/HsGDI.c" + "cbits/HsWin32.c" + "cbits/WndProc.c" + "cbits/diatemp.c" + "cbits/dumpBMP.c" + "cbits/ellipse.c" + "cbits/errors.c" + "cbits/alphablend.c" + ]; + includeDirs = [ "include" ]; + includes = [ + "alphablend.h" + "diatemp.h" + "dumpBMP.h" + "ellipse.h" + "errors.h" + "HsGDI.h" + "HsWin32.h" + "Win32Aux.h" + "win32debug.h" + "windows_cconv.h" + "WndProc.h" + "alignment.h" + ]; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../libraries/Win32; } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/ghc-boot.nix b/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/ghc-boot.nix new file mode 100644 index 0000000000..d4fff2782c --- /dev/null +++ b/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/ghc-boot.nix @@ -0,0 +1,64 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "ghc-boot"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Shared functionality between GHC and its boot libraries"; + description = "This library is shared between GHC, ghc-pkg, and other boot\nlibraries.\n.\nA note about \"GHC.Unit.Database\": it only deals with the subset of\nthe package database that the compiler cares about: modules\npaths etc and not package metadata like description, authors\netc. It is thus not a library interface to ghc-pkg and is *not*\nsuitable for modifying GHC package databases.\n.\nThe package database format and this library are constructed in\nsuch a way that while ghc-pkg depends on Cabal, the GHC library\nand program do not have to depend on Cabal."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = [ "LICENSE" ]; + dataDir = "."; + dataFiles = []; + extraSrcFiles = [ "changelog.md" ]; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghc-boot-th" or (errorHandler.buildDepError "ghc-boot-th")) + ] ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + modules = [ + "GHC/BaseDir" + "GHC/Data/ShortText" + "GHC/Data/SizedSeq" + "GHC/Utils/Encoding" + "GHC/LanguageExtensions" + "GHC/Unit/Database" + "GHC/Serialized" + "GHC/ForeignSrcLang" + "GHC/HandleEncoding" + "GHC/Platform/ArchOS" + "GHC/Platform/Host" + "GHC/Settings/Utils" + "GHC/UniqueSubdir" + "GHC/Version" + ]; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../libraries/ghc-boot; } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/ghc.nix b/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/ghc.nix new file mode 100644 index 0000000000..071b71777b --- /dev/null +++ b/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/ghc.nix @@ -0,0 +1,662 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { + internal-interpreter = false; + stage1 = false; + stage2 = false; + stage3 = false; + terminfo = true; + dynamic-system-linker = true; + }; + package = { + specVersion = "1.22"; + identifier = { name = "ghc"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "glasgow-haskell-users@haskell.org"; + author = "The GHC Team"; + homepage = "http://www.haskell.org/ghc/"; + url = ""; + synopsis = "The GHC API"; + description = "GHC's functionality can be useful for more things than just\ncompiling Haskell programs. Important use cases are programs\nthat analyse (and perhaps transform) Haskell code. Others\ninclude loading Haskell code dynamically in a GHCi-like manner.\nFor this reason, a lot of GHC's functionality is made available\nthrough this package.\n\nSee \nfor more information."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = [ "LICENSE" ]; + dataDir = "."; + dataFiles = []; + extraSrcFiles = []; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."hpc" or (errorHandler.buildDepError "hpc")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."exceptions" or (errorHandler.buildDepError "exceptions")) + (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot")) + (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ] ++ (if system.isWindows + then [ (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) ] + else [ + (hsPkgs."unix" or (errorHandler.buildDepError "unix")) + ] ++ (pkgs.lib).optional (flags.terminfo) (hsPkgs."terminfo" or (errorHandler.buildDepError "terminfo"))); + buildable = true; + modules = [ + "GHC" + "GHC/Builtin/Names" + "GHC/Builtin/Names/TH" + "GHC/Builtin/PrimOps" + "GHC/Builtin/Types" + "GHC/Builtin/Types/Literals" + "GHC/Builtin/Types/Prim" + "GHC/Builtin/Uniques" + "GHC/Builtin/Utils" + "GHC/ByteCode/Asm" + "GHC/ByteCode/InfoTable" + "GHC/ByteCode/Instr" + "GHC/ByteCode/Linker" + "GHC/ByteCode/Types" + "GHC/Cmm" + "GHC/Cmm/BlockId" + "GHC/Cmm/CallConv" + "GHC/Cmm/CLabel" + "GHC/Cmm/CommonBlockElim" + "GHC/Cmm/ContFlowOpt" + "GHC/Cmm/Dataflow" + "GHC/Cmm/Dataflow/Block" + "GHC/Cmm/Dataflow/Collections" + "GHC/Cmm/Dataflow/Graph" + "GHC/Cmm/Dataflow/Label" + "GHC/Cmm/DebugBlock" + "GHC/Cmm/Expr" + "GHC/Cmm/Graph" + "GHC/Cmm/Info" + "GHC/Cmm/Info/Build" + "GHC/Cmm/LayoutStack" + "GHC/Cmm/Lexer" + "GHC/Cmm/Lint" + "GHC/Cmm/Liveness" + "GHC/Cmm/MachOp" + "GHC/Cmm/Node" + "GHC/Cmm/Opt" + "GHC/Cmm/Parser" + "GHC/Cmm/Parser/Monad" + "GHC/Cmm/Pipeline" + "GHC/Cmm/Ppr" + "GHC/Cmm/Ppr/Decl" + "GHC/Cmm/Ppr/Expr" + "GHC/Cmm/ProcPoint" + "GHC/Cmm/Sink" + "GHC/Cmm/Switch" + "GHC/Cmm/Switch/Implement" + "GHC/CmmToAsm" + "GHC/Cmm/LRegSet" + "GHC/CmmToAsm/AArch64" + "GHC/CmmToAsm/AArch64/CodeGen" + "GHC/CmmToAsm/AArch64/Cond" + "GHC/CmmToAsm/AArch64/Instr" + "GHC/CmmToAsm/AArch64/Ppr" + "GHC/CmmToAsm/AArch64/RegInfo" + "GHC/CmmToAsm/AArch64/Regs" + "GHC/CmmToAsm/BlockLayout" + "GHC/CmmToAsm/CFG" + "GHC/CmmToAsm/CFG/Dominators" + "GHC/CmmToAsm/CFG/Weight" + "GHC/CmmToAsm/Config" + "GHC/CmmToAsm/CPrim" + "GHC/CmmToAsm/Dwarf" + "GHC/CmmToAsm/Dwarf/Constants" + "GHC/CmmToAsm/Dwarf/Types" + "GHC/CmmToAsm/Format" + "GHC/CmmToAsm/Instr" + "GHC/CmmToAsm/Monad" + "GHC/CmmToAsm/PIC" + "GHC/CmmToAsm/PPC" + "GHC/CmmToAsm/PPC/CodeGen" + "GHC/CmmToAsm/PPC/Cond" + "GHC/CmmToAsm/PPC/Instr" + "GHC/CmmToAsm/PPC/Ppr" + "GHC/CmmToAsm/PPC/RegInfo" + "GHC/CmmToAsm/PPC/Regs" + "GHC/CmmToAsm/Ppr" + "GHC/CmmToAsm/Reg/Graph" + "GHC/CmmToAsm/Reg/Graph/Base" + "GHC/CmmToAsm/Reg/Graph/Coalesce" + "GHC/CmmToAsm/Reg/Graph/Spill" + "GHC/CmmToAsm/Reg/Graph/SpillClean" + "GHC/CmmToAsm/Reg/Graph/SpillCost" + "GHC/CmmToAsm/Reg/Graph/Stats" + "GHC/CmmToAsm/Reg/Graph/TrivColorable" + "GHC/CmmToAsm/Reg/Graph/X86" + "GHC/CmmToAsm/Reg/Linear" + "GHC/CmmToAsm/Reg/Linear/AArch64" + "GHC/CmmToAsm/Reg/Linear/Base" + "GHC/CmmToAsm/Reg/Linear/FreeRegs" + "GHC/CmmToAsm/Reg/Linear/JoinToTargets" + "GHC/CmmToAsm/Reg/Linear/PPC" + "GHC/CmmToAsm/Reg/Linear/SPARC" + "GHC/CmmToAsm/Reg/Linear/StackMap" + "GHC/CmmToAsm/Reg/Linear/State" + "GHC/CmmToAsm/Reg/Linear/Stats" + "GHC/CmmToAsm/Reg/Linear/X86" + "GHC/CmmToAsm/Reg/Linear/X86_64" + "GHC/CmmToAsm/Reg/Liveness" + "GHC/CmmToAsm/Reg/Target" + "GHC/CmmToAsm/Reg/Utils" + "GHC/CmmToAsm/SPARC" + "GHC/CmmToAsm/SPARC/AddrMode" + "GHC/CmmToAsm/SPARC/Base" + "GHC/CmmToAsm/SPARC/CodeGen" + "GHC/CmmToAsm/SPARC/CodeGen/Amode" + "GHC/CmmToAsm/SPARC/CodeGen/Base" + "GHC/CmmToAsm/SPARC/CodeGen/CondCode" + "GHC/CmmToAsm/SPARC/CodeGen/Expand" + "GHC/CmmToAsm/SPARC/CodeGen/Gen32" + "GHC/CmmToAsm/SPARC/CodeGen/Gen64" + "GHC/CmmToAsm/SPARC/CodeGen/Sanity" + "GHC/CmmToAsm/SPARC/Cond" + "GHC/CmmToAsm/SPARC/Imm" + "GHC/CmmToAsm/SPARC/Instr" + "GHC/CmmToAsm/SPARC/Ppr" + "GHC/CmmToAsm/SPARC/Regs" + "GHC/CmmToAsm/SPARC/ShortcutJump" + "GHC/CmmToAsm/SPARC/Stack" + "GHC/CmmToAsm/Types" + "GHC/CmmToAsm/Utils" + "GHC/CmmToAsm/X86" + "GHC/CmmToAsm/X86/CodeGen" + "GHC/CmmToAsm/X86/Cond" + "GHC/CmmToAsm/X86/Instr" + "GHC/CmmToAsm/X86/Ppr" + "GHC/CmmToAsm/X86/RegInfo" + "GHC/CmmToAsm/X86/Regs" + "GHC/CmmToC" + "GHC/CmmToLlvm" + "GHC/CmmToLlvm/Base" + "GHC/CmmToLlvm/CodeGen" + "GHC/CmmToLlvm/Data" + "GHC/CmmToLlvm/Mangler" + "GHC/CmmToLlvm/Ppr" + "GHC/CmmToLlvm/Regs" + "GHC/Cmm/Type" + "GHC/Cmm/Utils" + "GHC/Core" + "GHC/Core/Class" + "GHC/Core/Coercion" + "GHC/Core/Coercion/Axiom" + "GHC/Core/Coercion/Opt" + "GHC/Core/ConLike" + "GHC/Core/DataCon" + "GHC/Core/FamInstEnv" + "GHC/Core/FVs" + "GHC/Core/InstEnv" + "GHC/Core/Lint" + "GHC/Core/Make" + "GHC/Core/Map/Expr" + "GHC/Core/Map/Type" + "GHC/Core/Multiplicity" + "GHC/Core/Opt/Arity" + "GHC/Core/Opt/CallArity" + "GHC/Core/Opt/CallerCC" + "GHC/Core/Opt/ConstantFold" + "GHC/Core/Opt/CprAnal" + "GHC/Core/Opt/CSE" + "GHC/Core/Opt/DmdAnal" + "GHC/Core/Opt/Exitify" + "GHC/Core/Opt/FloatIn" + "GHC/Core/Opt/FloatOut" + "GHC/Core/Opt/LiberateCase" + "GHC/Core/Opt/Monad" + "GHC/Core/Opt/OccurAnal" + "GHC/Core/Opt/Pipeline" + "GHC/Core/Opt/SetLevels" + "GHC/Core/Opt/Simplify" + "GHC/Core/Opt/Simplify/Env" + "GHC/Core/Opt/Simplify/Monad" + "GHC/Core/Opt/Simplify/Utils" + "GHC/Core/Opt/SpecConstr" + "GHC/Core/Opt/Specialise" + "GHC/Core/Opt/StaticArgs" + "GHC/Core/Opt/WorkWrap" + "GHC/Core/Opt/WorkWrap/Utils" + "GHC/Core/PatSyn" + "GHC/Core/Ppr" + "GHC/Types/TyThing/Ppr" + "GHC/Core/Predicate" + "GHC/Core/Rules" + "GHC/Core/Seq" + "GHC/Core/SimpleOpt" + "GHC/Core/Stats" + "GHC/Core/Subst" + "GHC/Core/Tidy" + "GHC/CoreToIface" + "GHC/CoreToStg" + "GHC/CoreToStg/Prep" + "GHC/Core/TyCo/FVs" + "GHC/Core/TyCon" + "GHC/Core/TyCon/Env" + "GHC/Core/TyCon/RecWalk" + "GHC/Core/TyCon/Set" + "GHC/Core/TyCo/Ppr" + "GHC/Core/TyCo/Rep" + "GHC/Core/TyCo/Subst" + "GHC/Core/TyCo/Tidy" + "GHC/Core/Type" + "GHC/Core/Unfold" + "GHC/Core/Unfold/Make" + "GHC/Core/Unify" + "GHC/Core/UsageEnv" + "GHC/Core/Utils" + "GHC/Data/Bag" + "GHC/Data/Bitmap" + "GHC/Data/BooleanFormula" + "GHC/Data/EnumSet" + "GHC/Data/FastMutInt" + "GHC/Data/FastString" + "GHC/Data/FastString/Env" + "GHC/Data/FiniteMap" + "GHC/Data/Graph/Base" + "GHC/Data/Graph/Color" + "GHC/Data/Graph/Directed" + "GHC/Data/Graph/Ops" + "GHC/Data/Graph/Ppr" + "GHC/Data/Graph/UnVar" + "GHC/Data/IOEnv" + "GHC/Data/List/SetOps" + "GHC/Data/Maybe" + "GHC/Data/OrdList" + "GHC/Data/Pair" + "GHC/Data/Stream" + "GHC/Data/StringBuffer" + "GHC/Data/TrieMap" + "GHC/Data/UnionFind" + "GHC/Driver/Backend" + "GHC/Driver/Backpack" + "GHC/Driver/Backpack/Syntax" + "GHC/Driver/CmdLine" + "GHC/Driver/CodeOutput" + "GHC/Driver/Config" + "GHC/Driver/Env" + "GHC/Driver/Env/Types" + "GHC/Driver/Errors" + "GHC/Driver/Flags" + "GHC/Driver/Hooks" + "GHC/Driver/Main" + "GHC/Driver/Make" + "GHC/Driver/MakeFile" + "GHC/Driver/Monad" + "GHC/Driver/Phases" + "GHC/Driver/Pipeline" + "GHC/Driver/Pipeline/Monad" + "GHC/Driver/Plugins" + "GHC/Driver/Ppr" + "GHC/Driver/Session" + "GHC/Hs" + "GHC/Hs/Binds" + "GHC/Hs/Decls" + "GHC/Hs/Doc" + "GHC/Hs/Dump" + "GHC/Hs/Expr" + "GHC/Hs/Extension" + "GHC/Hs/ImpExp" + "GHC/Hs/Instances" + "GHC/Hs/Lit" + "GHC/Hs/Pat" + "GHC/Hs/Stats" + "GHC/HsToCore" + "GHC/HsToCore/Arrows" + "GHC/HsToCore/Binds" + "GHC/HsToCore/Coverage" + "GHC/HsToCore/Docs" + "GHC/HsToCore/Expr" + "GHC/HsToCore/Foreign/Call" + "GHC/HsToCore/Foreign/Decl" + "GHC/HsToCore/GuardedRHSs" + "GHC/HsToCore/ListComp" + "GHC/HsToCore/Match" + "GHC/HsToCore/Match/Constructor" + "GHC/HsToCore/Match/Literal" + "GHC/HsToCore/Monad" + "GHC/HsToCore/Pmc" + "GHC/HsToCore/Pmc/Check" + "GHC/HsToCore/Pmc/Desugar" + "GHC/HsToCore/Pmc/Ppr" + "GHC/HsToCore/Pmc/Solver" + "GHC/HsToCore/Pmc/Solver/Types" + "GHC/HsToCore/Pmc/Types" + "GHC/HsToCore/Pmc/Utils" + "GHC/HsToCore/Quote" + "GHC/HsToCore/Types" + "GHC/HsToCore/Usage" + "GHC/HsToCore/Utils" + "GHC/Hs/Type" + "GHC/Hs/Utils" + "GHC/Iface/Binary" + "GHC/Iface/Env" + "GHC/Iface/Ext/Ast" + "GHC/Iface/Ext/Binary" + "GHC/Iface/Ext/Debug" + "GHC/Iface/Ext/Fields" + "GHC/Iface/Ext/Types" + "GHC/Iface/Ext/Utils" + "GHC/Iface/Load" + "GHC/Iface/Make" + "GHC/Iface/Recomp" + "GHC/Iface/Recomp/Binary" + "GHC/Iface/Recomp/Flags" + "GHC/Iface/Rename" + "GHC/Iface/Syntax" + "GHC/Iface/Tidy" + "GHC/Iface/Tidy/StaticPtrTable" + "GHC/IfaceToCore" + "GHC/Iface/Type" + "GHC/Linker" + "GHC/Linker/Dynamic" + "GHC/Linker/ExtraObj" + "GHC/Linker/Loader" + "GHC/Linker/MacOS" + "GHC/Linker/Static" + "GHC/Linker/Types" + "GHC/Linker/Unit" + "GHC/Linker/Windows" + "GHC/Llvm" + "GHC/Llvm/MetaData" + "GHC/Llvm/Ppr" + "GHC/Llvm/Syntax" + "GHC/Llvm/Types" + "GHC/Parser" + "GHC/Parser/Annotation" + "GHC/Parser/CharClass" + "GHC/Parser/Errors" + "GHC/Parser/Errors/Ppr" + "GHC/Parser/Header" + "GHC/Parser/Lexer" + "GHC/Parser/PostProcess" + "GHC/Parser/PostProcess/Haddock" + "GHC/Parser/Types" + "GHC/Parser/Utils" + "GHC/Platform" + "GHC/Platform/ARM" + "GHC/Platform/AArch64" + "GHC/Platform/Constants" + "GHC/Platform/NoRegs" + "GHC/Platform/PPC" + "GHC/Platform/Profile" + "GHC/Platform/Reg" + "GHC/Platform/Reg/Class" + "GHC/Platform/Regs" + "GHC/Platform/RISCV64" + "GHC/Platform/S390X" + "GHC/Platform/SPARC" + "GHC/Platform/Ways" + "GHC/Platform/X86" + "GHC/Platform/X86_64" + "GHC/Plugins" + "GHC/Prelude" + "GHC/Rename/Bind" + "GHC/Rename/Env" + "GHC/Rename/Expr" + "GHC/Rename/Fixity" + "GHC/Rename/HsType" + "GHC/Rename/Module" + "GHC/Rename/Names" + "GHC/Rename/Pat" + "GHC/Rename/Splice" + "GHC/Rename/Unbound" + "GHC/Rename/Utils" + "GHC/Runtime/Context" + "GHC/Runtime/Debugger" + "GHC/Runtime/Eval" + "GHC/Runtime/Eval/Types" + "GHC/Runtime/Heap/Inspect" + "GHC/Runtime/Heap/Layout" + "GHC/Runtime/Interpreter" + "GHC/Runtime/Interpreter/Types" + "GHC/Runtime/Loader" + "GHC/Settings" + "GHC/Settings/Config" + "GHC/Settings/Constants" + "GHC/Settings/IO" + "GHC/Stg/CSE" + "GHC/Stg/Debug" + "GHC/Stg/DepAnal" + "GHC/Stg/FVs" + "GHC/Stg/Lift" + "GHC/Stg/Lift/Analysis" + "GHC/Stg/Lift/Monad" + "GHC/Stg/Lint" + "GHC/Stg/Pipeline" + "GHC/Stg/Stats" + "GHC/Stg/Subst" + "GHC/Stg/Syntax" + "GHC/StgToByteCode" + "GHC/StgToCmm" + "GHC/StgToCmm/ArgRep" + "GHC/StgToCmm/Bind" + "GHC/StgToCmm/CgUtils" + "GHC/StgToCmm/Closure" + "GHC/StgToCmm/DataCon" + "GHC/StgToCmm/Env" + "GHC/StgToCmm/Expr" + "GHC/StgToCmm/ExtCode" + "GHC/StgToCmm/Foreign" + "GHC/StgToCmm/Heap" + "GHC/StgToCmm/Hpc" + "GHC/StgToCmm/Layout" + "GHC/StgToCmm/Lit" + "GHC/StgToCmm/Monad" + "GHC/StgToCmm/Prim" + "GHC/StgToCmm/Prof" + "GHC/StgToCmm/Ticky" + "GHC/StgToCmm/Types" + "GHC/StgToCmm/Utils" + "GHC/Stg/Unarise" + "GHC/SysTools" + "GHC/SysTools/Ar" + "GHC/SysTools/BaseDir" + "GHC/SysTools/Elf" + "GHC/SysTools/Info" + "GHC/SysTools/Process" + "GHC/SysTools/Tasks" + "GHC/SysTools/Terminal" + "GHC/Tc/Deriv" + "GHC/Tc/Deriv/Functor" + "GHC/Tc/Deriv/Generate" + "GHC/Tc/Deriv/Generics" + "GHC/Tc/Deriv/Infer" + "GHC/Tc/Deriv/Utils" + "GHC/Tc/Errors" + "GHC/Tc/Errors/Hole" + "GHC/Tc/Errors/Hole/FitTypes" + "GHC/Tc/Gen/Annotation" + "GHC/Tc/Gen/App" + "GHC/Tc/Gen/Arrow" + "GHC/Tc/Gen/Bind" + "GHC/Tc/Gen/Default" + "GHC/Tc/Gen/Export" + "GHC/Tc/Gen/Expr" + "GHC/Tc/Gen/Foreign" + "GHC/Tc/Gen/Head" + "GHC/Tc/Gen/HsType" + "GHC/Tc/Gen/Match" + "GHC/Tc/Gen/Pat" + "GHC/Tc/Gen/Rule" + "GHC/Tc/Gen/Sig" + "GHC/Tc/Gen/Splice" + "GHC/Tc/Instance/Class" + "GHC/Tc/Instance/Family" + "GHC/Tc/Instance/FunDeps" + "GHC/Tc/Instance/Typeable" + "GHC/Tc/Module" + "GHC/Tc/Plugin" + "GHC/Tc/Solver" + "GHC/Tc/Solver/Canonical" + "GHC/Tc/Solver/Rewrite" + "GHC/Tc/Solver/Interact" + "GHC/Tc/Solver/Monad" + "GHC/Tc/TyCl" + "GHC/Tc/TyCl/Build" + "GHC/Tc/TyCl/Class" + "GHC/Tc/TyCl/Instance" + "GHC/Tc/TyCl/PatSyn" + "GHC/Tc/TyCl/Utils" + "GHC/Tc/Types" + "GHC/Tc/Types/Constraint" + "GHC/Tc/Types/Evidence" + "GHC/Tc/Types/EvTerm" + "GHC/Tc/Types/Origin" + "GHC/Tc/Utils/Backpack" + "GHC/Tc/Utils/Env" + "GHC/Tc/Utils/Instantiate" + "GHC/Tc/Utils/Monad" + "GHC/Tc/Utils/TcMType" + "GHC/Tc/Utils/TcType" + "GHC/Tc/Utils/Unify" + "GHC/Tc/Utils/Zonk" + "GHC/Tc/Validity" + "GHC/ThToHs" + "GHC/Types/Annotations" + "GHC/Types/Avail" + "GHC/Types/Basic" + "GHC/Types/CompleteMatch" + "GHC/Types/CostCentre" + "GHC/Types/CostCentre/State" + "GHC/Types/Cpr" + "GHC/Types/Demand" + "GHC/Types/Error" + "GHC/Types/FieldLabel" + "GHC/Types/Fixity" + "GHC/Types/Fixity/Env" + "GHC/Types/ForeignCall" + "GHC/Types/ForeignStubs" + "GHC/Types/HpcInfo" + "GHC/Types/Id" + "GHC/Types/IPE" + "GHC/Types/Id/Info" + "GHC/Types/Id/Make" + "GHC/Types/Literal" + "GHC/Types/Meta" + "GHC/Types/Name" + "GHC/Types/Name/Cache" + "GHC/Types/Name/Env" + "GHC/Types/Name/Occurrence" + "GHC/Types/Name/Reader" + "GHC/Types/Name/Set" + "GHC/Types/Name/Shape" + "GHC/Types/Name/Ppr" + "GHC/Types/RepType" + "GHC/Types/SafeHaskell" + "GHC/Types/SourceError" + "GHC/Types/SourceFile" + "GHC/Types/SourceText" + "GHC/Types/SrcLoc" + "GHC/Types/Target" + "GHC/Types/Tickish" + "GHC/Types/TypeEnv" + "GHC/Types/TyThing" + "GHC/Types/Unique" + "GHC/Types/Unique/DFM" + "GHC/Types/Unique/DSet" + "GHC/Types/Unique/FM" + "GHC/Types/Unique/Map" + "GHC/Types/Unique/SDFM" + "GHC/Types/Unique/Set" + "GHC/Types/Unique/Supply" + "GHC/Types/Var" + "GHC/Types/Var/Env" + "GHC/Types/Var/Set" + "GHC/Unit" + "GHC/Unit/Env" + "GHC/Unit/External" + "GHC/Unit/Finder" + "GHC/Unit/Finder/Types" + "GHC/Unit/Home" + "GHC/Unit/Home/ModInfo" + "GHC/Unit/Info" + "GHC/Unit/Module" + "GHC/Unit/Module/Deps" + "GHC/Unit/Module/Env" + "GHC/Unit/Module/Graph" + "GHC/Unit/Module/Imported" + "GHC/Unit/Module/Location" + "GHC/Unit/Module/ModDetails" + "GHC/Unit/Module/ModGuts" + "GHC/Unit/Module/ModIface" + "GHC/Unit/Module/ModSummary" + "GHC/Unit/Module/Name" + "GHC/Unit/Module/Status" + "GHC/Unit/Module/Warnings" + "GHC/Unit/Parser" + "GHC/Unit/Ppr" + "GHC/Unit/State" + "GHC/Unit/Types" + "GHC/Utils/Asm" + "GHC/Utils/Binary" + "GHC/Utils/Binary/Typeable" + "GHC/Utils/BufHandle" + "GHC/Utils/CliOption" + "GHC/Utils/Error" + "GHC/Utils/Exception" + "GHC/Utils/Fingerprint" + "GHC/Utils/FV" + "GHC/Utils/GlobalVars" + "GHC/Utils/IO/Unsafe" + "GHC/Utils/Json" + "GHC/Utils/Lexeme" + "GHC/Utils/Logger" + "GHC/Utils/Misc" + "GHC/Utils/Monad" + "GHC/Utils/Monad/State" + "GHC/Utils/Outputable" + "GHC/Utils/Panic" + "GHC/Utils/Panic/Plain" + "GHC/Utils/Ppr" + "GHC/Utils/Ppr/Colour" + "GHC/Utils/TmpFs" + "Language/Haskell/Syntax" + "Language/Haskell/Syntax/Binds" + "Language/Haskell/Syntax/Decls" + "Language/Haskell/Syntax/Expr" + "Language/Haskell/Syntax/Extension" + "Language/Haskell/Syntax/Lit" + "Language/Haskell/Syntax/Pat" + "Language/Haskell/Syntax/Type" + ]; + cSources = [ + "cbits/cutils.c" + "cbits/genSym.c" + "cbits/keepCAFsForGHCi.c" + ]; + hsSourceDirs = [ "." ]; + includeDirs = ([ + "." + ] ++ (pkgs.lib).optional (flags.internal-interpreter) "../rts/dist/build") ++ (if flags.stage1 + then [ "stage1" ] + else if flags.stage2 + then [ "stage2" ] + else (pkgs.lib).optional (flags.stage3) "stage2"); + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../compiler; } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/ghci.nix b/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/ghci.nix new file mode 100644 index 0000000000..e17d0ce030 --- /dev/null +++ b/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/ghci.nix @@ -0,0 +1,70 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { internal-interpreter = false; }; + package = { + specVersion = "1.10"; + identifier = { name = "ghci"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "The library supporting GHC's interactive interpreter"; + description = "This library offers interfaces which mediate interactions between the\n@ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter\nbackend."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = [ "LICENSE" ]; + dataDir = "."; + dataFiles = []; + extraSrcFiles = [ "changelog.md" ]; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + "library" = { + depends = [ + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot")) + (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + ] ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + modules = [ + "GHCi/BreakArray" + "GHCi/BinaryArray" + "GHCi/Message" + "GHCi/ResolvedBCO" + "GHCi/RemoteTypes" + "GHCi/FFI" + "GHCi/TH/Binary" + ] ++ (pkgs.lib).optionals (flags.internal-interpreter) [ + "GHCi/InfoTable" + "GHCi/Run" + "GHCi/CreateBCO" + "GHCi/ObjLink" + "GHCi/Signals" + "GHCi/StaticPtrTable" + "GHCi/TH" + ]; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../libraries/ghci; } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/hpc.nix b/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/hpc.nix new file mode 100644 index 0000000000..260c9b2b88 --- /dev/null +++ b/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/hpc.nix @@ -0,0 +1,52 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "hpc"; version = "0.6.1.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = "Andy Gill"; + homepage = ""; + url = ""; + synopsis = "Code Coverage Library for Haskell"; + description = "This package provides the code coverage library for Haskell.\n\nSee for more\ninformation."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = [ "LICENSE" ]; + dataDir = "."; + dataFiles = []; + extraSrcFiles = [ "changelog.md" ]; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + ]; + buildable = true; + modules = [ + "Trace/Hpc/Util" + "Trace/Hpc/Mix" + "Trace/Hpc/Tix" + "Trace/Hpc/Reflect" + ]; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../libraries/hpc; } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/iserv-proxy.nix b/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/iserv-proxy.nix new file mode 100644 index 0000000000..405c965d5c --- /dev/null +++ b/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/iserv-proxy.nix @@ -0,0 +1,55 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "iserv-proxy"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "GHC can be provided with a path to the iserv binary with\n@-pgmi=/path/to/iserv-bin@, and will in combination with\n@-fexternal-interpreter@, compile Template Haskell though the\n@iserv-bin@ delegate. This is very similar to how ghcjs has been\ncompiling Template Haskell, by spawning a separate delegate (so\ncalled runner on the javascript vm) and evaluating the splices\nthere.\n\niserv can also be used in combination with cross compilation. For\nthis, the @iserv-proxy@ needs to be built on the host, targeting the\nhost (as it is running on the host). @cabal install -flibrary\n-fproxy@ will yield the proxy.\n\nUsing the cabal for the target @arch-platform-target-cabal install\n-flibrary@ will build the required library that contains the ffi\n@startSlave@ function, which needs to be invoked on the target\n(e.g. in an iOS application) to start the remote iserv slave.\n\ncalling the GHC cross compiler with @-fexternal-interpreter\n-pgmi=$HOME/.cabal/bin/iserv-proxy -opti\\ -opti\\@\nwill cause it to compile Template Haskell via the remote at \\.\n\nThus to get cross compilation with Template Haskell follow the\nfollowing receipt:\n\n* compile the iserv library for your target\n\n> iserv $ arch-platform-target-cabal install -flibrary\n\n* setup an application for your target that calls the\n* startSlave function. This could be either haskell or your\n* targets ffi capable language, if needed.\n\n> void startSlave(false /* verbose */, 5000 /* port */,\n> \"/path/to/storagelocation/on/target\");\n\n* build the iserv-proxy\n\n> iserv $ cabal install -flibrary -fproxy\n* Start your iserv-slave app on your target running on say @10.0.0.1:5000@\n* compiler your sources with -fexternal-interpreter and the proxy\n\n> project $ arch-platform-target-ghc ModuleContainingTH.hs \\\n> -fexternal-interpreter \\\n> -pgmi=$HOME/.cabal/bin/iserv-proxy \\\n> -opti10.0.0.1 -opti5000\n\nShould something not work as expected, provide @-opti-v@ for verbose\nlogging of the @iserv-proxy@."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = []; + dataDir = "."; + dataFiles = []; + extraSrcFiles = []; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + exes = { + "iserv-proxy" = { + depends = [ + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."network" or (errorHandler.buildDepError "network")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + (hsPkgs."libiserv" or (errorHandler.buildDepError "libiserv")) + ]; + buildable = true; + hsSourceDirs = [ "src" ]; + mainPath = [ "Main.hs" ]; + }; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../utils/iserv-proxy; } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/iserv.nix b/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/iserv.nix new file mode 100644 index 0000000000..5807928dbc --- /dev/null +++ b/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/iserv.nix @@ -0,0 +1,54 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "iserv"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "GHC can be provided with a path to the iserv binary with\n@-pgmi=/path/to/iserv-bin@, and will in combination with\n@-fexternal-interpreter@, compile Template Haskell though the\n@iserv-bin@ delegate. This is very similar to how ghcjs has been\ncompiling Template Haskell, by spawning a separate delegate (so\ncalled runner on the javascript vm) and evaluating the splices\nthere.\n\nTo use iserv with cross compilers, please see @libraries/libiserv@\nand @utils/iserv-proxy@."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = []; + dataDir = "."; + dataFiles = []; + extraSrcFiles = []; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + exes = { + "iserv" = { + depends = [ + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + (hsPkgs."libiserv" or (errorHandler.buildDepError "libiserv")) + ] ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + cSources = [ "cbits/iservmain.c" ]; + hsSourceDirs = [ "src" ]; + includeDirs = [ "." ]; + mainPath = [ "Main.hs" ] ++ [ "" ]; + }; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../utils/iserv; } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/libiserv.nix b/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/libiserv.nix new file mode 100644 index 0000000000..f36b50c89a --- /dev/null +++ b/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/libiserv.nix @@ -0,0 +1,58 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { network = false; }; + package = { + specVersion = "1.10"; + identifier = { name = "libiserv"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "Provides shared functionality between iserv and iserv-proxy."; + description = "Provides shared functionality between iserv and iserv-proxy."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = [ "LICENSE" ]; + dataDir = "."; + dataFiles = []; + extraSrcFiles = []; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + "library" = { + depends = ([ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ] ++ (pkgs.lib).optionals (flags.network) [ + (hsPkgs."network" or (errorHandler.buildDepError "network")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + ]) ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + modules = [ + "Lib" + "GHCi/Utils" + ] ++ (pkgs.lib).optionals (flags.network) [ + "Remote/Message" + "Remote/Slave" + ]; + hsSourceDirs = [ "src" ]; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../libraries/libiserv; } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/remote-iserv.nix b/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/remote-iserv.nix new file mode 100644 index 0000000000..a484db7b90 --- /dev/null +++ b/materialized/ghc-extra-projects/windows/ghc927/.plan.nix/remote-iserv.nix @@ -0,0 +1,46 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "remote-iserv"; version = "9.2.7"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "Moritz Angermann "; + author = "Moritz Angermann "; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "This is a very simple remote runner for iserv, to be used together\nwith iserv-proxy. The foundamental idea is that this this wrapper\nstarts running libiserv on a given port to which iserv-proxy will\nthen connect."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = []; + dataDir = "."; + dataFiles = []; + extraSrcFiles = []; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + exes = { + "remote-iserv" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."libiserv" or (errorHandler.buildDepError "libiserv")) + ]; + buildable = true; + hsSourceDirs = [ "src" ]; + mainPath = [ "Cli.hs" ]; + }; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../utils/remote-iserv; } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/windows/ghc927/cabal-files/Win32.nix b/materialized/ghc-extra-projects/windows/ghc927/cabal-files/Win32.nix new file mode 100644 index 0000000000..f604418035 --- /dev/null +++ b/materialized/ghc-extra-projects/windows/ghc927/cabal-files/Win32.nix @@ -0,0 +1,53 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "Win32"; version = "2.8.3.0"; }; + license = "BSD-3-Clause"; + copyright = "Alastair Reid, 1999-2003; shelarcy, 2012-2013; Tamar Christina, 2016-2018"; + maintainer = "Haskell Libraries "; + author = "Alastair Reid, shelarcy, Tamar Christina"; + homepage = "https://github.com/haskell/win32"; + url = ""; + synopsis = "A binding to Windows Win32 API."; + description = "This library contains direct bindings to the Windows Win32 APIs for Haskell."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + ] ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unbuildable" or (errorHandler.buildDepError "unbuildable")); + libs = [ + (pkgs."user32" or (errorHandler.sysDepError "user32")) + (pkgs."gdi32" or (errorHandler.sysDepError "gdi32")) + (pkgs."winmm" or (errorHandler.sysDepError "winmm")) + (pkgs."advapi32" or (errorHandler.sysDepError "advapi32")) + (pkgs."shell32" or (errorHandler.sysDepError "shell32")) + (pkgs."shfolder" or (errorHandler.sysDepError "shfolder")) + (pkgs."shlwapi" or (errorHandler.sysDepError "shlwapi")) + (pkgs."msimg32" or (errorHandler.sysDepError "msimg32")) + (pkgs."imm32" or (errorHandler.sysDepError "imm32")) + ]; + buildable = if !system.isWindows then false else true; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/Win32-2.8.3.0.tar.gz"; + sha256 = "593fbbfef98546a224e4652aa0423b0374da8c109cd4e48f16e16b17c21f5c63"; + }); + }) // { + package-description-override = "name:\t\tWin32\nversion:\t2.8.3.0\nlicense:\tBSD3\nlicense-file:\tLICENSE\nauthor:\t\tAlastair Reid, shelarcy, Tamar Christina\ncopyright:\tAlastair Reid, 1999-2003; shelarcy, 2012-2013; Tamar Christina, 2016-2018\nmaintainer:\tHaskell Libraries \nbug-reports: https://github.com/haskell/win32/issues\nhomepage: https://github.com/haskell/win32\ncategory:\tSystem, Graphics\nsynopsis:\tA binding to Windows Win32 API.\ndescription:\tThis library contains direct bindings to the Windows Win32 APIs for Haskell.\nbuild-type: Simple\ncabal-version: >=1.10\nextra-source-files:\n include/diatemp.h include/dumpBMP.h include/ellipse.h include/errors.h\n include/Win32Aux.h include/win32debug.h include/alignment.h\n changelog.md\n\nLibrary\n default-language: Haskell2010\n default-extensions: ForeignFunctionInterface, CPP\n if impl(ghc >= 7.1)\n default-extensions: NondecreasingIndentation\n\n if !os(windows)\n -- This package requires Windows to build\n build-depends: unbuildable<0\n buildable: False\n\n build-depends:\tbase >= 4.5 && < 5, bytestring, filepath\n ghc-options: -Wall -fno-warn-name-shadowing\n cc-options: -fno-strict-aliasing\n exposed-modules:\n Graphics.Win32.GDI\n Graphics.Win32.GDI.Bitmap\n Graphics.Win32.GDI.Brush\n Graphics.Win32.GDI.Clip\n Graphics.Win32.GDI.Font\n Graphics.Win32.GDI.Graphics2D\n Graphics.Win32.GDI.HDC\n Graphics.Win32.GDI.Palette\n Graphics.Win32.GDI.Path\n Graphics.Win32.GDI.Pen\n Graphics.Win32.GDI.Region\n Graphics.Win32.GDI.Types\n Graphics.Win32\n Graphics.Win32.Control\n Graphics.Win32.Dialogue\n Graphics.Win32.Icon\n Graphics.Win32.Key\n Graphics.Win32.Menu\n Graphics.Win32.Message\n Graphics.Win32.Misc\n Graphics.Win32.Resource\n Graphics.Win32.Window\n Graphics.Win32.LayeredWindow\n Graphics.Win32.GDI.AlphaBlend\n Graphics.Win32.Window.AnimateWindow\n Graphics.Win32.Window.HotKey\n Graphics.Win32.Window.IMM\n Graphics.Win32.Window.ForegroundWindow\n Graphics.Win32.Window.PostMessage\n\n Media.Win32\n\n System.Win32\n System.Win32.DebugApi\n System.Win32.DLL\n System.Win32.File\n System.Win32.FileMapping\n System.Win32.Info\n System.Win32.Path\n System.Win32.Mem\n System.Win32.MinTTY\n System.Win32.NLS\n System.Win32.Process\n System.Win32.Registry\n System.Win32.SimpleMAPI\n System.Win32.Time\n System.Win32.Console\n System.Win32.Security\n System.Win32.Types\n System.Win32.Shell\n System.Win32.Automation\n System.Win32.Automation.Input\n System.Win32.Automation.Input.Key\n System.Win32.Automation.Input.Mouse\n System.Win32.Console.CtrlHandler\n System.Win32.Console.HWND\n System.Win32.Console.Title\n System.Win32.Encoding\n System.Win32.Exception.Unsupported\n System.Win32.HardLink\n System.Win32.Info.Computer\n System.Win32.Info.Version\n System.Win32.String\n System.Win32.SymbolicLink\n System.Win32.Thread\n System.Win32.Utils\n System.Win32.Word\n\n extra-libraries:\n \"user32\", \"gdi32\", \"winmm\", \"advapi32\", \"shell32\", \"shfolder\", \"shlwapi\", \"msimg32\", \"imm32\"\n ghc-options: -Wall\n include-dirs: include\n includes: \"alphablend.h\", \"diatemp.h\", \"dumpBMP.h\", \"ellipse.h\", \"errors.h\", \"HsGDI.h\", \"HsWin32.h\", \"Win32Aux.h\", \"win32debug.h\", \"windows_cconv.h\", \"WndProc.h\", \"alignment.h\"\n install-includes: \"HsWin32.h\", \"HsGDI.h\", \"WndProc.h\", \"windows_cconv.h\", \"alphablend.h\", \"winternl_compat.h\", \"winuser_compat.h\", \"winreg_compat.h\", \"tlhelp32_compat.h\"\n c-sources:\n cbits/HsGDI.c\n cbits/HsWin32.c\n cbits/WndProc.c\n cbits/diatemp.c\n cbits/dumpBMP.c\n cbits/ellipse.c\n cbits/errors.c\n cbits/alphablend.c\n cc-options: -Wall\n\nsource-repository head\n type: git\n location: git://github.com/haskell/win32\n"; + } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/windows/ghc927/cabal-files/directory.nix b/materialized/ghc-extra-projects/windows/ghc927/cabal-files/directory.nix new file mode 100644 index 0000000000..24048a60ca --- /dev/null +++ b/materialized/ghc-extra-projects/windows/ghc927/cabal-files/directory.nix @@ -0,0 +1,57 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "directory"; version = "1.3.7.1"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Platform-agnostic library for filesystem operations"; + description = "This library provides a basic set of operations for manipulating files and\ndirectories in a portable way."; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + ] ++ (if system.isWindows + then [ (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) ] + else [ (hsPkgs."unix" or (errorHandler.buildDepError "unix")) ]); + buildable = true; + }; + tests = { + "test" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + ] ++ (if system.isWindows + then [ (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) ] + else [ (hsPkgs."unix" or (errorHandler.buildDepError "unix")) ]); + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/directory-1.3.7.1.tar.gz"; + sha256 = "dc2785d6548cec2e80700fab007d3e9467f65d3c58ab3efa21b34d9017cf0efd"; + }); + }) // { + package-description-override = "name: directory\nversion: 1.3.7.1\nlicense: BSD3\nlicense-file: LICENSE\nmaintainer: libraries@haskell.org\nbug-reports: https://github.com/haskell/directory/issues\nsynopsis: Platform-agnostic library for filesystem operations\ndescription:\n This library provides a basic set of operations for manipulating files and\n directories in a portable way.\ncategory: System\nbuild-type: Configure\ncabal-version: >= 1.10\ntested-with: GHC>=7.4.1\n\nextra-tmp-files:\n autom4te.cache\n config.log\n config.status\n HsDirectoryConfig.h\n\nextra-source-files:\n HsDirectoryConfig.h.in\n README.md\n System/Directory/Internal/*.h\n changelog.md\n configure\n configure.ac\n directory.buildinfo\n tests/*.hs\n tests/util.inl\n\nsource-repository head\n type: git\n location: https://github.com/haskell/directory\n\nLibrary\n default-language: Haskell2010\n other-extensions:\n CPP\n Trustworthy\n\n exposed-modules:\n System.Directory\n System.Directory.Internal\n System.Directory.Internal.Prelude\n other-modules:\n System.Directory.Internal.C_utimensat\n System.Directory.Internal.Common\n System.Directory.Internal.Config\n System.Directory.Internal.Posix\n System.Directory.Internal.Windows\n\n include-dirs: .\n\n build-depends:\n base >= 4.5 && < 4.18,\n time >= 1.4 && < 1.13,\n filepath >= 1.3 && < 1.5\n if os(windows)\n build-depends: Win32 >= 2.2.2 && < 2.14\n else\n build-depends: unix >= 2.5.1 && < 2.9\n\n ghc-options: -Wall\n\ntest-suite test\n default-language: Haskell2010\n other-extensions: BangPatterns, CPP, Safe\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: Main.hs\n type: exitcode-stdio-1.0\n build-depends: base, directory, filepath, time\n if os(windows)\n build-depends: Win32\n else\n build-depends: unix\n other-modules:\n TestUtils\n Util\n -- test-modules-begin\n CanonicalizePath\n CopyFile001\n CopyFile002\n CopyFileWithMetadata\n CreateDirectory001\n CreateDirectoryIfMissing001\n CurrentDirectory001\n Directory001\n DoesDirectoryExist001\n DoesPathExist\n FileTime\n FindFile001\n GetDirContents001\n GetDirContents002\n GetFileSize\n GetHomeDirectory001\n GetHomeDirectory002\n GetPermissions001\n LongPaths\n MakeAbsolute\n MinimizeNameConflicts\n PathIsSymbolicLink\n RemoveDirectoryRecursive001\n RemovePathForcibly\n RenameDirectory\n RenameFile001\n RenamePath\n Safe\n Simplify\n T8482\n WithCurrentDirectory\n Xdg\n -- test-modules-end\n"; + } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/windows/ghc927/cabal-files/hsc2hs.nix b/materialized/ghc-extra-projects/windows/ghc927/cabal-files/hsc2hs.nix new file mode 100644 index 0000000000..71e6e92488 --- /dev/null +++ b/materialized/ghc-extra-projects/windows/ghc927/cabal-files/hsc2hs.nix @@ -0,0 +1,57 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = { in-ghc-tree = false; }; + package = { + specVersion = "1.10"; + identifier = { name = "hsc2hs"; version = "0.68.8"; }; + license = "BSD-3-Clause"; + copyright = "2000, Marcin Kowalczyk"; + maintainer = "ghc-devs@haskell.org"; + author = "Marcin Kowalczyk "; + homepage = ""; + url = ""; + synopsis = "A preprocessor that helps with writing Haskell bindings to C code"; + description = "The hsc2hs program can be used to automate some parts of the\nprocess of writing Haskell bindings to C code. It reads an\nalmost-Haskell source file with embedded special constructs, and\noutputs a real Haskell file with these constructs processed, based\non information taken from some C headers. The extra constructs\nprovide Haskell counterparts of C types, values of C constants,\nincluding sizes of C types, and access to fields of C structs.\n\nFor more details, see the\n\nin the GHC User's Guide."; + buildType = "Simple"; + }; + components = { + exes = { + "hsc2hs" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + ] ++ (pkgs.lib).optional (system.isWindows) (hsPkgs."process" or (errorHandler.buildDepError "process")); + buildable = true; + }; + }; + tests = { + "spec" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."test-framework" or (errorHandler.buildDepError "test-framework")) + (hsPkgs."test-framework-hunit" or (errorHandler.buildDepError "test-framework-hunit")) + (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/hsc2hs-0.68.8.tar.gz"; + sha256 = "78341efbc917a84a07f2143bee9203e2555072054d495717aa73d89d9df77a52"; + }); + }) // { + package-description-override = "cabal-version: >=1.10\r\nName: hsc2hs\r\nVersion: 0.68.8\r\nx-revision: 1\r\n\r\nCopyright: 2000, Marcin Kowalczyk\r\nLicense: BSD3\r\nLicense-File: LICENSE\r\nAuthor: Marcin Kowalczyk \r\nMaintainer: ghc-devs@haskell.org\r\nSynopsis: A preprocessor that helps with writing Haskell bindings to C code\r\nBug-Reports: https://github.com/haskell/hsc2hs/issues\r\nDescription:\r\n The hsc2hs program can be used to automate some parts of the\r\n process of writing Haskell bindings to C code. It reads an\r\n almost-Haskell source file with embedded special constructs, and\r\n outputs a real Haskell file with these constructs processed, based\r\n on information taken from some C headers. The extra constructs\r\n provide Haskell counterparts of C types, values of C constants,\r\n including sizes of C types, and access to fields of C structs.\r\n .\r\n For more details, see the\r\n \r\n in the GHC User's Guide.\r\nCategory: Development\r\nData-Dir: data/\r\nData-Files: template-hsc.h\r\nbuild-type: Simple\r\ntested-with: GHC==8.10.1, GHC==8.8.3, GHC==8.6.5, GHC==8.4.4, GHC==8.2.2, GHC==8.0.2, GHC==7.10.3, GHC==7.8.4, GHC==7.6.3, GHC==7.4.2, GHC==7.2.2, GHC==7.0.4\r\n\r\nextra-source-files:\r\n changelog.md\r\n test/asm/*.s\r\n\r\nflag in-ghc-tree\r\n description: Are we in a GHC tree?\r\n default: False\r\n manual: True\r\n\r\nsource-repository head\r\n Type: git\r\n Location: https://github.com/haskell/hsc2hs.git\r\n\r\nExecutable hsc2hs\r\n Default-Language: Haskell2010\r\n Main-Is: Main.hs\r\n Hs-Source-Dirs: src/\r\n Other-Modules:\r\n C\r\n Common\r\n CrossCodegen\r\n DirectCodegen\r\n Flags\r\n HSCParser\r\n ATTParser\r\n UtilsCodegen\r\n Compat.ResponseFile\r\n Compat.TempFile\r\n Paths_hsc2hs\r\n\r\n c-sources:\r\n cbits/utils.c\r\n\r\n Other-Extensions: CPP, NoMonomorphismRestriction\r\n\r\n Build-Depends: base >= 4.3.0 && < 4.18,\r\n containers >= 0.4.0 && < 0.7,\r\n directory >= 1.1.0 && < 1.4,\r\n filepath >= 1.2.0 && < 1.5,\r\n process >= 1.1.0 && < 1.7\r\n\r\n if os(windows)\r\n -- N.B. Job object support was irreparably broken prior to 1.6.8.\r\n -- See https://github.com/haskell/process/issues/167.\r\n Build-Depends: process >= 1.6.8 && < 1.7\r\n\r\n ghc-options: -Wall\r\n if flag(in-ghc-tree)\r\n cpp-options: -DIN_GHC_TREE\r\n\r\ntest-suite spec\r\n main-is: Spec.hs\r\n hs-source-dirs: src/ test/\r\n other-modules: ATTParser Flags BDD\r\n ghc-options: -Wall -threaded\r\n type: exitcode-stdio-1.0\r\n build-depends: base,\r\n test-framework >=0.8.2.0 && <0.9,\r\n test-framework-hunit >=0.3.0.2 && <0.4,\r\n HUnit >=1.3.1.2 && <1.4 || >=1.6.0.0 && <1.7\r\n\r\n default-language: Haskell2010\r\n"; + } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/windows/ghc927/cabal-files/network.nix b/materialized/ghc-extra-projects/windows/ghc927/cabal-files/network.nix new file mode 100644 index 0000000000..c0cb3c389e --- /dev/null +++ b/materialized/ghc-extra-projects/windows/ghc927/cabal-files/network.nix @@ -0,0 +1,64 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "1.8"; + identifier = { name = "network"; version = "2.8.0.1"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "Kazu Yamamoto, Evan Borden"; + author = ""; + homepage = "https://github.com/haskell/network"; + url = ""; + synopsis = "Low-level networking interface"; + description = "This package provides a low-level networking interface.\n\nIn network-2.6 the @Network.URI@ module was split off into its own\npackage, network-uri-2.6. If you're using the @Network.URI@ module\nyou can automatically get it from the right package by adding this\nto your .cabal file:\n\n> library\n> build-depends: network-uri-flag"; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + ] ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + tests = { + "spec" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) + (hsPkgs."network" or (errorHandler.buildDepError "network")) + (hsPkgs."hspec" or (errorHandler.buildDepError "hspec")) + ]; + build-tools = [ + (hsPkgs.buildPackages.hspec-discover.components.exes.hspec-discover or (pkgs.buildPackages.hspec-discover or (errorHandler.buildToolDepError "hspec-discover:hspec-discover"))) + ]; + buildable = true; + }; + "doctest" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."doctest" or (errorHandler.buildDepError "doctest")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/network-2.8.0.1.tar.gz"; + sha256 = "61f55dbfed0f0af721a8ea36079e9309fcc5a1be20783b44ae500d9e4399a846"; + }); + }) // { + package-description-override = "name: network\nversion: 2.8.0.1\nlicense: BSD3\nlicense-file: LICENSE\nmaintainer: Kazu Yamamoto, Evan Borden\nsynopsis: Low-level networking interface\ndescription:\n This package provides a low-level networking interface.\n .\n In network-2.6 the @Network.URI@ module was split off into its own\n package, network-uri-2.6. If you're using the @Network.URI@ module\n you can automatically get it from the right package by adding this\n to your .cabal file:\n .\n > library\n > build-depends: network-uri-flag\ncategory: Network\nbuild-type: Configure\ncabal-version: >=1.8\nextra-tmp-files:\n config.log config.status autom4te.cache network.buildinfo\n include/HsNetworkConfig.h\nextra-source-files:\n README.md CHANGELOG.md\n examples/*.hs tests/*.hs config.guess config.sub install-sh\n configure.ac configure network.buildinfo.in\n include/HsNetworkConfig.h.in include/HsNet.h include/HsNetDef.h\n -- C sources only used on some systems\n cbits/ancilData.c cbits/asyncAccept.c cbits/initWinSock.c\n cbits/winSockErr.c\nhomepage: https://github.com/haskell/network\nbug-reports: https://github.com/haskell/network/issues\ntested-with: GHC == 7.8.4\n , GHC == 7.10.3\n , GHC == 8.0.2\n , GHC == 8.2.2\n , GHC == 8.4.3\n\nlibrary\n exposed-modules:\n Network\n Network.BSD\n Network.Socket\n Network.Socket.ByteString\n Network.Socket.ByteString.Lazy\n Network.Socket.Internal\n other-modules:\n Network.Socket.ByteString.Internal\n Network.Socket.Types\n\n if !os(windows)\n other-modules:\n Network.Socket.ByteString.IOVec\n Network.Socket.ByteString.Lazy.Posix\n Network.Socket.ByteString.MsgHdr\n if os(windows)\n other-modules:\n Network.Socket.ByteString.Lazy.Windows\n\n build-depends:\n base >= 4.7 && < 5,\n bytestring == 0.10.*\n\n if !os(windows)\n build-depends:\n unix >= 2\n\n extensions:\n CPP, DeriveDataTypeable, ForeignFunctionInterface, TypeSynonymInstances\n include-dirs: include\n includes: HsNet.h HsNetDef.h\n install-includes: HsNet.h HsNetDef.h\n c-sources: cbits/HsNet.c\n ghc-options: -Wall -fwarn-tabs\n\ntest-suite spec\n hs-source-dirs: tests\n main-is: Spec.hs\n other-modules:\n Network.Test.Common\n Network.SocketSpec\n Network.Socket.ByteStringSpec\n Network.Socket.ByteString.LazySpec\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded\n -- NB: make sure to versions of hspec and hspec-discover\n -- that work together; easiest way is to constraint\n -- both packages to a small enough version range.\n build-tools: hspec-discover >= 2.6\n build-depends:\n base >= 4.7 && < 5,\n bytestring,\n directory,\n HUnit,\n network,\n hspec >= 2.6\n\ntest-suite doctest\n hs-source-dirs: tests\n main-is: doctests.hs\n type: exitcode-stdio-1.0\n\n build-depends:\n base >= 4.7 && < 5,\n doctest >= 0.10.1\n\n ghc-options: -Wall\n\nsource-repository head\n type: git\n location: git://github.com/haskell/network.git\n"; + } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/windows/ghc927/cabal-files/process.nix b/materialized/ghc-extra-projects/windows/ghc927/cabal-files/process.nix new file mode 100644 index 0000000000..16bb8b37b1 --- /dev/null +++ b/materialized/ghc-extra-projects/windows/ghc927/cabal-files/process.nix @@ -0,0 +1,61 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "process"; version = "1.6.16.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Process libraries"; + description = "This package contains libraries for dealing with system processes.\n\nThe typed-process package is a more recent take on a process API,\nwhich uses this package internally. It features better binary\nsupport, easier concurrency, and a more composable API. You can\nread more about it at\n."; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + ] ++ (if system.isWindows + then [ (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) ] + else [ (hsPkgs."unix" or (errorHandler.buildDepError "unix")) ]); + libs = (pkgs.lib).optionals (system.isWindows) [ + (pkgs."kernel32" or (errorHandler.sysDepError "kernel32")) + (pkgs."ole32" or (errorHandler.sysDepError "ole32")) + (pkgs."rpcrt4" or (errorHandler.sysDepError "rpcrt4")) + ]; + buildable = true; + }; + tests = { + "test" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/process-1.6.16.0.tar.gz"; + sha256 = "bbc21380d1271aa0dd57934f0b7a4f790f3f6cd12a27eed3eefcd46677ca9328"; + }); + }) // { + package-description-override = "name: process\nversion: 1.6.16.0\n-- NOTE: Don't forget to update ./changelog.md\nlicense: BSD3\nlicense-file: LICENSE\nmaintainer: libraries@haskell.org\nbug-reports: https://github.com/haskell/process/issues\nsynopsis: Process libraries\ncategory: System\nbuild-type: Configure\ncabal-version: >=1.10\ndescription:\n This package contains libraries for dealing with system processes.\n .\n The typed-process package is a more recent take on a process API,\n which uses this package internally. It features better binary\n support, easier concurrency, and a more composable API. You can\n read more about it at\n .\n\nextra-source-files:\n aclocal.m4\n changelog.md\n configure\n configure.ac\n include/HsProcessConfig.h.in\n process.buildinfo\n exes/echo.bat\n exes/subdir/echo.bat\n cbits/posix/common.h\n\nextra-tmp-files:\n autom4te.cache\n config.log\n config.status\n include/HsProcessConfig.h\n\nsource-repository head\n type: git\n location: https://github.com/haskell/process.git\n\nlibrary\n default-language: Haskell2010\n other-extensions:\n BangPatterns\n CPP\n InterruptibleFFI\n RecordWildCards\n Trustworthy\n Safe\n\n exposed-modules:\n System.Cmd\n System.Process\n System.Process.Internals\n other-modules: System.Process.Common\n if os(windows)\n c-sources:\n cbits/win32/runProcess.c\n other-modules: System.Process.Windows\n build-depends: Win32 >=2.4 && < 2.14\n -- ole32 and rpcrt4 are needed to create GUIDs for unique named pipes\n -- for process.\n extra-libraries: kernel32, ole32, rpcrt4\n cpp-options: -DWINDOWS\n else\n c-sources:\n cbits/posix/runProcess.c\n cbits/posix/fork_exec.c\n cbits/posix/posix_spawn.c\n cbits/posix/find_executable.c\n other-modules: System.Process.Posix\n build-depends: unix >= 2.5 && < 2.9\n\n include-dirs: include\n includes:\n runProcess.h\n install-includes:\n runProcess.h\n processFlags.h\n\n ghc-options: -Wall\n\n build-depends: base >= 4.10 && < 4.18,\n directory >= 1.1 && < 1.4,\n filepath >= 1.2 && < 1.5,\n deepseq >= 1.1 && < 1.5\n\ntest-suite test\n default-language: Haskell2010\n hs-source-dirs: test\n main-is: main.hs\n type: exitcode-stdio-1.0\n -- Add otherwise redundant bounds on base since GHC's build system runs\n -- `cabal check`, which mandates bounds on base.\n build-depends: base >= 4 && < 5\n , bytestring\n , directory\n , process\n ghc-options: -threaded\n -with-rtsopts \"-N\"\n if os(windows)\n cpp-options: -DWINDOWS\n"; + } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/windows/ghc927/cabal-files/time.nix b/materialized/ghc-extra-projects/windows/ghc927/cabal-files/time.nix new file mode 100644 index 0000000000..7d118cfbf0 --- /dev/null +++ b/materialized/ghc-extra-projects/windows/ghc927/cabal-files/time.nix @@ -0,0 +1,94 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "time"; version = "1.12.2"; }; + license = "BSD-2-Clause"; + copyright = ""; + maintainer = ""; + author = "Ashley Yakeley"; + homepage = "https://github.com/haskell/time"; + url = ""; + synopsis = "A time library"; + description = "Time, clocks and calendars"; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + ] ++ (pkgs.lib).optional (system.isWindows) (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")); + buildable = true; + }; + tests = { + "ShowDefaultTZAbbreviations" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + ]; + buildable = true; + }; + "ShowTime" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + ]; + buildable = true; + }; + "test-main" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + ]; + buildable = true; + }; + "test-unix" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + ]; + buildable = if system.isWindows then false else true; + }; + }; + benchmarks = { + "time-bench" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."criterion" or (errorHandler.buildDepError "criterion")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/time-1.12.2.tar.gz"; + sha256 = "dba0b047a230e823ce08007b4a6c2cd0a1e9e899c148b72019511c0b71ebaf1e"; + }); + }) // { + package-description-override = "cabal-version: 3.0\nname: time\nversion: 1.12.2\nstability: stable\nlicense: BSD-2-Clause\nlicense-file: LICENSE\nauthor: Ashley Yakeley\nmaintainer: \nhomepage: https://github.com/haskell/time\nbug-reports: https://github.com/haskell/time/issues\nsynopsis: A time library\ndescription: Time, clocks and calendars\ncategory: Time\nbuild-type: Configure\ntested-with:\n GHC == 8.10.7,\n GHC == 9.0.2,\n GHC == 9.2.2\nx-follows-version-policy:\n\nextra-source-files:\n changelog.md\n aclocal.m4\n configure.ac\n configure\n lib/include/HsTime.h\n lib/include/HsTimeConfig.h.in\n test/unix/Test/Format/*.c\n test/unix/Test/Format/*.h\nextra-tmp-files:\n config.log\n config.status\n autom4te.cache\n lib/include/HsTimeConfig.h\n\nsource-repository head\n type: git\n location: https://github.com/haskell/time\n\nlibrary\n hs-source-dirs: lib\n default-language: Haskell2010\n default-extensions:\n Rank2Types\n DeriveDataTypeable\n StandaloneDeriving\n PatternSynonyms\n ViewPatterns\n ghc-options: -Wall -fwarn-tabs\n c-sources: lib/cbits/HsTime.c\n build-depends:\n base >= 4.14 && < 5,\n deepseq >= 1.1\n if os(windows)\n build-depends: Win32\n exposed-modules:\n Data.Time.Calendar,\n Data.Time.Calendar.MonthDay,\n Data.Time.Calendar.OrdinalDate,\n Data.Time.Calendar.WeekDate,\n Data.Time.Calendar.Julian,\n Data.Time.Calendar.Easter,\n Data.Time.Calendar.Month,\n Data.Time.Calendar.Quarter,\n Data.Time.Clock,\n Data.Time.Clock.System,\n Data.Time.Clock.POSIX,\n Data.Time.Clock.TAI,\n Data.Time.LocalTime,\n Data.Time.Format,\n Data.Time.Format.Internal,\n Data.Time.Format.ISO8601,\n Data.Time\n other-modules:\n Data.Format,\n Data.Time.Calendar.CalendarDiffDays,\n Data.Time.Calendar.Days,\n Data.Time.Calendar.Gregorian,\n Data.Time.Calendar.JulianYearDay,\n Data.Time.Calendar.Private,\n Data.Time.Calendar.Types,\n Data.Time.Calendar.Week,\n Data.Time.Clock.Internal.DiffTime,\n Data.Time.Clock.Internal.AbsoluteTime,\n Data.Time.Clock.Internal.NominalDiffTime,\n Data.Time.Clock.Internal.POSIXTime,\n Data.Time.Clock.Internal.UniversalTime,\n Data.Time.Clock.Internal.SystemTime,\n Data.Time.Clock.Internal.UTCTime,\n Data.Time.Clock.Internal.CTimeval,\n Data.Time.Clock.Internal.CTimespec,\n Data.Time.Clock.Internal.UTCDiff,\n Data.Time.LocalTime.Internal.TimeZone,\n Data.Time.LocalTime.Internal.TimeOfDay,\n Data.Time.LocalTime.Internal.CalendarDiffTime,\n Data.Time.LocalTime.Internal.LocalTime,\n Data.Time.LocalTime.Internal.ZonedTime,\n Data.Time.Format.Parse,\n Data.Time.Format.Locale,\n Data.Time.Format.Format.Class,\n Data.Time.Format.Format.Instances,\n Data.Time.Format.Parse.Class,\n Data.Time.Format.Parse.Instances\n include-dirs: lib/include\n if os(windows)\n install-includes:\n HsTime.h\n else\n autogen-includes:\n HsTimeConfig.h\n install-includes:\n HsTime.h\n HsTimeConfig.h\n\ntest-suite ShowDefaultTZAbbreviations\n type: exitcode-stdio-1.0\n hs-source-dirs: test\n default-language: Haskell2010\n ghc-options: -Wall -fwarn-tabs\n build-depends:\n base,\n time\n main-is: ShowDefaultTZAbbreviations.hs\n\ntest-suite ShowTime\n type: exitcode-stdio-1.0\n hs-source-dirs: test\n default-language: Haskell2010\n ghc-options: -Wall -fwarn-tabs\n build-depends:\n base,\n time\n main-is: ShowTime.hs\n\ntest-suite test-main\n type: exitcode-stdio-1.0\n hs-source-dirs: test/main\n default-language: Haskell2010\n default-extensions:\n Rank2Types\n GeneralizedNewtypeDeriving\n DeriveDataTypeable\n StandaloneDeriving\n ExistentialQuantification\n MultiParamTypeClasses\n FlexibleInstances\n UndecidableInstances\n ScopedTypeVariables\n TupleSections\n ghc-options: -Wall -fwarn-tabs\n build-depends:\n base,\n deepseq,\n time,\n random,\n QuickCheck,\n tasty,\n tasty-hunit,\n tasty-quickcheck\n main-is: Main.hs\n other-modules:\n Test.Types\n Test.TestUtil\n Test.Arbitrary\n Test.Calendar.AddDays\n Test.Calendar.AddDaysRef\n Test.Calendar.CalendarProps\n Test.Calendar.Calendars\n Test.Calendar.CalendarsRef\n Test.Calendar.ClipDates\n Test.Calendar.ClipDatesRef\n Test.Calendar.ConvertBack\n Test.Calendar.Duration\n Test.Calendar.Easter\n Test.Calendar.EasterRef\n Test.Calendar.DayPeriod\n Test.Calendar.LongWeekYears\n Test.Calendar.LongWeekYearsRef\n Test.Calendar.MonthDay\n Test.Calendar.MonthDayRef\n Test.Calendar.MonthOfYear\n Test.Calendar.Valid\n Test.Calendar.Week\n Test.Calendar.Year\n Test.Clock.Conversion\n Test.Clock.Resolution\n Test.Clock.TAI\n Test.Format.Compile\n Test.Format.Format\n Test.Format.ParseTime\n Test.Format.ISO8601\n Test.LocalTime.CalendarDiffTime\n Test.LocalTime.Time\n Test.LocalTime.TimeOfDay\n Test.LocalTime.TimeRef\n\ntest-suite test-unix\n if os(windows)\n buildable: False\n type: exitcode-stdio-1.0\n hs-source-dirs: test/unix\n default-language: Haskell2010\n default-extensions:\n Rank2Types\n DeriveDataTypeable\n StandaloneDeriving\n ExistentialQuantification\n MultiParamTypeClasses\n FlexibleInstances\n UndecidableInstances\n ScopedTypeVariables\n ghc-options: -Wall -fwarn-tabs\n c-sources: test/unix/Test/Format/FormatStuff.c\n build-depends:\n base,\n deepseq,\n time,\n random,\n QuickCheck,\n tasty,\n tasty-hunit,\n tasty-quickcheck\n main-is: Main.hs\n other-modules:\n Test.TestUtil\n Test.Format.Format\n Test.LocalTime.TimeZone\n\nbenchmark time-bench\n type: exitcode-stdio-1.0\n hs-source-dirs: benchmark\n default-language: Haskell2010\n ghc-options: -Wall -fwarn-tabs\n build-depends:\n base,\n deepseq,\n time,\n criterion\n main-is: Main.hs\n"; + } \ No newline at end of file diff --git a/materialized/ghc-extra-projects/windows/ghc927/default.nix b/materialized/ghc-extra-projects/windows/ghc927/default.nix new file mode 100644 index 0000000000..eaadb2dcbd --- /dev/null +++ b/materialized/ghc-extra-projects/windows/ghc927/default.nix @@ -0,0 +1,134 @@ +{ + pkgs = hackage: + { + packages = { + bytestring.revision = (((hackage.bytestring)."0.11.4.0").revisions).default; + exceptions.revision = (((hackage.exceptions)."0.10.4").revisions).default; + directory.revision = import ./cabal-files/directory.nix; + filepath.revision = (((hackage.filepath)."1.4.2.2").revisions).default; + network.revision = import ./cabal-files/network.nix; + mtl.revision = (((hackage.mtl)."2.2.2").revisions).default; + ghc-bignum.revision = (((hackage.ghc-bignum)."1.2").revisions).default; + ghc-prim.revision = (((hackage.ghc-prim)."0.8.0").revisions).default; + ghc-heap.revision = (((hackage.ghc-heap)."9.2.7").revisions).default; + containers.revision = (((hackage.containers)."0.6.5.1").revisions).default; + stm.revision = (((hackage.stm)."2.5.0.2").revisions).default; + base.revision = (((hackage.base)."4.16.4.0").revisions).default; + time.revision = import ./cabal-files/time.nix; + Win32.revision = import ./cabal-files/Win32.nix; + hsc2hs.revision = import ./cabal-files/hsc2hs.nix; + hsc2hs.flags.in-ghc-tree = false; + deepseq.revision = (((hackage.deepseq)."1.4.6.1").revisions).default; + rts.revision = (((hackage.rts)."1.0.2").revisions).default; + template-haskell.revision = (((hackage.template-haskell)."2.18.0.0").revisions).default; + binary.revision = (((hackage.binary)."0.8.9.0").revisions).default; + process.revision = import ./cabal-files/process.nix; + transformers.revision = (((hackage.transformers)."0.5.6.2").revisions).default; + array.revision = (((hackage.array)."0.5.4.0").revisions).default; + ghc-boot-th.revision = (((hackage.ghc-boot-th)."9.2.7").revisions).default; + pretty.revision = (((hackage.pretty)."1.1.3.6").revisions).default; + }; + compiler = { + version = "9.2.7"; + nix-name = "ghc927"; + packages = { + "pretty" = "1.1.3.6"; + "array" = "0.5.4.0"; + "mtl" = "2.2.2"; + "bytestring" = "0.11.4.0"; + "filepath" = "1.4.2.2"; + "stm" = "2.5.0.2"; + "ghc-heap" = "9.2.7"; + "ghc-prim" = "0.8.0"; + "ghc-boot-th" = "9.2.7"; + "base" = "4.16.4.0"; + "ghc-bignum" = "1.2"; + "exceptions" = "0.10.4"; + "rts" = "1.0.2"; + "transformers" = "0.5.6.2"; + "template-haskell" = "2.18.0.0"; + "deepseq" = "1.4.6.1"; + "binary" = "0.8.9.0"; + "containers" = "0.6.5.1"; + }; + }; + }; + extras = hackage: + { + packages = { + iserv-proxy = ./.plan.nix/iserv-proxy.nix; + ghc = ./.plan.nix/ghc.nix; + Win32 = ./.plan.nix/Win32.nix; + remote-iserv = ./.plan.nix/remote-iserv.nix; + ghci = ./.plan.nix/ghci.nix; + ghc-boot = ./.plan.nix/ghc-boot.nix; + iserv = ./.plan.nix/iserv.nix; + libiserv = ./.plan.nix/libiserv.nix; + hpc = ./.plan.nix/hpc.nix; + }; + }; + modules = [ + ({ lib, ... }: + { + packages = { + "iserv-proxy" = { flags = {}; }; + "ghc" = { + flags = { + "dynamic-system-linker" = lib.mkOverride 900 true; + "stage2" = lib.mkOverride 900 false; + "terminfo" = lib.mkOverride 900 true; + "stage3" = lib.mkOverride 900 false; + "internal-interpreter" = lib.mkOverride 900 false; + "stage1" = lib.mkOverride 900 false; + }; + }; + "Win32" = { flags = {}; }; + "remote-iserv" = { flags = {}; }; + "ghci" = { + flags = { "internal-interpreter" = lib.mkOverride 900 true; }; + }; + "ghc-boot" = { flags = {}; }; + "iserv" = { flags = {}; }; + "libiserv" = { flags = { "network" = lib.mkOverride 900 true; }; }; + "hpc" = { flags = {}; }; + }; + }) + ({ lib, ... }: + { + packages = { + "filepath".components.library.planned = lib.mkOverride 900 true; + "pretty".components.library.planned = lib.mkOverride 900 true; + "bytestring".components.library.planned = lib.mkOverride 900 true; + "remote-iserv".components.exes."remote-iserv".planned = lib.mkOverride 900 true; + "exceptions".components.library.planned = lib.mkOverride 900 true; + "ghc-prim".components.library.planned = lib.mkOverride 900 true; + "array".components.library.planned = lib.mkOverride 900 true; + "Win32".components.library.planned = lib.mkOverride 900 true; + "binary".components.library.planned = lib.mkOverride 900 true; + "ghc-boot-th".components.library.planned = lib.mkOverride 900 true; + "rts".components.library.planned = lib.mkOverride 900 true; + "hsc2hs".components.exes."hsc2hs".planned = lib.mkOverride 900 true; + "directory".components.library.planned = lib.mkOverride 900 true; + "iserv".components.exes."iserv".planned = lib.mkOverride 900 true; + "time".components.library.planned = lib.mkOverride 900 true; + "network".components.library.planned = lib.mkOverride 900 true; + "ghc".components.library.planned = lib.mkOverride 900 true; + "ghc-bignum".components.library.planned = lib.mkOverride 900 true; + "process".components.library.planned = lib.mkOverride 900 true; + "template-haskell".components.library.planned = lib.mkOverride 900 true; + "stm".components.library.planned = lib.mkOverride 900 true; + "ghci".components.library.planned = lib.mkOverride 900 true; + "ghc-boot".components.library.planned = lib.mkOverride 900 true; + "hpc".components.library.planned = lib.mkOverride 900 true; + "ghc-heap".components.library.planned = lib.mkOverride 900 true; + "mtl".components.library.planned = lib.mkOverride 900 true; + "transformers".components.library.planned = lib.mkOverride 900 true; + "libiserv".components.library.planned = lib.mkOverride 900 true; + "deepseq".components.library.planned = lib.mkOverride 900 true; + "base".components.library.planned = lib.mkOverride 900 true; + "containers".components.library.planned = lib.mkOverride 900 true; + "iserv-proxy".components.exes."iserv-proxy".planned = lib.mkOverride 900 true; + }; + }) + ]; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/.plan.nix/cabal-install.nix b/materialized/ghc927/cabal-install/.plan.nix/cabal-install.nix new file mode 100644 index 0000000000..5b1fbe8ada --- /dev/null +++ b/materialized/ghc927/cabal-install/.plan.nix/cabal-install.nix @@ -0,0 +1,385 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { native-dns = true; lukko = true; }; + package = { + specVersion = "2.2"; + identifier = { name = "cabal-install"; version = "3.8.1.0"; }; + license = "BSD-3-Clause"; + copyright = "2003-2022, Cabal Development Team"; + maintainer = "Cabal Development Team "; + author = "Cabal Development Team (see AUTHORS file)"; + homepage = "http://www.haskell.org/cabal/"; + url = ""; + synopsis = "The command-line interface for Cabal and Hackage."; + description = "The \\'cabal\\' command-line program simplifies the process of managing\nHaskell software by automating the fetching, configuration, compilation\nand installation of Haskell libraries and programs."; + buildType = "Simple"; + isLocal = true; + detailLevel = "FullDetails"; + licenseFiles = [ "LICENSE" ]; + dataDir = "."; + dataFiles = []; + extraSrcFiles = [ "README.md" "bash-completion/cabal" "changelog" ]; + extraTmpFiles = []; + extraDocFiles = []; + }; + components = { + "library" = { + depends = (([ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal")) + (hsPkgs."Cabal-syntax" or (errorHandler.buildDepError "Cabal-syntax")) + (hsPkgs."cabal-install-solver" or (errorHandler.buildDepError "cabal-install-solver")) + (hsPkgs."async" or (errorHandler.buildDepError "async")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base16-bytestring" or (errorHandler.buildDepError "base16-bytestring")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."cryptohash-sha256" or (errorHandler.buildDepError "cryptohash-sha256")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."echo" or (errorHandler.buildDepError "echo")) + (hsPkgs."edit-distance" or (errorHandler.buildDepError "edit-distance")) + (hsPkgs."exceptions" or (errorHandler.buildDepError "exceptions")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."HTTP" or (errorHandler.buildDepError "HTTP")) + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + (hsPkgs."network-uri" or (errorHandler.buildDepError "network-uri")) + (hsPkgs."pretty" or (errorHandler.buildDepError "pretty")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."stm" or (errorHandler.buildDepError "stm")) + (hsPkgs."tar" or (errorHandler.buildDepError "tar")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."zlib" or (errorHandler.buildDepError "zlib")) + (hsPkgs."hackage-security" or (errorHandler.buildDepError "hackage-security")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."parsec" or (errorHandler.buildDepError "parsec")) + (hsPkgs."regex-base" or (errorHandler.buildDepError "regex-base")) + (hsPkgs."regex-posix" or (errorHandler.buildDepError "regex-posix")) + (hsPkgs."safe-exceptions" or (errorHandler.buildDepError "safe-exceptions")) + ] ++ (pkgs.lib).optionals (flags.native-dns) (if system.isWindows + then [ (hsPkgs."windns" or (errorHandler.buildDepError "windns")) ] + else [ + (hsPkgs."resolv" or (errorHandler.buildDepError "resolv")) + ])) ++ (if system.isWindows + then [ + (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + ] + else [ + (hsPkgs."unix" or (errorHandler.buildDepError "unix")) + ])) ++ (pkgs.lib).optional (flags.lukko) (hsPkgs."lukko" or (errorHandler.buildDepError "lukko")); + buildable = true; + modules = [ + "Distribution/Deprecated/ParseUtils" + "Distribution/Deprecated/ReadP" + "Distribution/Deprecated/ViewAsFieldDescr" + "Distribution/Client/BuildReports/Anonymous" + "Distribution/Client/BuildReports/Lens" + "Distribution/Client/BuildReports/Storage" + "Distribution/Client/BuildReports/Types" + "Distribution/Client/BuildReports/Upload" + "Distribution/Client/Check" + "Distribution/Client/CmdBench" + "Distribution/Client/CmdBuild" + "Distribution/Client/CmdClean" + "Distribution/Client/CmdConfigure" + "Distribution/Client/CmdErrorMessages" + "Distribution/Client/CmdExec" + "Distribution/Client/CmdFreeze" + "Distribution/Client/CmdHaddock" + "Distribution/Client/CmdInstall" + "Distribution/Client/CmdInstall/ClientInstallFlags" + "Distribution/Client/CmdInstall/ClientInstallTargetSelector" + "Distribution/Client/CmdLegacy" + "Distribution/Client/CmdListBin" + "Distribution/Client/CmdOutdated" + "Distribution/Client/CmdRepl" + "Distribution/Client/CmdRun" + "Distribution/Client/CmdSdist" + "Distribution/Client/CmdTest" + "Distribution/Client/CmdUpdate" + "Distribution/Client/Compat/Directory" + "Distribution/Client/Compat/ExecutablePath" + "Distribution/Client/Compat/Orphans" + "Distribution/Client/Compat/Prelude" + "Distribution/Client/Compat/Process" + "Distribution/Client/Compat/Semaphore" + "Distribution/Client/Config" + "Distribution/Client/Configure" + "Distribution/Client/Dependency" + "Distribution/Client/Dependency/Types" + "Distribution/Client/DistDirLayout" + "Distribution/Client/Fetch" + "Distribution/Client/FetchUtils" + "Distribution/Client/FileMonitor" + "Distribution/Client/Freeze" + "Distribution/Client/GZipUtils" + "Distribution/Client/GenBounds" + "Distribution/Client/Get" + "Distribution/Client/Glob" + "Distribution/Client/GlobalFlags" + "Distribution/Client/Haddock" + "Distribution/Client/HashValue" + "Distribution/Client/HttpUtils" + "Distribution/Client/IndexUtils" + "Distribution/Client/IndexUtils/ActiveRepos" + "Distribution/Client/IndexUtils/IndexState" + "Distribution/Client/IndexUtils/Timestamp" + "Distribution/Client/Init" + "Distribution/Client/Init/Defaults" + "Distribution/Client/Init/FileCreators" + "Distribution/Client/Init/FlagExtractors" + "Distribution/Client/Init/Format" + "Distribution/Client/Init/Interactive/Command" + "Distribution/Client/Init/NonInteractive/Command" + "Distribution/Client/Init/NonInteractive/Heuristics" + "Distribution/Client/Init/Licenses" + "Distribution/Client/Init/Prompt" + "Distribution/Client/Init/Simple" + "Distribution/Client/Init/Types" + "Distribution/Client/Init/Utils" + "Distribution/Client/Install" + "Distribution/Client/InstallPlan" + "Distribution/Client/InstallSymlink" + "Distribution/Client/JobControl" + "Distribution/Client/List" + "Distribution/Client/Manpage" + "Distribution/Client/ManpageFlags" + "Distribution/Client/Nix" + "Distribution/Client/NixStyleOptions" + "Distribution/Client/PackageHash" + "Distribution/Client/ParseUtils" + "Distribution/Client/ProjectBuilding" + "Distribution/Client/ProjectBuilding/Types" + "Distribution/Client/ProjectConfig" + "Distribution/Client/ProjectConfig/Legacy" + "Distribution/Client/ProjectConfig/Types" + "Distribution/Client/ProjectFlags" + "Distribution/Client/ProjectOrchestration" + "Distribution/Client/ProjectPlanOutput" + "Distribution/Client/ProjectPlanning" + "Distribution/Client/ProjectPlanning/Types" + "Distribution/Client/RebuildMonad" + "Distribution/Client/Reconfigure" + "Distribution/Client/Run" + "Distribution/Client/Sandbox" + "Distribution/Client/Sandbox/PackageEnvironment" + "Distribution/Client/SavedFlags" + "Distribution/Client/ScriptUtils" + "Distribution/Client/Security/DNS" + "Distribution/Client/Security/HTTP" + "Distribution/Client/Setup" + "Distribution/Client/SetupWrapper" + "Distribution/Client/SolverInstallPlan" + "Distribution/Client/SourceFiles" + "Distribution/Client/SrcDist" + "Distribution/Client/Store" + "Distribution/Client/Tar" + "Distribution/Client/TargetProblem" + "Distribution/Client/TargetSelector" + "Distribution/Client/Targets" + "Distribution/Client/Types" + "Distribution/Client/Types/AllowNewer" + "Distribution/Client/Types/BuildResults" + "Distribution/Client/Types/ConfiguredId" + "Distribution/Client/Types/ConfiguredPackage" + "Distribution/Client/Types/Credentials" + "Distribution/Client/Types/InstallMethod" + "Distribution/Client/Types/OverwritePolicy" + "Distribution/Client/Types/PackageLocation" + "Distribution/Client/Types/PackageSpecifier" + "Distribution/Client/Types/ReadyPackage" + "Distribution/Client/Types/Repo" + "Distribution/Client/Types/RepoName" + "Distribution/Client/Types/SourcePackageDb" + "Distribution/Client/Types/SourceRepo" + "Distribution/Client/Types/WriteGhcEnvironmentFilesPolicy" + "Distribution/Client/Upload" + "Distribution/Client/Utils" + "Distribution/Client/Utils/Json" + "Distribution/Client/Utils/Parsec" + "Distribution/Client/VCS" + "Distribution/Client/Version" + "Distribution/Client/Win32SelfUpgrade" + ]; + hsSourceDirs = [ "src" ]; + }; + exes = { + "cabal" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal")) + (hsPkgs."Cabal-syntax" or (errorHandler.buildDepError "Cabal-syntax")) + (hsPkgs."cabal-install" or (errorHandler.buildDepError "cabal-install")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + ]; + libs = (pkgs.lib).optional (system.isAix) (pkgs."bsd" or (errorHandler.sysDepError "bsd")); + buildable = true; + hsSourceDirs = [ "main" ]; + mainPath = (([ + "Main.hs" + ] ++ (pkgs.lib).optional (compiler.isGhc && (compiler.version).lt "8.8") "") ++ (pkgs.lib).optional (compiler.isGhc && (compiler.version).ge "8.10") "") ++ (pkgs.lib).optional (system.isAix) ""; + }; + }; + tests = { + "unit-tests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal")) + (hsPkgs."Cabal-syntax" or (errorHandler.buildDepError "Cabal-syntax")) + (hsPkgs."cabal-install-solver" or (errorHandler.buildDepError "cabal-install-solver")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."cabal-install" or (errorHandler.buildDepError "cabal-install")) + (hsPkgs."Cabal-tree-diff" or (errorHandler.buildDepError "Cabal-tree-diff")) + (hsPkgs."Cabal-QuickCheck" or (errorHandler.buildDepError "Cabal-QuickCheck")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + (hsPkgs."network-uri" or (errorHandler.buildDepError "network-uri")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."tar" or (errorHandler.buildDepError "tar")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."zlib" or (errorHandler.buildDepError "zlib")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-golden" or (errorHandler.buildDepError "tasty-golden")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + (hsPkgs."tree-diff" or (errorHandler.buildDepError "tree-diff")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + ]; + buildable = true; + modules = [ + "UnitTests/Distribution/Client/ArbitraryInstances" + "UnitTests/Distribution/Client/BuildReport" + "UnitTests/Distribution/Client/Configure" + "UnitTests/Distribution/Client/FetchUtils" + "UnitTests/Distribution/Client/Get" + "UnitTests/Distribution/Client/Glob" + "UnitTests/Distribution/Client/GZipUtils" + "UnitTests/Distribution/Client/IndexUtils" + "UnitTests/Distribution/Client/IndexUtils/Timestamp" + "UnitTests/Distribution/Client/Init" + "UnitTests/Distribution/Client/Init/Golden" + "UnitTests/Distribution/Client/Init/Interactive" + "UnitTests/Distribution/Client/Init/NonInteractive" + "UnitTests/Distribution/Client/Init/Simple" + "UnitTests/Distribution/Client/Init/Utils" + "UnitTests/Distribution/Client/Init/FileCreators" + "UnitTests/Distribution/Client/InstallPlan" + "UnitTests/Distribution/Client/JobControl" + "UnitTests/Distribution/Client/ProjectConfig" + "UnitTests/Distribution/Client/ProjectPlanning" + "UnitTests/Distribution/Client/Store" + "UnitTests/Distribution/Client/Tar" + "UnitTests/Distribution/Client/Targets" + "UnitTests/Distribution/Client/TreeDiffInstances" + "UnitTests/Distribution/Client/UserConfig" + "UnitTests/Distribution/Solver/Modular/Builder" + "UnitTests/Distribution/Solver/Modular/RetryLog" + "UnitTests/Distribution/Solver/Modular/Solver" + "UnitTests/Distribution/Solver/Modular/DSL" + "UnitTests/Distribution/Solver/Modular/DSL/TestCaseUtils" + "UnitTests/Distribution/Solver/Modular/WeightedPSQ" + "UnitTests/Distribution/Solver/Types/OptionalStanza" + "UnitTests/Options" + "UnitTests/TempTestDir" + ]; + hsSourceDirs = [ "tests" ]; + mainPath = [ "UnitTests.hs" ]; + }; + "mem-use-tests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal")) + (hsPkgs."Cabal-syntax" or (errorHandler.buildDepError "Cabal-syntax")) + (hsPkgs."cabal-install-solver" or (errorHandler.buildDepError "cabal-install-solver")) + (hsPkgs."cabal-install" or (errorHandler.buildDepError "cabal-install")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + ]; + buildable = true; + modules = [ + "UnitTests/Distribution/Solver/Modular/DSL" + "UnitTests/Distribution/Solver/Modular/DSL/TestCaseUtils" + "UnitTests/Distribution/Solver/Modular/MemoryUsage" + "UnitTests/Options" + ]; + hsSourceDirs = [ "tests" ]; + mainPath = [ "MemoryUsageTests.hs" ]; + }; + "integration-tests2" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal")) + (hsPkgs."Cabal-syntax" or (errorHandler.buildDepError "Cabal-syntax")) + (hsPkgs."cabal-install-solver" or (errorHandler.buildDepError "cabal-install-solver")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."cabal-install" or (errorHandler.buildDepError "cabal-install")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + (hsPkgs."tagged" or (errorHandler.buildDepError "tagged")) + ]; + buildable = true; + hsSourceDirs = [ "tests" ]; + mainPath = [ "IntegrationTests2.hs" ]; + }; + "long-tests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal")) + (hsPkgs."Cabal-syntax" or (errorHandler.buildDepError "Cabal-syntax")) + (hsPkgs."cabal-install-solver" or (errorHandler.buildDepError "cabal-install-solver")) + (hsPkgs."Cabal-QuickCheck" or (errorHandler.buildDepError "Cabal-QuickCheck")) + (hsPkgs."Cabal-described" or (errorHandler.buildDepError "Cabal-described")) + (hsPkgs."cabal-install" or (errorHandler.buildDepError "cabal-install")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + (hsPkgs."network-uri" or (errorHandler.buildDepError "network-uri")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."tagged" or (errorHandler.buildDepError "tagged")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-expected-failure" or (errorHandler.buildDepError "tasty-expected-failure")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."pretty-show" or (errorHandler.buildDepError "pretty-show")) + ]; + buildable = true; + modules = [ + "UnitTests/Distribution/Client/ArbitraryInstances" + "UnitTests/Distribution/Client/Described" + "UnitTests/Distribution/Client/DescribedInstances" + "UnitTests/Distribution/Client/FileMonitor" + "UnitTests/Distribution/Client/VCS" + "UnitTests/Distribution/Solver/Modular/DSL" + "UnitTests/Distribution/Solver/Modular/QuickCheck" + "UnitTests/Distribution/Solver/Modular/QuickCheck/Utils" + "UnitTests/Options" + "UnitTests/TempTestDir" + ]; + hsSourceDirs = [ "tests" ]; + mainPath = [ "LongTests.hs" ]; + }; + }; + }; + } // rec { src = (pkgs.lib).mkDefault ../.; } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/Cabal-syntax.nix b/materialized/ghc927/cabal-install/cabal-files/Cabal-syntax.nix new file mode 100644 index 0000000000..b9a8c2c473 --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/Cabal-syntax.nix @@ -0,0 +1,55 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "1.22"; + identifier = { name = "Cabal-syntax"; version = "3.8.1.0"; }; + license = "BSD-3-Clause"; + copyright = "2003-2022, Cabal Development Team (see AUTHORS file)"; + maintainer = "cabal-devel@haskell.org"; + author = "Cabal Development Team "; + homepage = "http://www.haskell.org/cabal/"; + url = ""; + synopsis = "A library for working with .cabal files"; + description = "This library provides tools for reading and manipulating the .cabal file\nformat."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + (hsPkgs."parsec" or (errorHandler.buildDepError "parsec")) + (hsPkgs."pretty" or (errorHandler.buildDepError "pretty")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + ] ++ (if system.isWindows + then [ (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) ] + else [ (hsPkgs."unix" or (errorHandler.buildDepError "unix")) ]); + buildable = true; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/Cabal-syntax-3.8.1.0.tar.gz"; + sha256 = "07e8ddb19fe01781485f1522b6afc22aba680b0ab28ebe6bbfb84a2dd698ce0f"; + }); + }) // { + package-description-override = "cabal-version: 1.22\r\nname: Cabal-syntax\r\nversion: 3.8.1.0\r\nx-revision: 1\r\ncopyright: 2003-2022, Cabal Development Team (see AUTHORS file)\r\nlicense: BSD3\r\nlicense-file: LICENSE\r\nauthor: Cabal Development Team \r\nmaintainer: cabal-devel@haskell.org\r\nhomepage: http://www.haskell.org/cabal/\r\nbug-reports: https://github.com/haskell/cabal/issues\r\nsynopsis: A library for working with .cabal files\r\ndescription:\r\n This library provides tools for reading and manipulating the .cabal file\r\n format.\r\ncategory: Distribution\r\nbuild-type: Simple\r\n\r\nextra-source-files:\r\n README.md ChangeLog.md\r\n\r\nsource-repository head\r\n type: git\r\n location: https://github.com/haskell/cabal/\r\n subdir: Cabal-syntax\r\n\r\nlibrary\r\n default-language: Haskell2010\r\n hs-source-dirs: src\r\n\r\n build-depends:\r\n array >= 0.4.0.1 && < 0.6,\r\n base >= 4.9 && < 5,\r\n binary >= 0.7 && < 0.9,\r\n bytestring >= 0.10.0.0 && < 0.12,\r\n containers >= 0.5.0.0 && < 0.7,\r\n deepseq >= 1.3.0.1 && < 1.5,\r\n directory >= 1.2 && < 1.4,\r\n filepath >= 1.3.0.1 && < 1.5,\r\n mtl >= 2.1 && < 2.3,\r\n parsec >= 3.1.13.0 && < 3.2,\r\n pretty >= 1.1.1 && < 1.2,\r\n text (>= 1.2.3.0 && < 1.3) || (>= 2.0 && < 2.1),\r\n time >= 1.4.0.1 && < 1.13,\r\n -- transformers-0.4.0.0 doesn't have record syntax e.g. for Identity\r\n -- See also https://github.com/ekmett/transformers-compat/issues/35\r\n transformers (>= 0.3 && < 0.4) || (>=0.4.1.0 && <0.6)\r\n\r\n if os(windows)\r\n build-depends: Win32 >= 2.3.0.0 && < 2.14\r\n else\r\n build-depends: unix >= 2.6.0.0 && < 2.8\r\n\r\n ghc-options: -Wall -fno-ignore-asserts -fwarn-tabs -fwarn-incomplete-uni-patterns -fwarn-incomplete-record-updates\r\n ghc-options: -Wcompat -Wnoncanonical-monad-instances\r\n\r\n if impl(ghc <8.8)\r\n ghc-options: -Wnoncanonical-monadfail-instances\r\n\r\n exposed-modules:\r\n Distribution.Backpack\r\n Distribution.CabalSpecVersion\r\n Distribution.Compat.Binary\r\n Distribution.Compat.CharParsing\r\n Distribution.Compat.DList\r\n Distribution.Compat.Exception\r\n Distribution.Compat.Graph\r\n Distribution.Compat.Lens\r\n Distribution.Compat.MonadFail\r\n Distribution.Compat.Newtype\r\n Distribution.Compat.NonEmptySet\r\n Distribution.Compat.Parsing\r\n Distribution.Compat.Prelude\r\n Distribution.Compat.Semigroup\r\n Distribution.Compat.Typeable\r\n Distribution.Compiler\r\n Distribution.FieldGrammar\r\n Distribution.FieldGrammar.Class\r\n Distribution.FieldGrammar.FieldDescrs\r\n Distribution.FieldGrammar.Newtypes\r\n Distribution.FieldGrammar.Parsec\r\n Distribution.FieldGrammar.Pretty\r\n Distribution.Fields\r\n Distribution.Fields.ConfVar\r\n Distribution.Fields.Field\r\n Distribution.Fields.Lexer\r\n Distribution.Fields.LexerMonad\r\n Distribution.Fields.ParseResult\r\n Distribution.Fields.Parser\r\n Distribution.Fields.Pretty\r\n Distribution.InstalledPackageInfo\r\n Distribution.License\r\n Distribution.ModuleName\r\n Distribution.Package\r\n Distribution.PackageDescription\r\n Distribution.PackageDescription.Configuration\r\n Distribution.PackageDescription.FieldGrammar\r\n Distribution.PackageDescription.Parsec\r\n Distribution.PackageDescription.PrettyPrint\r\n Distribution.PackageDescription.Quirks\r\n Distribution.PackageDescription.Utils\r\n Distribution.Parsec\r\n Distribution.Parsec.Error\r\n Distribution.Parsec.FieldLineStream\r\n Distribution.Parsec.Position\r\n Distribution.Parsec.Warning\r\n Distribution.Pretty\r\n Distribution.SPDX\r\n Distribution.SPDX.License\r\n Distribution.SPDX.LicenseExceptionId\r\n Distribution.SPDX.LicenseExpression\r\n Distribution.SPDX.LicenseId\r\n Distribution.SPDX.LicenseListVersion\r\n Distribution.SPDX.LicenseReference\r\n Distribution.System\r\n Distribution.Text\r\n Distribution.Types.AbiDependency\r\n Distribution.Types.AbiHash\r\n Distribution.Types.Benchmark\r\n Distribution.Types.Benchmark.Lens\r\n Distribution.Types.BenchmarkInterface\r\n Distribution.Types.BenchmarkType\r\n Distribution.Types.BuildInfo\r\n Distribution.Types.BuildInfo.Lens\r\n Distribution.Types.BuildType\r\n Distribution.Types.Component\r\n Distribution.Types.ComponentId\r\n Distribution.Types.ComponentName\r\n Distribution.Types.ComponentRequestedSpec\r\n Distribution.Types.CondTree\r\n Distribution.Types.Condition\r\n Distribution.Types.ConfVar\r\n Distribution.Types.Dependency\r\n Distribution.Types.DependencyMap\r\n Distribution.Types.ExeDependency\r\n Distribution.Types.Executable\r\n Distribution.Types.Executable.Lens\r\n Distribution.Types.ExecutableScope\r\n Distribution.Types.ExposedModule\r\n Distribution.Types.Flag\r\n Distribution.Types.ForeignLib\r\n Distribution.Types.ForeignLib.Lens\r\n Distribution.Types.ForeignLibOption\r\n Distribution.Types.ForeignLibType\r\n Distribution.Types.GenericPackageDescription\r\n Distribution.Types.GenericPackageDescription.Lens\r\n Distribution.Types.HookedBuildInfo\r\n Distribution.Types.IncludeRenaming\r\n Distribution.Types.InstalledPackageInfo\r\n Distribution.Types.InstalledPackageInfo.Lens\r\n Distribution.Types.InstalledPackageInfo.FieldGrammar\r\n Distribution.Types.LegacyExeDependency\r\n Distribution.Types.Lens\r\n Distribution.Types.Library\r\n Distribution.Types.Library.Lens\r\n Distribution.Types.LibraryName\r\n Distribution.Types.LibraryVisibility\r\n Distribution.Types.Mixin\r\n Distribution.Types.Module\r\n Distribution.Types.ModuleReexport\r\n Distribution.Types.ModuleRenaming\r\n Distribution.Types.MungedPackageId\r\n Distribution.Types.MungedPackageName\r\n Distribution.Types.PackageDescription\r\n Distribution.Types.PackageDescription.Lens\r\n Distribution.Types.PackageId\r\n Distribution.Types.PackageId.Lens\r\n Distribution.Types.PackageName\r\n Distribution.Types.PackageVersionConstraint\r\n Distribution.Types.PkgconfigDependency\r\n Distribution.Types.PkgconfigName\r\n Distribution.Types.PkgconfigVersion\r\n Distribution.Types.PkgconfigVersionRange\r\n Distribution.Types.SetupBuildInfo\r\n Distribution.Types.SetupBuildInfo.Lens\r\n Distribution.Types.SourceRepo\r\n Distribution.Types.SourceRepo.Lens\r\n Distribution.Types.TestSuite\r\n Distribution.Types.TestSuite.Lens\r\n Distribution.Types.TestSuiteInterface\r\n Distribution.Types.TestType\r\n Distribution.Types.UnitId\r\n Distribution.Types.UnqualComponentName\r\n Distribution.Types.Version\r\n Distribution.Types.VersionInterval\r\n Distribution.Types.VersionInterval.Legacy\r\n Distribution.Types.VersionRange\r\n Distribution.Types.VersionRange.Internal\r\n Distribution.Utils.Base62\r\n Distribution.Utils.Generic\r\n Distribution.Utils.MD5\r\n Distribution.Utils.Path\r\n Distribution.Utils.ShortText\r\n Distribution.Utils.String\r\n Distribution.Utils.Structured\r\n Distribution.Version\r\n Language.Haskell.Extension\r\n\r\n other-extensions:\r\n BangPatterns\r\n CPP\r\n DefaultSignatures\r\n DeriveDataTypeable\r\n DeriveFoldable\r\n DeriveFunctor\r\n DeriveGeneric\r\n DeriveTraversable\r\n ExistentialQuantification\r\n FlexibleContexts\r\n FlexibleInstances\r\n GeneralizedNewtypeDeriving\r\n ImplicitParams\r\n KindSignatures\r\n NondecreasingIndentation\r\n OverloadedStrings\r\n PatternSynonyms\r\n RankNTypes\r\n RecordWildCards\r\n ScopedTypeVariables\r\n StandaloneDeriving\r\n Trustworthy\r\n TypeFamilies\r\n TypeOperators\r\n TypeSynonymInstances\r\n UndecidableInstances\r\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/Cabal.nix b/materialized/ghc927/cabal-install/cabal-files/Cabal.nix new file mode 100644 index 0000000000..3d69ff116a --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/Cabal.nix @@ -0,0 +1,56 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "1.22"; + identifier = { name = "Cabal"; version = "3.8.1.0"; }; + license = "BSD-3-Clause"; + copyright = "2003-2022, Cabal Development Team (see AUTHORS file)"; + maintainer = "cabal-devel@haskell.org"; + author = "Cabal Development Team "; + homepage = "http://www.haskell.org/cabal/"; + url = ""; + synopsis = "A framework for packaging Haskell software"; + description = "The Haskell Common Architecture for Building Applications and\nLibraries: a framework defining a common interface for authors to more\neasily build their Haskell applications in a portable way.\n\nThe Haskell Cabal is part of a larger infrastructure for distributing,\norganizing, and cataloging Haskell libraries and tools."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = ([ + (hsPkgs."Cabal-syntax" or (errorHandler.buildDepError "Cabal-syntax")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."pretty" or (errorHandler.buildDepError "pretty")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."parsec" or (errorHandler.buildDepError "parsec")) + ] ++ (pkgs.lib).optional (compiler.isGhc && (compiler.version).ge "8.2") (hsPkgs."process" or (errorHandler.buildDepError "process"))) ++ (if system.isWindows + then [ (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) ] + else [ (hsPkgs."unix" or (errorHandler.buildDepError "unix")) ]); + buildable = true; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/Cabal-3.8.1.0.tar.gz"; + sha256 = "7464cbe6c2f3d7e5d0232023a1a7330621f8b24853cb259fc89a2af85b736608"; + }); + }) // { + package-description-override = "cabal-version: 1.22\nname: Cabal\nversion: 3.8.1.0\ncopyright: 2003-2022, Cabal Development Team (see AUTHORS file)\nlicense: BSD3\nlicense-file: LICENSE\nauthor: Cabal Development Team \nmaintainer: cabal-devel@haskell.org\nhomepage: http://www.haskell.org/cabal/\nbug-reports: https://github.com/haskell/cabal/issues\nsynopsis: A framework for packaging Haskell software\ndescription:\n The Haskell Common Architecture for Building Applications and\n Libraries: a framework defining a common interface for authors to more\n easily build their Haskell applications in a portable way.\n .\n The Haskell Cabal is part of a larger infrastructure for distributing,\n organizing, and cataloging Haskell libraries and tools.\ncategory: Distribution\nbuild-type: Simple\n-- If we use a new Cabal feature, this needs to be changed to Custom so\n-- we can bootstrap.\n\nextra-source-files:\n README.md ChangeLog.md\n\nsource-repository head\n type: git\n location: https://github.com/haskell/cabal/\n subdir: Cabal\n\nlibrary\n default-language: Haskell2010\n hs-source-dirs: src\n\n build-depends:\n Cabal-syntax >= 3.8 && < 3.9,\n array >= 0.4.0.1 && < 0.6,\n base >= 4.6 && < 5,\n bytestring >= 0.10.0.0 && < 0.12,\n containers >= 0.5.0.0 && < 0.7,\n deepseq >= 1.3.0.1 && < 1.5,\n directory >= 1.2 && < 1.4,\n filepath >= 1.3.0.1 && < 1.5,\n pretty >= 1.1.1 && < 1.2,\n process >= 1.2.1.0 && < 1.7,\n time >= 1.4.0.1 && < 1.13\n\n -- pull in process version with fixed waitForProcess error\n if impl(ghc >=8.2)\n build-depends: process >= 1.6.14.0\n\n if os(windows)\n build-depends: Win32 >= 2.3.0.0 && < 2.14\n else\n build-depends: unix >= 2.6.0.0 && < 2.8\n\n ghc-options: -Wall -fno-ignore-asserts -fwarn-tabs -fwarn-incomplete-uni-patterns -fwarn-incomplete-record-updates\n ghc-options: -Wcompat -Wnoncanonical-monad-instances\n\n if impl(ghc <8.8)\n ghc-options: -Wnoncanonical-monadfail-instances\n\n exposed-modules:\n Distribution.Backpack.Configure\n Distribution.Backpack.ComponentsGraph\n Distribution.Backpack.ConfiguredComponent\n Distribution.Backpack.DescribeUnitId\n Distribution.Backpack.FullUnitId\n Distribution.Backpack.LinkedComponent\n Distribution.Backpack.ModSubst\n Distribution.Backpack.ModuleShape\n Distribution.Backpack.PreModuleShape\n Distribution.Utils.IOData\n Distribution.Utils.LogProgress\n Distribution.Utils.MapAccum\n Distribution.Compat.CreatePipe\n Distribution.Compat.Directory\n Distribution.Compat.Environment\n Distribution.Compat.FilePath\n Distribution.Compat.Internal.TempFile\n Distribution.Compat.ResponseFile\n Distribution.Compat.Prelude.Internal\n Distribution.Compat.Process\n Distribution.Compat.Stack\n Distribution.Compat.Time\n Distribution.Make\n Distribution.PackageDescription.Check\n Distribution.ReadE\n Distribution.Simple\n Distribution.Simple.Bench\n Distribution.Simple.Build\n Distribution.Simple.Build.Macros\n Distribution.Simple.Build.PathsModule\n Distribution.Simple.BuildPaths\n Distribution.Simple.BuildTarget\n Distribution.Simple.BuildToolDepends\n Distribution.Simple.CCompiler\n Distribution.Simple.Command\n Distribution.Simple.Compiler\n Distribution.Simple.Configure\n Distribution.Simple.Flag\n Distribution.Simple.GHC\n Distribution.Simple.GHCJS\n Distribution.Simple.Haddock\n Distribution.Simple.Glob\n Distribution.Simple.HaskellSuite\n Distribution.Simple.Hpc\n Distribution.Simple.Install\n Distribution.Simple.InstallDirs\n Distribution.Simple.InstallDirs.Internal\n Distribution.Simple.LocalBuildInfo\n Distribution.Simple.PackageDescription\n Distribution.Simple.PackageIndex\n Distribution.Simple.PreProcess\n Distribution.Simple.PreProcess.Unlit\n Distribution.Simple.Program\n Distribution.Simple.Program.Ar\n Distribution.Simple.Program.Builtin\n Distribution.Simple.Program.Db\n Distribution.Simple.Program.Find\n Distribution.Simple.Program.GHC\n Distribution.Simple.Program.HcPkg\n Distribution.Simple.Program.Hpc\n Distribution.Simple.Program.Internal\n Distribution.Simple.Program.Ld\n Distribution.Simple.Program.ResponseFile\n Distribution.Simple.Program.Run\n Distribution.Simple.Program.Script\n Distribution.Simple.Program.Strip\n Distribution.Simple.Program.Types\n Distribution.Simple.Register\n Distribution.Simple.Setup\n Distribution.Simple.ShowBuildInfo\n Distribution.Simple.SrcDist\n Distribution.Simple.Test\n Distribution.Simple.Test.ExeV10\n Distribution.Simple.Test.LibV09\n Distribution.Simple.Test.Log\n Distribution.Simple.UHC\n Distribution.Simple.UserHooks\n Distribution.Simple.Utils\n Distribution.TestSuite\n Distribution.Types.AnnotatedId\n Distribution.Types.ComponentInclude\n Distribution.Types.DumpBuildInfo\n Distribution.Types.PackageName.Magic\n Distribution.Types.ComponentLocalBuildInfo\n Distribution.Types.LocalBuildInfo\n Distribution.Types.TargetInfo\n Distribution.Types.GivenComponent\n Distribution.Utils.Json\n Distribution.Utils.NubList\n Distribution.Utils.Progress\n Distribution.Verbosity\n Distribution.Verbosity.Internal\n\n -- We reexport all of Cabal-syntax to aid in compatibility for downstream\n -- users. In the future we may opt to deprecate some or all of these exports.\n -- See haskell/Cabal#7974.\n reexported-modules:\n Distribution.Backpack,\n Distribution.CabalSpecVersion,\n Distribution.Compat.Binary,\n Distribution.Compat.CharParsing,\n Distribution.Compat.DList,\n Distribution.Compat.Exception,\n Distribution.Compat.Graph,\n Distribution.Compat.Lens,\n Distribution.Compat.MonadFail,\n Distribution.Compat.Newtype,\n Distribution.Compat.NonEmptySet,\n Distribution.Compat.Parsing,\n Distribution.Compat.Prelude,\n Distribution.Compat.Semigroup,\n Distribution.Compat.Typeable,\n Distribution.Compiler,\n Distribution.FieldGrammar,\n Distribution.FieldGrammar.Class,\n Distribution.FieldGrammar.FieldDescrs,\n Distribution.FieldGrammar.Newtypes,\n Distribution.FieldGrammar.Parsec,\n Distribution.FieldGrammar.Pretty,\n Distribution.Fields,\n Distribution.Fields.ConfVar,\n Distribution.Fields.Field,\n Distribution.Fields.Lexer,\n Distribution.Fields.LexerMonad,\n Distribution.Fields.ParseResult,\n Distribution.Fields.Parser,\n Distribution.Fields.Pretty,\n Distribution.InstalledPackageInfo,\n Distribution.License,\n Distribution.ModuleName,\n Distribution.Package,\n Distribution.PackageDescription,\n Distribution.PackageDescription.Configuration,\n Distribution.PackageDescription.FieldGrammar,\n Distribution.PackageDescription.Parsec,\n Distribution.PackageDescription.PrettyPrint,\n Distribution.PackageDescription.Quirks,\n Distribution.PackageDescription.Utils,\n Distribution.Parsec,\n Distribution.Parsec.Error,\n Distribution.Parsec.FieldLineStream,\n Distribution.Parsec.Position,\n Distribution.Parsec.Warning,\n Distribution.Pretty,\n Distribution.SPDX,\n Distribution.SPDX.License,\n Distribution.SPDX.LicenseExceptionId,\n Distribution.SPDX.LicenseExpression,\n Distribution.SPDX.LicenseId,\n Distribution.SPDX.LicenseListVersion,\n Distribution.SPDX.LicenseReference,\n Distribution.System,\n Distribution.Text,\n Distribution.Types.AbiDependency,\n Distribution.Types.AbiHash,\n Distribution.Types.Benchmark,\n Distribution.Types.Benchmark.Lens,\n Distribution.Types.BenchmarkInterface,\n Distribution.Types.BenchmarkType,\n Distribution.Types.BuildInfo,\n Distribution.Types.BuildInfo.Lens,\n Distribution.Types.BuildType,\n Distribution.Types.Component,\n Distribution.Types.ComponentId,\n Distribution.Types.ComponentName,\n Distribution.Types.ComponentRequestedSpec,\n Distribution.Types.CondTree,\n Distribution.Types.Condition,\n Distribution.Types.ConfVar,\n Distribution.Types.Dependency,\n Distribution.Types.DependencyMap,\n Distribution.Types.ExeDependency,\n Distribution.Types.Executable,\n Distribution.Types.Executable.Lens,\n Distribution.Types.ExecutableScope,\n Distribution.Types.ExposedModule,\n Distribution.Types.Flag,\n Distribution.Types.ForeignLib,\n Distribution.Types.ForeignLib.Lens,\n Distribution.Types.ForeignLibOption,\n Distribution.Types.ForeignLibType,\n Distribution.Types.GenericPackageDescription,\n Distribution.Types.GenericPackageDescription.Lens,\n Distribution.Types.HookedBuildInfo,\n Distribution.Types.IncludeRenaming,\n Distribution.Types.InstalledPackageInfo,\n Distribution.Types.InstalledPackageInfo.Lens,\n Distribution.Types.InstalledPackageInfo.FieldGrammar,\n Distribution.Types.LegacyExeDependency,\n Distribution.Types.Lens,\n Distribution.Types.Library,\n Distribution.Types.Library.Lens,\n Distribution.Types.LibraryName,\n Distribution.Types.LibraryVisibility,\n Distribution.Types.Mixin,\n Distribution.Types.Module,\n Distribution.Types.ModuleReexport,\n Distribution.Types.ModuleRenaming,\n Distribution.Types.MungedPackageId,\n Distribution.Types.MungedPackageName,\n Distribution.Types.PackageDescription,\n Distribution.Types.PackageDescription.Lens,\n Distribution.Types.PackageId,\n Distribution.Types.PackageId.Lens,\n Distribution.Types.PackageName,\n Distribution.Types.PackageVersionConstraint,\n Distribution.Types.PkgconfigDependency,\n Distribution.Types.PkgconfigName,\n Distribution.Types.PkgconfigVersion,\n Distribution.Types.PkgconfigVersionRange,\n Distribution.Types.SetupBuildInfo,\n Distribution.Types.SetupBuildInfo.Lens,\n Distribution.Types.SourceRepo,\n Distribution.Types.SourceRepo.Lens,\n Distribution.Types.TestSuite,\n Distribution.Types.TestSuite.Lens,\n Distribution.Types.TestSuiteInterface,\n Distribution.Types.TestType,\n Distribution.Types.UnitId,\n Distribution.Types.UnqualComponentName,\n Distribution.Types.Version,\n Distribution.Types.VersionInterval,\n Distribution.Types.VersionInterval.Legacy,\n Distribution.Types.VersionRange,\n Distribution.Types.VersionRange.Internal,\n Distribution.Utils.Base62,\n Distribution.Utils.Generic,\n Distribution.Utils.MD5,\n Distribution.Utils.Path,\n Distribution.Utils.ShortText,\n Distribution.Utils.String,\n Distribution.Utils.Structured,\n Distribution.Version,\n Language.Haskell.Extension\n\n -- Parsec parser-related modules\n build-depends:\n -- transformers-0.4.0.0 doesn't have record syntax e.g. for Identity\n -- See also https://github.com/ekmett/transformers-compat/issues/35\n transformers (>= 0.3 && < 0.4) || (>=0.4.1.0 && <0.6),\n mtl >= 2.1 && < 2.3,\n text (>= 1.2.3.0 && < 1.3) || (>= 2.0 && < 2.1),\n parsec >= 3.1.13.0 && < 3.2\n\n other-modules:\n Distribution.Backpack.PreExistingComponent\n Distribution.Backpack.ReadyComponent\n Distribution.Backpack.MixLink\n Distribution.Backpack.ModuleScope\n Distribution.Backpack.UnifyM\n Distribution.Backpack.Id\n Distribution.Utils.UnionFind\n Distribution.Compat.Async\n Distribution.Compat.CopyFile\n Distribution.Compat.GetShortPathName\n Distribution.Compat.SnocList\n Distribution.GetOpt\n Distribution.Lex\n Distribution.Simple.Build.Macros.Z\n Distribution.Simple.Build.PathsModule.Z\n Distribution.Simple.GHC.EnvironmentParser\n Distribution.Simple.GHC.Internal\n Distribution.Simple.GHC.ImplInfo\n Distribution.ZinzaPrelude\n Paths_Cabal\n\n other-extensions:\n BangPatterns\n CPP\n DefaultSignatures\n DeriveDataTypeable\n DeriveFoldable\n DeriveFunctor\n DeriveGeneric\n DeriveTraversable\n ExistentialQuantification\n FlexibleContexts\n FlexibleInstances\n GeneralizedNewtypeDeriving\n ImplicitParams\n KindSignatures\n LambdaCase\n NondecreasingIndentation\n OverloadedStrings\n PatternSynonyms\n RankNTypes\n RecordWildCards\n ScopedTypeVariables\n StandaloneDeriving\n Trustworthy\n TypeFamilies\n TypeOperators\n TypeSynonymInstances\n UndecidableInstances\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/HTTP.nix b/materialized/ghc927/cabal-install/cabal-files/HTTP.nix new file mode 100644 index 0000000000..3e032ab1ad --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/HTTP.nix @@ -0,0 +1,98 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = { + warn-as-error = false; + conduit10 = false; + warp-tests = false; + network-uri = true; + }; + package = { + specVersion = "1.10"; + identifier = { name = "HTTP"; version = "4000.4.1"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "Ganesh Sittampalam "; + author = "Warrick Gray "; + homepage = "https://github.com/haskell/HTTP"; + url = ""; + synopsis = "A library for client-side HTTP"; + description = "The HTTP package supports client-side web programming in Haskell. It lets you set up\nHTTP connections, transmitting requests and processing the responses coming back, all\nfrom within the comforts of Haskell. It's dependent on the network package to operate,\nbut other than that, the implementation is all written in Haskell.\n\nA basic API for issuing single HTTP requests + receiving responses is provided. On top\nof that, a session-level abstraction is also on offer (the @BrowserAction@ monad);\nit taking care of handling the management of persistent connections, proxies,\nstate (cookies) and authentication credentials required to handle multi-step\ninteractions with a web server.\n\nThe representation of the bytes flowing across is extensible via the use of a type class,\nletting you pick the representation of requests and responses that best fits your use.\nSome pre-packaged, common instances are provided for you (@ByteString@, @String@).\n\nHere's an example use:\n\n>\n> do\n> rsp <- Network.HTTP.simpleHTTP (getRequest \"http://www.haskell.org/\")\n> -- fetch document and return it (as a 'String'.)\n> fmap (take 100) (getResponseBody rsp)\n>\n> do\n> (_, rsp)\n> <- Network.Browser.browse $ do\n> setAllowRedirects True -- handle HTTP redirects\n> request $ getRequest \"http://www.haskell.org/\"\n> return (take 100 (rspBody rsp))\n\n__Note:__ This package does not support HTTPS connections.\nIf you need HTTPS, take a look at the following packages:\n\n* \n\n* (in combination with\n)\n\n* \n\n* \n"; + buildType = "Simple"; + }; + components = { + "library" = { + depends = ([ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."parsec" or (errorHandler.buildDepError "parsec")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + (hsPkgs."network" or (errorHandler.buildDepError "network")) + ] ++ (if flags.network-uri + then [ + (hsPkgs."network-uri" or (errorHandler.buildDepError "network-uri")) + (hsPkgs."network" or (errorHandler.buildDepError "network")) + ] + else [ + (hsPkgs."network" or (errorHandler.buildDepError "network")) + ])) ++ (pkgs.lib).optional (system.isWindows) (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")); + buildable = true; + }; + tests = { + "test" = { + depends = ([ + (hsPkgs."HTTP" or (errorHandler.buildDepError "HTTP")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + (hsPkgs."network" or (errorHandler.buildDepError "network")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."httpd-shed" or (errorHandler.buildDepError "httpd-shed")) + (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) + (hsPkgs."pureMD5" or (errorHandler.buildDepError "pureMD5")) + (hsPkgs."split" or (errorHandler.buildDepError "split")) + (hsPkgs."test-framework" or (errorHandler.buildDepError "test-framework")) + (hsPkgs."test-framework-hunit" or (errorHandler.buildDepError "test-framework-hunit")) + ] ++ (if flags.network-uri + then [ + (hsPkgs."network-uri" or (errorHandler.buildDepError "network-uri")) + (hsPkgs."network" or (errorHandler.buildDepError "network")) + ] + else [ + (hsPkgs."network" or (errorHandler.buildDepError "network")) + ])) ++ (pkgs.lib).optionals (flags.warp-tests) ([ + (hsPkgs."case-insensitive" or (errorHandler.buildDepError "case-insensitive")) + (hsPkgs."conduit" or (errorHandler.buildDepError "conduit")) + (hsPkgs."http-types" or (errorHandler.buildDepError "http-types")) + (hsPkgs."wai" or (errorHandler.buildDepError "wai")) + (hsPkgs."warp" or (errorHandler.buildDepError "warp")) + ] ++ (if flags.conduit10 + then [ + (hsPkgs."conduit" or (errorHandler.buildDepError "conduit")) + ] + else [ + (hsPkgs."conduit" or (errorHandler.buildDepError "conduit")) + (hsPkgs."conduit-extra" or (errorHandler.buildDepError "conduit-extra")) + ])); + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/HTTP-4000.4.1.tar.gz"; + sha256 = "df31d8efec775124dab856d7177ddcba31be9f9e0836ebdab03d94392f2dd453"; + }); + }) // { + package-description-override = "Cabal-Version: >= 1.10\nName: HTTP\nVersion: 4000.4.1\nx-revision: 1\nBuild-type: Simple\nLicense: BSD3\nLicense-file: LICENSE\nAuthor: Warrick Gray \nMaintainer: Ganesh Sittampalam \nHomepage: https://github.com/haskell/HTTP\nCategory: Network\nSynopsis: A library for client-side HTTP\nDescription:\n\n The HTTP package supports client-side web programming in Haskell. It lets you set up\n HTTP connections, transmitting requests and processing the responses coming back, all\n from within the comforts of Haskell. It's dependent on the network package to operate,\n but other than that, the implementation is all written in Haskell.\n .\n A basic API for issuing single HTTP requests + receiving responses is provided. On top\n of that, a session-level abstraction is also on offer (the @BrowserAction@ monad);\n it taking care of handling the management of persistent connections, proxies,\n state (cookies) and authentication credentials required to handle multi-step\n interactions with a web server.\n .\n The representation of the bytes flowing across is extensible via the use of a type class,\n letting you pick the representation of requests and responses that best fits your use.\n Some pre-packaged, common instances are provided for you (@ByteString@, @String@).\n .\n Here's an example use:\n .\n >\n > do\n > rsp <- Network.HTTP.simpleHTTP (getRequest \"http://www.haskell.org/\")\n > -- fetch document and return it (as a 'String'.)\n > fmap (take 100) (getResponseBody rsp)\n >\n > do\n > (_, rsp)\n > <- Network.Browser.browse $ do\n > setAllowRedirects True -- handle HTTP redirects\n > request $ getRequest \"http://www.haskell.org/\"\n > return (take 100 (rspBody rsp))\n .\n __Note:__ This package does not support HTTPS connections.\n If you need HTTPS, take a look at the following packages:\n .\n * \n .\n * (in combination with\n )\n .\n * \n .\n * \n .\n\nExtra-Source-Files: CHANGES\n\ntested-with:\n GHC==9.2.1, GHC==9.0.1,\n GHC==8.10.7, GHC==8.8.4, GHC==8.6.5, GHC==8.4.4, GHC==8.2.2, GHC==8.0.2,\n GHC==7.10.3, GHC==7.8.4, GHC==7.6.3\n\nSource-Repository head\n type: git\n location: https://github.com/haskell/HTTP.git\n\nFlag warn-as-error\n default: False\n description: Build with warnings-as-errors\n manual: True\n\nFlag conduit10\n description: Use version 1.0.x or below of the conduit package (for the test suite)\n default: False\n\nFlag warp-tests\n description: Test against warp\n default: False\n manual: True\n\nflag network-uri\n description: Get Network.URI from the network-uri package\n default: True\n\nLibrary\n Exposed-modules:\n Network.BufferType,\n Network.Stream,\n Network.StreamDebugger,\n Network.StreamSocket,\n Network.TCP,\n Network.HTTP,\n Network.HTTP.Headers,\n Network.HTTP.Base,\n Network.HTTP.Stream,\n Network.HTTP.Auth,\n Network.HTTP.Cookie,\n Network.HTTP.Proxy,\n Network.HTTP.HandleStream,\n Network.Browser\n Other-modules:\n Network.HTTP.Base64,\n Network.HTTP.MD5Aux,\n Network.HTTP.Utils\n Paths_HTTP\n GHC-options: -fwarn-missing-signatures -Wall\n\n -- note the test harness constraints should be kept in sync with these\n -- where dependencies are shared\n build-depends:\n base >= 4.6.0.0 && < 4.18\n , array >= 0.3.0.2 && < 0.6\n , bytestring >= 0.9.1.5 && < 0.12\n , parsec >= 2.0 && < 3.2\n , time >= 1.1.2.3 && < 1.13\n , transformers >= 0.2.0.0 && < 0.7\n -- transformers-0.2.0.0 is the first to have Control.Monad.IO.Class\n -- The following dependencies are refined by flags, but they should\n -- still be mentioned here on the top-level.\n , mtl >= 2.0.0.0 && < 2.4\n , network >= 2.4 && < 3.2\n\n default-language: Haskell98\n default-extensions: FlexibleInstances\n\n if flag(network-uri)\n Build-depends: network-uri == 2.6.*, network >= 2.6\n else\n Build-depends: network < 2.6\n\n if flag(warn-as-error)\n ghc-options: -Werror\n\n if os(windows)\n Build-depends: Win32 >= 2.2.0.0 && < 2.14\n\nTest-Suite test\n type: exitcode-stdio-1.0\n\n default-language: Haskell98\n hs-source-dirs: test\n main-is: httpTests.hs\n\n other-modules:\n Httpd\n UnitTests\n\n ghc-options: -Wall\n\n build-depends:\n HTTP\n -- constraints inherited from HTTP\n , base\n , bytestring\n , mtl\n , network\n -- extra dependencies\n , deepseq >= 1.3.0.0 && < 1.5\n , httpd-shed >= 0.4 && < 0.5\n , HUnit >= 1.2.0.1 && < 1.7\n , pureMD5 >= 0.2.4 && < 2.2\n , split >= 0.1.3 && < 0.3\n , test-framework >= 0.2.0 && < 0.9\n , test-framework-hunit >= 0.3.0 && < 0.4\n\n if flag(network-uri)\n Build-depends: network-uri == 2.6.*, network >= 2.6\n else\n Build-depends: network < 2.6\n\n if flag(warp-tests)\n CPP-Options: -DWARP_TESTS\n build-depends:\n case-insensitive >= 0.4.0.1 && < 1.3\n , conduit >= 1.0.8 && < 1.4\n , http-types >= 0.8.0 && < 1.0\n , wai >= 2.1.0 && < 3.3\n , warp >= 2.1.0 && < 3.4\n\n if flag(conduit10)\n build-depends: conduit < 1.1\n else\n build-depends: conduit >= 1.1, conduit-extra >= 1.1 && < 1.4\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/async.nix b/materialized/ghc927/cabal-install/cabal-files/async.nix new file mode 100644 index 0000000000..7dddda914b --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/async.nix @@ -0,0 +1,81 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = { bench = false; }; + package = { + specVersion = "1.10"; + identifier = { name = "async"; version = "2.2.4"; }; + license = "BSD-3-Clause"; + copyright = "(c) Simon Marlow 2012"; + maintainer = "Simon Marlow "; + author = "Simon Marlow"; + homepage = "https://github.com/simonmar/async"; + url = ""; + synopsis = "Run IO operations asynchronously and wait for their results"; + description = "This package provides a higher-level interface over\nthreads, in which an @Async a@ is a concurrent\nthread that will eventually deliver a value of\ntype @a@. The package provides ways to create\n@Async@ computations, wait for their results, and\ncancel them.\n\nUsing @Async@ is safer than using threads in two\nways:\n\n* When waiting for a thread to return a result,\nif the thread dies with an exception then the\ncaller must either re-throw the exception\n('wait') or handle it ('waitCatch'); the\nexception cannot be ignored.\n\n* The API makes it possible to build a tree of\nthreads that are automatically killed when\ntheir parent dies (see 'withAsync')."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."stm" or (errorHandler.buildDepError "stm")) + ]; + buildable = true; + }; + exes = { + "concasync" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."async" or (errorHandler.buildDepError "async")) + (hsPkgs."stm" or (errorHandler.buildDepError "stm")) + ]; + buildable = if !flags.bench then false else true; + }; + "conccancel" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."async" or (errorHandler.buildDepError "async")) + (hsPkgs."stm" or (errorHandler.buildDepError "stm")) + ]; + buildable = if !flags.bench then false else true; + }; + "race" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."async" or (errorHandler.buildDepError "async")) + (hsPkgs."stm" or (errorHandler.buildDepError "stm")) + ]; + buildable = if !flags.bench then false else true; + }; + }; + tests = { + "test-async" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."async" or (errorHandler.buildDepError "async")) + (hsPkgs."stm" or (errorHandler.buildDepError "stm")) + (hsPkgs."test-framework" or (errorHandler.buildDepError "test-framework")) + (hsPkgs."test-framework-hunit" or (errorHandler.buildDepError "test-framework-hunit")) + (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/async-2.2.4.tar.gz"; + sha256 = "484df85be0e76c4fed9376451e48e1d0c6e97952ce79735b72d54297e7e0a725"; + }); + }) // { + package-description-override = "name: async\nversion: 2.2.4\n-- don't forget to update ./changelog.md!\nx-revision: 2\nsynopsis: Run IO operations asynchronously and wait for their results\n\ndescription:\n This package provides a higher-level interface over\n threads, in which an @Async a@ is a concurrent\n thread that will eventually deliver a value of\n type @a@. The package provides ways to create\n @Async@ computations, wait for their results, and\n cancel them.\n .\n Using @Async@ is safer than using threads in two\n ways:\n .\n * When waiting for a thread to return a result,\n if the thread dies with an exception then the\n caller must either re-throw the exception\n ('wait') or handle it ('waitCatch'); the\n exception cannot be ignored.\n .\n * The API makes it possible to build a tree of\n threads that are automatically killed when\n their parent dies (see 'withAsync').\n\nlicense: BSD3\nlicense-file: LICENSE\nauthor: Simon Marlow\nmaintainer: Simon Marlow \ncopyright: (c) Simon Marlow 2012\ncategory: Concurrency\nbuild-type: Simple\ncabal-version: >=1.10\nhomepage: https://github.com/simonmar/async\nbug-reports: https://github.com/simonmar/async/issues\ntested-with:\n GHC == 9.4.1\n GHC == 9.2.4\n GHC == 9.0.2\n GHC == 8.10.7\n GHC == 8.8.4\n GHC == 8.6.5\n GHC == 8.4.4\n GHC == 8.2.2\n GHC == 8.0.2\n GHC == 7.10.3\n GHC == 7.8.4\n GHC == 7.6.3\n GHC == 7.4.2\n GHC == 7.2.2\n GHC == 7.0.4\n\nextra-source-files:\n changelog.md\n bench/race.hs\n\nsource-repository head\n type: git\n location: https://github.com/simonmar/async.git\n\nlibrary\n default-language: Haskell2010\n other-extensions: CPP, MagicHash, RankNTypes, UnboxedTuples\n if impl(ghc>=7.1)\n other-extensions: Trustworthy\n exposed-modules: Control.Concurrent.Async\n build-depends: base >= 4.3 && < 4.18,\n hashable >= 1.1.2.0 && < 1.5,\n stm >= 2.2 && < 2.6\n\ntest-suite test-async\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n hs-source-dirs: test\n main-is: test-async.hs\n build-depends: base,\n async,\n stm,\n test-framework,\n test-framework-hunit,\n HUnit\n\nflag bench\n default: False\n\nexecutable concasync\n if !flag(bench)\n buildable: False\n default-language: Haskell2010\n hs-source-dirs: bench\n main-is: concasync.hs\n build-depends: base, async, stm\n ghc-options: -O2\n\nexecutable conccancel\n if !flag(bench)\n buildable: False\n default-language: Haskell2010\n hs-source-dirs: bench\n main-is: conccancel.hs\n build-depends: base, async, stm\n ghc-options: -O2 -threaded\n\nexecutable race\n if !flag(bench)\n buildable: False\n default-language: Haskell2010\n hs-source-dirs: bench\n main-is: race.hs\n build-depends: base, async, stm\n ghc-options: -O2 -threaded\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/base16-bytestring.nix b/materialized/ghc927/cabal-install/cabal-files/base16-bytestring.nix new file mode 100644 index 0000000000..31d3b31c55 --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/base16-bytestring.nix @@ -0,0 +1,68 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "1.12"; + identifier = { name = "base16-bytestring"; version = "1.0.2.0"; }; + license = "BSD-3-Clause"; + copyright = "Copyright 2011 MailRank, Inc.;\nCopyright 2010-2020 Bryan O'Sullivan et al."; + maintainer = "Herbert Valerio Riedel ,\nMikhail Glushenkov ,\nEmily Pillmore "; + author = "Bryan O'Sullivan "; + homepage = "http://github.com/haskell/base16-bytestring"; + url = ""; + synopsis = "RFC 4648-compliant Base16 encodings for ByteStrings"; + description = "This package provides support for encoding and decoding binary data according\nto @base16@ (see also ) for\nstrict (see \"Data.ByteString.Base16\") and lazy @ByteString@s (see \"Data.ByteString.Base16.Lazy\").\n\nSee the package which provides superior encoding and decoding performance as well as support for lazy, short, and strict variants of 'Text' and 'ByteString' values. Additionally, see the package which\nprovides an uniform API providing conversion paths between more binary and textual types."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + ]; + buildable = true; + }; + tests = { + "test" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."base16-bytestring" or (errorHandler.buildDepError "base16-bytestring")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."test-framework" or (errorHandler.buildDepError "test-framework")) + (hsPkgs."test-framework-hunit" or (errorHandler.buildDepError "test-framework-hunit")) + (hsPkgs."test-framework-quickcheck2" or (errorHandler.buildDepError "test-framework-quickcheck2")) + ]; + buildable = true; + }; + }; + benchmarks = { + "bench" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."base16-bytestring" or (errorHandler.buildDepError "base16-bytestring")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."criterion" or (errorHandler.buildDepError "criterion")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/base16-bytestring-1.0.2.0.tar.gz"; + sha256 = "1d5a91143ef0e22157536093ec8e59d226a68220ec89378d5dcaeea86472c784"; + }); + }) // { + package-description-override = "cabal-version: 1.12\nname: base16-bytestring\nversion: 1.0.2.0\nsynopsis: RFC 4648-compliant Base16 encodings for ByteStrings\ndescription:\n This package provides support for encoding and decoding binary data according\n to @base16@ (see also ) for\n strict (see \"Data.ByteString.Base16\") and lazy @ByteString@s (see \"Data.ByteString.Base16.Lazy\").\n .\n See the package which provides superior encoding and decoding performance as well as support for lazy, short, and strict variants of 'Text' and 'ByteString' values. Additionally, see the package which\n provides an uniform API providing conversion paths between more binary and textual types.\n\nhomepage: http://github.com/haskell/base16-bytestring\nbug-reports: http://github.com/haskell/base16-bytestring/issues\nlicense: BSD3\nlicense-file: LICENSE\ncopyright:\n Copyright 2011 MailRank, Inc.;\n Copyright 2010-2020 Bryan O'Sullivan et al.\n\nauthor: Bryan O'Sullivan \nmaintainer:\n Herbert Valerio Riedel ,\n Mikhail Glushenkov ,\n Emily Pillmore \n\ncategory: Data\nbuild-type: Simple\nextra-source-files:\n README.md\n CHANGELOG.md\n\ntested-with:\n GHC ==8.0.2\n || ==8.2.2\n || ==8.4.4\n || ==8.6.5\n || ==8.8.4\n || ==8.10.4\n || ==9.0.1\n\nsource-repository head\n type: git\n location: http://github.com/haskell/base16-bytestring\n\nlibrary\n other-modules: Data.ByteString.Base16.Internal\n exposed-modules:\n Data.ByteString.Base16\n Data.ByteString.Base16.Lazy\n\n build-depends:\n base >=4.9 && <5\n , bytestring >=0.9 && <0.12\n\n ghc-options: -Wall -funbox-strict-fields\n default-language: Haskell2010\n\ntest-suite test\n type: exitcode-stdio-1.0\n hs-source-dirs: tests\n main-is: Tests.hs\n build-depends:\n base\n , base16-bytestring\n , bytestring\n , HUnit\n , QuickCheck\n , test-framework\n , test-framework-hunit\n , test-framework-quickcheck2\n\n default-language: Haskell2010\n\nbenchmark bench\n type: exitcode-stdio-1.0\n hs-source-dirs: benchmarks\n main-is: Benchmarks.hs\n build-depends:\n base >=4 && <5\n , base16-bytestring\n , bytestring\n , criterion\n , deepseq\n\n default-language: Haskell2010\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/base64-bytestring.nix b/materialized/ghc927/cabal-install/cabal-files/base64-bytestring.nix new file mode 100644 index 0000000000..4149848da2 --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/base64-bytestring.nix @@ -0,0 +1,68 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "1.12"; + identifier = { name = "base64-bytestring"; version = "1.2.1.0"; }; + license = "BSD-3-Clause"; + copyright = "2010-2020 Bryan O'Sullivan et al."; + maintainer = "Herbert Valerio Riedel ,\nMikhail Glushenkov ,\nEmily Pillmore "; + author = "Bryan O'Sullivan "; + homepage = "https://github.com/haskell/base64-bytestring"; + url = ""; + synopsis = "Fast base64 encoding and decoding for ByteStrings"; + description = "This package provides support for encoding and decoding binary data according to @base64@ (see also ) for strict and lazy ByteStrings\n\nFor a fuller-featured and better-performing Base64 library, see the package."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + ]; + buildable = true; + }; + tests = { + "test" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."base64-bytestring" or (errorHandler.buildDepError "base64-bytestring")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."test-framework" or (errorHandler.buildDepError "test-framework")) + (hsPkgs."test-framework-hunit" or (errorHandler.buildDepError "test-framework-hunit")) + (hsPkgs."test-framework-quickcheck2" or (errorHandler.buildDepError "test-framework-quickcheck2")) + ]; + buildable = true; + }; + }; + benchmarks = { + "benchmarks" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."base64-bytestring" or (errorHandler.buildDepError "base64-bytestring")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."criterion" or (errorHandler.buildDepError "criterion")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/base64-bytestring-1.2.1.0.tar.gz"; + sha256 = "fbf8ed30edde271eb605352021431d8f1b055f95a56af31fe2eacf6bdfdc49c9"; + }); + }) // { + package-description-override = "cabal-version: 1.12\nname: base64-bytestring\nversion: 1.2.1.0\nsynopsis: Fast base64 encoding and decoding for ByteStrings\ndescription:\n This package provides support for encoding and decoding binary data according to @base64@ (see also ) for strict and lazy ByteStrings\n .\n For a fuller-featured and better-performing Base64 library, see the package.\n\nhomepage: https://github.com/haskell/base64-bytestring\nbug-reports: https://github.com/haskell/base64-bytestring/issues\nlicense: BSD3\nlicense-file: LICENSE\nauthor: Bryan O'Sullivan \nmaintainer:\n Herbert Valerio Riedel ,\n Mikhail Glushenkov ,\n Emily Pillmore \n\ncopyright: 2010-2020 Bryan O'Sullivan et al.\ncategory: Data\nbuild-type: Simple\ntested-with:\n GHC ==7.0.4\n || ==7.2.2\n || ==7.4.2\n || ==7.6.3\n || ==7.8.4\n || ==7.10.3\n || ==8.0.2\n || ==8.2.2\n || ==8.4.4\n || ==8.6.5\n || ==8.8.4\n || ==8.10.5\n\nextra-source-files:\n README.md\n CHANGELOG.md\n utils/Transcode.hs\n utils/transcode.py\n\nlibrary\n exposed-modules:\n Data.ByteString.Base64\n Data.ByteString.Base64.Lazy\n Data.ByteString.Base64.URL\n Data.ByteString.Base64.URL.Lazy\n\n other-modules: Data.ByteString.Base64.Internal\n build-depends:\n base >=4 && <5\n , bytestring >=0.9 && <0.12\n\n ghc-options: -Wall -funbox-strict-fields\n default-language: Haskell2010\n\ntest-suite test\n type: exitcode-stdio-1.0\n hs-source-dirs: tests\n main-is: Tests.hs\n ghc-options: -Wall -threaded -rtsopts\n build-depends:\n base\n , base64-bytestring\n , bytestring\n , HUnit\n , QuickCheck\n , test-framework\n , test-framework-hunit\n , test-framework-quickcheck2\n\n default-language: Haskell2010\n\nbenchmark benchmarks\n type: exitcode-stdio-1.0\n hs-source-dirs: benchmarks\n main-is: BM.hs\n ghc-options: -Wall -threaded -rtsopts\n build-depends:\n base\n , base64-bytestring\n , bytestring\n , criterion\n , deepseq >=1.1\n\n default-language: Haskell2010\n\nsource-repository head\n type: git\n location: git://github.com/haskell/base64-bytestring\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/cabal-install-solver.nix b/materialized/ghc927/cabal-install/cabal-files/cabal-install-solver.nix new file mode 100644 index 0000000000..86b24243b4 --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/cabal-install-solver.nix @@ -0,0 +1,68 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = { + debug-expensive-assertions = false; + debug-conflict-sets = false; + debug-tracetree = false; + }; + package = { + specVersion = "2.2"; + identifier = { name = "cabal-install-solver"; version = "3.8.1.0"; }; + license = "BSD-3-Clause"; + copyright = "2003-2022, Cabal Development Team"; + maintainer = "Cabal Development Team "; + author = "Cabal Development Team (see AUTHORS file)"; + homepage = "http://www.haskell.org/cabal/"; + url = ""; + synopsis = "The command-line interface for Cabal and Hackage."; + description = "The solver component used in cabal-install command-line program"; + buildType = "Simple"; + }; + components = { + "library" = { + depends = ([ + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal")) + (hsPkgs."Cabal-syntax" or (errorHandler.buildDepError "Cabal-syntax")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."edit-distance" or (errorHandler.buildDepError "edit-distance")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + (hsPkgs."pretty" or (errorHandler.buildDepError "pretty")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + ] ++ (pkgs.lib).optional (flags.debug-conflict-sets) (hsPkgs."base" or (errorHandler.buildDepError "base"))) ++ (pkgs.lib).optional (flags.debug-tracetree) (hsPkgs."tracetree" or (errorHandler.buildDepError "tracetree")); + buildable = true; + }; + tests = { + "unit-tests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal")) + (hsPkgs."Cabal-syntax" or (errorHandler.buildDepError "Cabal-syntax")) + (hsPkgs."cabal-install-solver" or (errorHandler.buildDepError "cabal-install-solver")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/cabal-install-solver-3.8.1.0.tar.gz"; + sha256 = "df2369f6c37517a3b2625bc19057d9e206bbb40386bcb607f17dc7d2e588ffe7"; + }); + }) // { + package-description-override = "cabal-version: 2.2\r\nname: cabal-install-solver\r\nversion: 3.8.1.0\r\nx-revision: 1\r\nsynopsis: The command-line interface for Cabal and Hackage.\r\ndescription:\r\n The solver component used in cabal-install command-line program\r\n\r\nhomepage: http://www.haskell.org/cabal/\r\nbug-reports: https://github.com/haskell/cabal/issues\r\nlicense: BSD-3-Clause\r\nlicense-file: LICENSE\r\nauthor: Cabal Development Team (see AUTHORS file)\r\nmaintainer: Cabal Development Team \r\ncopyright: 2003-2022, Cabal Development Team\r\ncategory: Distribution\r\nbuild-type: Simple\r\nExtra-Source-Files:\r\n ChangeLog.md\r\n\r\nsource-repository head\r\n type: git\r\n location: https://github.com/haskell/cabal/\r\n subdir: cabal-install-solver\r\n\r\nflag debug-expensive-assertions\r\n description: Enable expensive assertions for testing or debugging\r\n default: False\r\n manual: True\r\n\r\nflag debug-conflict-sets\r\n description: Add additional information to ConflictSets\r\n default: False\r\n manual: True\r\n\r\nflag debug-tracetree\r\n description: Compile in support for tracetree (used to debug the solver)\r\n default: False\r\n manual: True\r\n\r\nlibrary\r\n default-language: Haskell2010\r\n hs-source-dirs: src\r\n hs-source-dirs: src-assertion\r\n ghc-options:\r\n -Wall -Wcompat -Wnoncanonical-monad-instances\r\n -fwarn-tabs -fwarn-incomplete-uni-patterns\r\n\r\n if impl(ghc <8.8)\r\n ghc-options: -Wnoncanonical-monadfail-instances\r\n if impl(ghc >=8.10)\r\n ghc-options: -Wunused-packages\r\n\r\n exposed-modules:\r\n Distribution.Client.Utils.Assertion\r\n\r\n Distribution.Solver.Compat.Prelude\r\n Distribution.Solver.Modular\r\n Distribution.Solver.Modular.Assignment\r\n Distribution.Solver.Modular.Builder\r\n Distribution.Solver.Modular.Configured\r\n Distribution.Solver.Modular.ConfiguredConversion\r\n Distribution.Solver.Modular.ConflictSet\r\n Distribution.Solver.Modular.Cycles\r\n Distribution.Solver.Modular.Dependency\r\n Distribution.Solver.Modular.Explore\r\n Distribution.Solver.Modular.Flag\r\n Distribution.Solver.Modular.Index\r\n Distribution.Solver.Modular.IndexConversion\r\n Distribution.Solver.Modular.LabeledGraph\r\n Distribution.Solver.Modular.Linking\r\n Distribution.Solver.Modular.Log\r\n Distribution.Solver.Modular.Message\r\n Distribution.Solver.Modular.MessageUtils\r\n Distribution.Solver.Modular.Package\r\n Distribution.Solver.Modular.Preference\r\n Distribution.Solver.Modular.PSQ\r\n Distribution.Solver.Modular.RetryLog\r\n Distribution.Solver.Modular.Solver\r\n Distribution.Solver.Modular.Tree\r\n Distribution.Solver.Modular.Validate\r\n Distribution.Solver.Modular.Var\r\n Distribution.Solver.Modular.Version\r\n Distribution.Solver.Modular.WeightedPSQ\r\n Distribution.Solver.Types.ComponentDeps\r\n Distribution.Solver.Types.ConstraintSource\r\n Distribution.Solver.Types.DependencyResolver\r\n Distribution.Solver.Types.Flag\r\n Distribution.Solver.Types.InstalledPreference\r\n Distribution.Solver.Types.InstSolverPackage\r\n Distribution.Solver.Types.LabeledPackageConstraint\r\n Distribution.Solver.Types.OptionalStanza\r\n Distribution.Solver.Types.PackageConstraint\r\n Distribution.Solver.Types.PackageFixedDeps\r\n Distribution.Solver.Types.PackageIndex\r\n Distribution.Solver.Types.PackagePath\r\n Distribution.Solver.Types.PackagePreferences\r\n Distribution.Solver.Types.PkgConfigDb\r\n Distribution.Solver.Types.Progress\r\n Distribution.Solver.Types.ResolverPackage\r\n Distribution.Solver.Types.Settings\r\n Distribution.Solver.Types.SolverId\r\n Distribution.Solver.Types.SolverPackage\r\n Distribution.Solver.Types.SourcePackage\r\n Distribution.Solver.Types.Variable\r\n\r\n build-depends:\r\n , array >=0.4 && <0.6\r\n , base >=4.10 && <4.18\r\n , bytestring >=0.10.6.0 && <0.12\r\n , Cabal ^>=3.8\r\n , Cabal-syntax ^>=3.8\r\n , containers >=0.5.6.2 && <0.7\r\n , edit-distance ^>= 0.2.2\r\n , filepath ^>=1.4.0.0\r\n , mtl >=2.0 && <2.3\r\n , pretty ^>=1.1\r\n , transformers >=0.4.2.0 && <0.6\r\n\r\n if flag(debug-expensive-assertions)\r\n cpp-options: -DDEBUG_EXPENSIVE_ASSERTIONS\r\n\r\n if flag(debug-conflict-sets)\r\n cpp-options: -DDEBUG_CONFLICT_SETS\r\n build-depends: base >=4.8\r\n\r\n if flag(debug-tracetree)\r\n cpp-options: -DDEBUG_TRACETREE\r\n build-depends: tracetree ^>=0.1\r\n\r\nTest-Suite unit-tests\r\n default-language: Haskell2010\r\n ghc-options: -rtsopts -threaded\r\n\r\n type: exitcode-stdio-1.0\r\n main-is: UnitTests.hs\r\n hs-source-dirs: tests\r\n other-modules:\r\n UnitTests.Distribution.Solver.Modular.MessageUtils\r\n\r\n build-depends:\r\n , base >= 4.10 && <4.18\r\n , Cabal\r\n , Cabal-syntax\r\n , cabal-install-solver\r\n , tasty >= 1.2.3 && <1.5\r\n , tasty-quickcheck\r\n , tasty-hunit >= 0.10\r\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/cryptohash-sha256.nix b/materialized/ghc927/cabal-install/cabal-files/cryptohash-sha256.nix new file mode 100644 index 0000000000..ac11267e42 --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/cryptohash-sha256.nix @@ -0,0 +1,84 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = { exe = false; use-cbits = true; }; + package = { + specVersion = "2.0"; + identifier = { name = "cryptohash-sha256"; version = "0.11.102.1"; }; + license = "BSD-3-Clause"; + copyright = "Vincent Hanquez, Herbert Valerio Riedel"; + maintainer = "Herbert Valerio Riedel "; + author = ""; + homepage = "https://github.com/hvr/cryptohash-sha256"; + url = ""; + synopsis = "Fast, pure and practical SHA-256 implementation"; + description = "A practical incremental and one-pass, pure API to\nthe [SHA-256 cryptographic hash algorithm](https://en.wikipedia.org/wiki/SHA-2) according\nto [FIPS 180-4](http://dx.doi.org/10.6028/NIST.FIPS.180-4)\nwith performance close to the fastest implementations available in other languages.\n\nThe core SHA-256 algorithm is implemented in C and is thus expected\nto be as fast as the standard [sha256sum(1) tool](https://linux.die.net/man/1/sha256sum);\nfor instance, on an /Intel Core i7-3770/ at 3.40GHz this implementation can\ncompute a SHA-256 hash over 230 MiB of data in under one second.\n(If, instead, you require a pure Haskell implementation and performance is secondary, please refer to the [SHA package](https://hackage.haskell.org/package/SHA).)\n\n\nAdditionally, this package provides support for\n\n- HMAC-SHA-256: SHA-256-based [Hashed Message Authentication Codes](https://en.wikipedia.org/wiki/HMAC) (HMAC)\n- HKDF-SHA-256: [HMAC-SHA-256-based Key Derivation Function](https://en.wikipedia.org/wiki/HKDF) (HKDF)\n\nconforming to [RFC6234](https://tools.ietf.org/html/rfc6234), [RFC4231](https://tools.ietf.org/html/rfc4231), [RFC5869](https://tools.ietf.org/html/rfc5869), et al..\n\n=== Relationship to the @cryptohash@ package and its API\n\nThis package has been originally a fork of @cryptohash-0.11.7@ because the @cryptohash@\npackage had been deprecated and so this package continues to satisfy the need for a\nlightweight package providing the SHA-256 hash algorithm without any dependencies on packages\nother than @base@ and @bytestring@. The API exposed by @cryptohash-sha256-0.11.*@'s\n\"Crypto.Hash.SHA256\" module is guaranteed to remain a compatible superset of the API provided\nby the @cryptohash-0.11.7@'s module of the same name.\n\nConsequently, this package is designed to be used as a drop-in replacement for @cryptohash-0.11.7@'s\n\"Crypto.Hash.SHA256\" module, though with\na [clearly smaller footprint by almost 3 orders of magnitude](https://www.reddit.com/r/haskell/comments/5lxv75/psa_please_use_unique_module_names_when_uploading/dbzegx3/)."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + ] ++ (if flags.use-cbits + then [ + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + ] + else [ + (hsPkgs."cryptohash-sha256-pure" or (errorHandler.buildDepError "cryptohash-sha256-pure")) + ]); + buildable = true; + }; + exes = { + "sha256sum" = { + depends = (pkgs.lib).optionals (flags.exe) [ + (hsPkgs."cryptohash-sha256" or (errorHandler.buildDepError "cryptohash-sha256")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."base16-bytestring" or (errorHandler.buildDepError "base16-bytestring")) + ]; + buildable = if flags.exe then true else false; + }; + }; + tests = { + "test-sha256" = { + depends = [ + (hsPkgs."cryptohash-sha256" or (errorHandler.buildDepError "cryptohash-sha256")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."base16-bytestring" or (errorHandler.buildDepError "base16-bytestring")) + (hsPkgs."SHA" or (errorHandler.buildDepError "SHA")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + ]; + buildable = true; + }; + }; + benchmarks = { + "bench-sha256" = { + depends = [ + (hsPkgs."cryptohash-sha256" or (errorHandler.buildDepError "cryptohash-sha256")) + (hsPkgs."SHA" or (errorHandler.buildDepError "SHA")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."criterion" or (errorHandler.buildDepError "criterion")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/cryptohash-sha256-0.11.102.1.tar.gz"; + sha256 = "73a7dc7163871a80837495039a099967b11f5c4fe70a118277842f7a713c6bf6"; + }); + }) // { + package-description-override = "cabal-version: 2.0\nname: cryptohash-sha256\nversion: 0.11.102.1\nx-revision: 1\n\nsynopsis: Fast, pure and practical SHA-256 implementation\ndescription: {\n\nA practical incremental and one-pass, pure API to\nthe [SHA-256 cryptographic hash algorithm](https://en.wikipedia.org/wiki/SHA-2) according\nto [FIPS 180-4](http://dx.doi.org/10.6028/NIST.FIPS.180-4)\nwith performance close to the fastest implementations available in other languages.\n.\nThe core SHA-256 algorithm is implemented in C and is thus expected\nto be as fast as the standard [sha256sum(1) tool](https://linux.die.net/man/1/sha256sum);\nfor instance, on an /Intel Core i7-3770/ at 3.40GHz this implementation can\ncompute a SHA-256 hash over 230 MiB of data in under one second.\n(If, instead, you require a pure Haskell implementation and performance is secondary, please refer to the [SHA package](https://hackage.haskell.org/package/SHA).)\n.\n\n.\nAdditionally, this package provides support for\n.\n- HMAC-SHA-256: SHA-256-based [Hashed Message Authentication Codes](https://en.wikipedia.org/wiki/HMAC) (HMAC)\n- HKDF-SHA-256: [HMAC-SHA-256-based Key Derivation Function](https://en.wikipedia.org/wiki/HKDF) (HKDF)\n.\nconforming to [RFC6234](https://tools.ietf.org/html/rfc6234), [RFC4231](https://tools.ietf.org/html/rfc4231), [RFC5869](https://tools.ietf.org/html/rfc5869), et al..\n.\n=== Relationship to the @cryptohash@ package and its API\n.\nThis package has been originally a fork of @cryptohash-0.11.7@ because the @cryptohash@\npackage had been deprecated and so this package continues to satisfy the need for a\nlightweight package providing the SHA-256 hash algorithm without any dependencies on packages\nother than @base@ and @bytestring@. The API exposed by @cryptohash-sha256-0.11.*@'s\n\"Crypto.Hash.SHA256\" module is guaranteed to remain a compatible superset of the API provided\nby the @cryptohash-0.11.7@'s module of the same name.\n.\nConsequently, this package is designed to be used as a drop-in replacement for @cryptohash-0.11.7@'s\n\"Crypto.Hash.SHA256\" module, though with\na [clearly smaller footprint by almost 3 orders of magnitude](https://www.reddit.com/r/haskell/comments/5lxv75/psa_please_use_unique_module_names_when_uploading/dbzegx3/).\n\n}\n\nlicense: BSD3\nlicense-file: LICENSE\ncopyright: Vincent Hanquez, Herbert Valerio Riedel\nmaintainer: Herbert Valerio Riedel \nhomepage: https://github.com/hvr/cryptohash-sha256\nbug-reports: https://github.com/hvr/cryptohash-sha256/issues\ncategory: Data, Cryptography\nbuild-type: Simple\ntested-with: GHC == 7.4.2\n , GHC == 7.6.3\n , GHC == 7.8.4\n , GHC == 7.10.3\n , GHC == 8.0.2\n , GHC == 8.2.2\n , GHC == 8.4.4\n , GHC == 8.6.5\n , GHC == 8.8.4\n , GHC == 8.10.4\n , GHC == 9.0.2\n , GHC == 9.2.4\n , GHC == 9.4.1\n\n\nextra-source-files: cbits/hs_sha256.h\n changelog.md\n\nsource-repository head\n type: git\n location: https://github.com/hvr/cryptohash-sha256.git\n\nflag exe\n description: Enable building @sha256sum@ executable\n manual: True\n default: False\n\nflag use-cbits\n description: Use fast optimized C routines via FFI; if flag is disabled falls back to non-FFI Haskell optimized implementation.\n manual: True\n default: True\n\nlibrary\n default-language: Haskell2010\n\n ghc-options: -Wall\n\n build-depends: base >= 4.5 && < 4.18\n\n exposed-modules: Crypto.Hash.SHA256\n\n if flag(use-cbits)\n build-depends: bytestring ^>= 0.9.2 || ^>= 0.10.0 || ^>= 0.11.0\n\n other-extensions: BangPatterns\n CApiFFI\n CPP\n Trustworthy\n Unsafe\n\n hs-source-dirs: src\n other-modules: Crypto.Hash.SHA256.FFI\n Compat\n include-dirs: cbits\n else\n hs-source-dirs: src-pure\n build-depends: cryptohash-sha256-pure ^>= 0.1.0\n\nexecutable sha256sum\n default-language: Haskell2010\n hs-source-dirs: src-exe\n main-is: sha256sum.hs\n ghc-options: -Wall -threaded\n if flag(exe)\n other-extensions: RecordWildCards\n build-depends: cryptohash-sha256\n , base\n , bytestring\n\n , base16-bytestring ^>= 0.1.1 || ^>= 1.0.0\n else\n buildable: False\n\ntest-suite test-sha256\n default-language: Haskell2010\n other-extensions: OverloadedStrings\n type: exitcode-stdio-1.0\n hs-source-dirs: src-tests\n main-is: test-sha256.hs\n ghc-options: -Wall -threaded\n build-depends: cryptohash-sha256\n , base\n , bytestring\n\n , base16-bytestring ^>= 0.1.1 || ^>= 1.0.0\n , SHA ^>= 1.6.4\n , tasty ^>= 1.4\n , tasty-quickcheck ^>= 0.10\n , tasty-hunit ^>= 0.10\n\nbenchmark bench-sha256\n default-language: Haskell2010\n other-extensions: BangPatterns\n type: exitcode-stdio-1.0\n main-is: bench-sha256.hs\n hs-source-dirs: src-bench\n build-depends: cryptohash-sha256\n , SHA ^>= 1.6.4\n , base\n , bytestring\n , criterion ^>= 1.5 || ^>=1.6\n\n -- not yet public\n -- build-depends: cryptohash-sha256-pure ^>= 0.1.0\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/echo.nix b/materialized/ghc927/cabal-install/cabal-files/echo.nix new file mode 100644 index 0000000000..580bd5d35d --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/echo.nix @@ -0,0 +1,53 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = { example = false; }; + package = { + specVersion = "1.10"; + identifier = { name = "echo"; version = "0.1.4"; }; + license = "BSD-3-Clause"; + copyright = "(C) 2016-2017 Ryan Scott"; + maintainer = "Ryan Scott "; + author = "Ryan Scott"; + homepage = "https://github.com/RyanGlScott/echo"; + url = ""; + synopsis = "A cross-platform, cross-console way to handle echoing terminal input"; + description = "The @base@ library exposes the @hGetEcho@ and @hSetEcho@ functions\nfor querying and setting echo status, but unfortunately, neither\nfunction works with MinTTY consoles on Windows. This is a serious\nissue, since @hGetEcho@ and @hSetEcho@ are often used to disable\ninput echoing when a program prompts for a password, so many\nprograms will reveal your password as you type it on MinTTY!\n\nThis library provides an alternative interface which works\nwith both MinTTY and other consoles. An example is included\nwhich demonstrates how one might prompt for a password using\nthis library. To build it, make sure to configure with the\n@-fexample@ flag."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + ] ++ (pkgs.lib).optionals (system.isWindows) [ + (hsPkgs."mintty" or (errorHandler.buildDepError "mintty")) + (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) + ]; + buildable = true; + }; + exes = { + "password" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."echo" or (errorHandler.buildDepError "echo")) + ]; + buildable = if !flags.example then false else true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/echo-0.1.4.tar.gz"; + sha256 = "c9fe1bf2904825a65b667251ec644f197b71dc5c209d2d254be5de3d496b0e43"; + }); + }) // { + package-description-override = "name: echo\nversion: 0.1.4\nsynopsis: A cross-platform, cross-console way to handle echoing terminal input\ndescription: The @base@ library exposes the @hGetEcho@ and @hSetEcho@ functions\n for querying and setting echo status, but unfortunately, neither\n function works with MinTTY consoles on Windows. This is a serious\n issue, since @hGetEcho@ and @hSetEcho@ are often used to disable\n input echoing when a program prompts for a password, so many\n programs will reveal your password as you type it on MinTTY!\n .\n This library provides an alternative interface which works\n with both MinTTY and other consoles. An example is included\n which demonstrates how one might prompt for a password using\n this library. To build it, make sure to configure with the\n @-fexample@ flag.\nhomepage: https://github.com/RyanGlScott/echo\nbug-reports: https://github.com/RyanGlScott/echo/issues\nlicense: BSD3\nlicense-file: LICENSE\nauthor: Ryan Scott\nmaintainer: Ryan Scott \nstability: Provisional\ncopyright: (C) 2016-2017 Ryan Scott\ncategory: System\nbuild-type: Simple\nextra-source-files: CHANGELOG.md, README.md\ncabal-version: >=1.10\ntested-with: GHC == 7.0.4\n , GHC == 7.2.2\n , GHC == 7.4.2\n , GHC == 7.6.3\n , GHC == 7.8.4\n , GHC == 7.10.3\n , GHC == 8.0.2\n , GHC == 8.2.2\n , GHC == 8.4.4\n , GHC == 8.6.5\n , GHC == 8.8.4\n , GHC == 8.10.2\n\nsource-repository head\n type: git\n location: https://github.com/RyanGlScott/echo\n\nflag example\n description: Build the bundled example program.\n default: False\n\nlibrary\n exposed-modules: System.IO.Echo\n System.IO.Echo.Internal\n\n build-depends: base >= 4.3 && < 5\n , process >= 1.0.1.1 && < 1.7\n if os(windows)\n cpp-options: \"-DWINDOWS\"\n build-depends: mintty >= 0.1 && < 0.2\n , Win32 >= 2 && < 3\n\n hs-source-dirs: src\n default-language: Haskell2010\n ghc-options: -Wall\n\nexecutable password\n if !flag(example)\n buildable: False\n\n main-is: Password.hs\n build-depends: base >= 4.3 && < 5\n , echo\n hs-source-dirs: example\n default-language: Haskell2010\n ghc-options: -Wall\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/ed25519.nix b/materialized/ghc927/cabal-install/cabal-files/ed25519.nix new file mode 100644 index 0000000000..b2844bd06c --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/ed25519.nix @@ -0,0 +1,86 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = { + test-properties = true; + test-hlint = true; + test-doctests = true; + no-donna = true; + }; + package = { + specVersion = "1.10"; + identifier = { name = "ed25519"; version = "0.0.5.0"; }; + license = "MIT"; + copyright = "Copyright (c) Austin Seipp 2013-2015"; + maintainer = "Austin Seipp "; + author = "Austin Seipp"; + homepage = "http://thoughtpolice.github.com/hs-ed25519"; + url = ""; + synopsis = "Ed25519 cryptographic signatures"; + description = "This package provides a simple, fast, self-contained copy of the\nEd25519 public-key signature system with a clean interface. It also\nincludes support for detached signatures, and thorough documentation\non the design and implementation, including usage guidelines."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + ]; + buildable = if flags.no-donna then true else false; + }; + tests = { + "properties" = { + depends = (pkgs.lib).optionals (!(!flags.test-properties)) [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."ed25519" or (errorHandler.buildDepError "ed25519")) + ]; + buildable = if !flags.test-properties then false else true; + }; + "hlint" = { + depends = (pkgs.lib).optionals (!(!flags.test-hlint)) [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."hlint" or (errorHandler.buildDepError "hlint")) + ]; + buildable = if !flags.test-hlint then false else true; + }; + "doctests" = { + depends = (pkgs.lib).optionals (!(!flags.test-doctests)) [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."doctest" or (errorHandler.buildDepError "doctest")) + ]; + buildable = if !flags.test-doctests then false else true; + }; + }; + benchmarks = { + "bench" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."criterion" or (errorHandler.buildDepError "criterion")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ed25519" or (errorHandler.buildDepError "ed25519")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/ed25519-0.0.5.0.tar.gz"; + sha256 = "d8a5958ebfa9309790efade64275dc5c441b568645c45ceed1b0c6ff36d6156d"; + }); + }) // { + package-description-override = "name: ed25519\r\nversion: 0.0.5.0\r\nx-revision: 6\r\ncategory: Cryptography\r\nlicense: MIT\r\nsynopsis: Ed25519 cryptographic signatures\r\nhomepage: http://thoughtpolice.github.com/hs-ed25519\r\nbug-reports: http://github.com/thoughtpolice/hs-ed25519/issues\r\nlicense-file: LICENSE.txt\r\ncopyright: Copyright (c) Austin Seipp 2013-2015\r\nauthor: Austin Seipp\r\nmaintainer: Austin Seipp \r\nbuild-type: Simple\r\ncabal-version: >=1.10\r\ntested-with: GHC == 7.0.1, GHC == 7.0.2, GHC == 7.0.3, GHC == 7.0.4,\r\n GHC == 7.2.1, GHC == 7.2.2, GHC == 7.4.1, GHC == 7.4.2,\r\n GHC == 7.6.1, GHC == 7.6.2, GHC == 7.6.3,\r\n GHC == 7.8.2, GHC == 7.8.3, GHC == 7.8.4,\r\n GHC == 7.10.1, GHC == 7.10.2\r\n\r\ndescription:\r\n This package provides a simple, fast, self-contained copy of the\r\n Ed25519 public-key signature system with a clean interface. It also\r\n includes support for detached signatures, and thorough documentation\r\n on the design and implementation, including usage guidelines.\r\n\r\nextra-source-files:\r\n .travis.yml\r\n AUTHORS.txt\r\n README.md\r\n CONTRIBUTING.md\r\n CHANGELOG.md\r\n src/cbits/ref10/*.c\r\n src/cbits/ref10/include/*.h\r\n\r\nsource-repository head\r\n type: git\r\n location: https://github.com/thoughtpolice/hs-ed25519.git\r\n\r\n-------------------------------------------------------------------------------\r\n-- Flags\r\n\r\nflag test-properties\r\n default: True\r\n manual: True\r\n\r\nflag test-hlint\r\n default: True\r\n manual: True\r\n\r\nflag test-doctests\r\n default: True\r\n manual: True\r\n\r\nflag no-donna\r\n default: True\r\n manual: True\r\n\r\n-------------------------------------------------------------------------------\r\n-- Build pt 1: main project\r\n\r\nlibrary\r\n build-depends:\r\n ghc-prim >= 0.1 && < 0.10,\r\n base >= 4 && < 5,\r\n bytestring >= 0.9 && < 0.12\r\n\r\n exposed-modules:\r\n Crypto.Sign.Ed25519\r\n\r\n ghc-options: -Wall -fwarn-tabs\r\n default-language: Haskell2010\r\n hs-source-dirs: src\r\n\r\n -- Choose the underlying C implementation\r\n if flag(no-donna)\r\n -- ref10 implementation from SUPERCOP, about 2x slower than the AMD64\r\n -- SUPERCOP implementations, 15x faster than ronald3072 for signing.\r\n c-sources: src/cbits/ref10/ed25519.c\r\n include-dirs: src/cbits/ref10 src/cbits/ref10/include\r\n else\r\n -- TODO(aseipp): ed25519-donna import\r\n buildable: False\r\n\r\n-------------------------------------------------------------------------------\r\n-- Build pt 2: Tests\r\n\r\ntest-suite properties\r\n type: exitcode-stdio-1.0\r\n main-is: properties.hs\r\n ghc-options: -w\r\n hs-source-dirs: tests\r\n default-language: Haskell2010\r\n\r\n if !flag(test-properties)\r\n buildable: False\r\n else\r\n build-depends:\r\n base >= 4 && < 5,\r\n bytestring >= 0.9 && < 0.12,\r\n QuickCheck >= 2.4 && < 2.9,\r\n ed25519\r\n\r\n--\r\n-- Style/doc tests below\r\n--\r\n\r\ntest-suite hlint\r\n type: exitcode-stdio-1.0\r\n main-is: hlint.hs\r\n hs-source-dirs: tests\r\n default-language: Haskell2010\r\n\r\n if !flag(test-hlint)\r\n buildable: False\r\n else\r\n build-depends:\r\n base >= 4 && < 5,\r\n hlint >= 1.7 && < 1.10\r\n\r\ntest-suite doctests\r\n type: exitcode-stdio-1.0\r\n main-is: doctests.hs\r\n hs-source-dirs: tests\r\n default-language: Haskell2010\r\n\r\n if !flag(test-doctests)\r\n buildable: False\r\n else\r\n build-depends:\r\n base >= 4 && < 5,\r\n filepath >= 1.0 && < 1.5,\r\n directory >= 1.0 && < 1.3,\r\n doctest >= 0.10 && < 0.12\r\n\r\n-------------------------------------------------------------------------------\r\n-- Build pt 3: benchmarks\r\n\r\nbenchmark bench\r\n type: exitcode-stdio-1.0\r\n build-depends:\r\n base >= 4 && < 5,\r\n bytestring >= 0.9 && < 0.12,\r\n criterion >= 0.8 && < 1.2,\r\n deepseq >= 1.3 && < 1.5,\r\n ed25519\r\n\r\n default-language: Haskell2010\r\n hs-source-dirs: benchmarks\r\n main-is: bench.hs\r\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/edit-distance.nix b/materialized/ghc927/cabal-install/cabal-files/edit-distance.nix new file mode 100644 index 0000000000..d1aca72934 --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/edit-distance.nix @@ -0,0 +1,73 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "edit-distance"; version = "0.2.2.1"; }; + license = "BSD-3-Clause"; + copyright = "(c) 2008-2013 Maximilian Bolinbroke"; + maintainer = "Oleg Grenrus "; + author = "Max Bolingbroke "; + homepage = "http://github.com/phadej/edit-distance"; + url = ""; + synopsis = "Levenshtein and restricted Damerau-Levenshtein edit distances"; + description = "Optimized edit distances for fuzzy matching, including Levenshtein and restricted Damerau-Levenshtein algorithms."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + ]; + buildable = true; + }; + tests = { + "edit-distance-tests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."test-framework" or (errorHandler.buildDepError "test-framework")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."test-framework-quickcheck2" or (errorHandler.buildDepError "test-framework-quickcheck2")) + ]; + buildable = true; + }; + }; + benchmarks = { + "edit-distance-benchmark" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."unix" or (errorHandler.buildDepError "unix")) + (hsPkgs."criterion" or (errorHandler.buildDepError "criterion")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/edit-distance-0.2.2.1.tar.gz"; + sha256 = "3e8885ee2f56ad4da940f043ae8f981ee2fe336b5e8e4ba3f7436cff4f526c4a"; + }); + }) // { + package-description-override = "name: edit-distance\r\nversion: 0.2.2.1\r\nx-revision: 1\r\ncabal-version: >= 1.10\r\ncategory: Algorithms\r\nsynopsis: Levenshtein and restricted Damerau-Levenshtein edit distances\r\ndescription: Optimized edit distances for fuzzy matching, including Levenshtein and restricted Damerau-Levenshtein algorithms.\r\nlicense: BSD3\r\nlicense-File: LICENSE\r\nextra-source-files: README.md\r\nauthor: Max Bolingbroke \r\ncopyright: (c) 2008-2013 Maximilian Bolinbroke\r\nmaintainer: Oleg Grenrus \r\nhomepage: http://github.com/phadej/edit-distance\r\nbuild-type: Simple\r\n\r\nlibrary\r\n default-language: Haskell98\r\n exposed-modules: Text.EditDistance\r\n other-modules: Text.EditDistance.EditCosts\r\n Text.EditDistance.SquareSTUArray\r\n Text.EditDistance.STUArray\r\n Text.EditDistance.Bits\r\n Text.EditDistance.MonadUtilities\r\n Text.EditDistance.ArrayUtilities\r\n build-depends: base >= 4.5 && < 5, array >= 0.1, random >= 1.0, containers >= 0.1.0.1\r\n ghc-options: -O2 -Wall\r\n\r\ntest-suite edit-distance-tests\r\n default-language: Haskell98\r\n main-is: Text/EditDistance/Tests.hs\r\n other-modules: Text.EditDistance.Tests.EditOperationOntology\r\n Text.EditDistance.Tests.Properties\r\n type: exitcode-stdio-1.0\r\n ghc-options: -O2 -Wall\r\n build-depends: base >= 4.5 && < 5, array >= 0.1, random >= 1.0, containers >= 0.1.0.1,\r\n test-framework >= 0.1.1, QuickCheck >= 2.4 && <2.10, test-framework-quickcheck2\r\n\r\nbenchmark edit-distance-benchmark\r\n default-language: Haskell98\r\n main-is: Text/EditDistance/Benchmark.hs\r\n type: exitcode-stdio-1.0\r\n build-depends: base >= 4.5 && < 5, array >= 0.1, random >= 1.0, time >= 1.0, process >= 1.0,\r\n deepseq >= 1.2, unix >= 2.3, criterion >= 1.1, containers >= 0.1.0.1\r\n ghc-options: -O2\r\n\r\nsource-repository head\r\n type: git\r\n location: https://github.com/phadej/edit-distance.git\r\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/hackage-security.nix b/materialized/ghc927/cabal-install/cabal-files/hackage-security.nix new file mode 100644 index 0000000000..64d7b1e298 --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/hackage-security.nix @@ -0,0 +1,126 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = { + base48 = true; + use-network-uri = true; + cabal-syntax = false; + old-directory = false; + mtl21 = false; + lukko = true; + }; + package = { + specVersion = "1.12"; + identifier = { name = "hackage-security"; version = "0.6.2.2"; }; + license = "BSD-3-Clause"; + copyright = "Copyright 2015-2022 Well-Typed LLP"; + maintainer = "cabal-devel@haskell.org"; + author = "Edsko de Vries"; + homepage = "https://github.com/haskell/hackage-security"; + url = ""; + synopsis = "Hackage security library"; + description = "The hackage security library provides both server and\nclient utilities for securing the Hackage package server\n(). It is based on The Update\nFramework (), a set of\nrecommendations developed by security researchers at\nvarious universities in the US as well as developers on the\nTor project ().\n\nThe current implementation supports only index signing,\nthereby enabling untrusted mirrors. It does not yet provide\nfacilities for author package signing.\n\nThe library has two main entry points:\n\"Hackage.Security.Client\" is the main entry point for\nclients (the typical example being @cabal@), and\n\"Hackage.Security.Server\" is the main entry point for\nservers (the typical example being @hackage-server@)."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = ((((([ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."base16-bytestring" or (errorHandler.buildDepError "base16-bytestring")) + (hsPkgs."base64-bytestring" or (errorHandler.buildDepError "base64-bytestring")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."ed25519" or (errorHandler.buildDepError "ed25519")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."parsec" or (errorHandler.buildDepError "parsec")) + (hsPkgs."pretty" or (errorHandler.buildDepError "pretty")) + (hsPkgs."cryptohash-sha256" or (errorHandler.buildDepError "cryptohash-sha256")) + (hsPkgs."tar" or (errorHandler.buildDepError "tar")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."zlib" or (errorHandler.buildDepError "zlib")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + ] ++ (if flags.old-directory + then [ + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."old-time" or (errorHandler.buildDepError "old-time")) + ] + else [ + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + ])) ++ (if flags.mtl21 + then [ + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + (hsPkgs."mtl-compat" or (errorHandler.buildDepError "mtl-compat")) + ] + else [ + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + ])) ++ (if flags.lukko + then [ (hsPkgs."lukko" or (errorHandler.buildDepError "lukko")) ] + else [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + ])) ++ (if flags.cabal-syntax && (compiler.isGhc && (compiler.version).ge "8.2") + then [ + (hsPkgs."Cabal-syntax" or (errorHandler.buildDepError "Cabal-syntax")) + ] + else [ + (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal")) + (hsPkgs."Cabal-syntax" or (errorHandler.buildDepError "Cabal-syntax")) + ])) ++ (if flags.base48 + then [ (hsPkgs."base" or (errorHandler.buildDepError "base")) ] + else [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."old-locale" or (errorHandler.buildDepError "old-locale")) + ])) ++ (if flags.use-network-uri + then [ + (hsPkgs."network-uri" or (errorHandler.buildDepError "network-uri")) + (hsPkgs."network" or (errorHandler.buildDepError "network")) + ] + else [ + (hsPkgs."network" or (errorHandler.buildDepError "network")) + ]); + buildable = true; + }; + tests = { + "TestSuite" = { + depends = [ + (hsPkgs."hackage-security" or (errorHandler.buildDepError "hackage-security")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."network-uri" or (errorHandler.buildDepError "network-uri")) + (hsPkgs."tar" or (errorHandler.buildDepError "tar")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."zlib" or (errorHandler.buildDepError "zlib")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."aeson" or (errorHandler.buildDepError "aeson")) + (hsPkgs."vector" or (errorHandler.buildDepError "vector")) + (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers")) + (hsPkgs."temporary" or (errorHandler.buildDepError "temporary")) + ] ++ [ + (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal")) + (hsPkgs."Cabal-syntax" or (errorHandler.buildDepError "Cabal-syntax")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/hackage-security-0.6.2.2.tar.gz"; + sha256 = "a833a31610220506557e96fb6e3e8b05a2e1db8e7ebc06e91bbb699ddde0b276"; + }); + }) // { + package-description-override = "cabal-version: 1.12\r\nname: hackage-security\r\nversion: 0.6.2.2\r\nx-revision: 1\r\n\r\nsynopsis: Hackage security library\r\ndescription: The hackage security library provides both server and\r\n client utilities for securing the Hackage package server\r\n (). It is based on The Update\r\n Framework (), a set of\r\n recommendations developed by security researchers at\r\n various universities in the US as well as developers on the\r\n Tor project ().\r\n .\r\n The current implementation supports only index signing,\r\n thereby enabling untrusted mirrors. It does not yet provide\r\n facilities for author package signing.\r\n .\r\n The library has two main entry points:\r\n \"Hackage.Security.Client\" is the main entry point for\r\n clients (the typical example being @cabal@), and\r\n \"Hackage.Security.Server\" is the main entry point for\r\n servers (the typical example being @hackage-server@).\r\nlicense: BSD3\r\nlicense-file: LICENSE\r\nauthor: Edsko de Vries\r\nmaintainer: cabal-devel@haskell.org\r\ncopyright: Copyright 2015-2022 Well-Typed LLP\r\ncategory: Distribution\r\nhomepage: https://github.com/haskell/hackage-security\r\nbug-reports: https://github.com/haskell/hackage-security/issues\r\nbuild-type: Simple\r\n\r\ntested-with:\r\n GHC==9.2.1, GHC==9.0.2,\r\n GHC==8.10.7, GHC==8.8.4, GHC==8.6.5, GHC==8.4.4, GHC==8.2.2, GHC==8.0.2,\r\n GHC==7.10.3, GHC==7.8.4, GHC==7.6.3, GHC==7.4.2\r\n\r\nextra-source-files:\r\n ChangeLog.md\r\n\r\nsource-repository head\r\n type: git\r\n location: https://github.com/haskell/hackage-security.git\r\n\r\nflag base48\r\n description: Are we using @base@ 4.8 or later?\r\n manual: False\r\n\r\nflag use-network-uri\r\n description: Are we using @network-uri@?\r\n manual: False\r\n\r\nflag Cabal-syntax\r\n description: Are we using Cabal-syntax?\r\n manual: False\r\n default: False\r\n\r\nflag old-directory\r\n description: Use @directory@ < 1.2 and @old-time@\r\n manual: False\r\n default: False\r\n\r\nflag mtl21\r\n description: Use @mtl@ < 2.2 and @mtl-compat@\r\n manual: False\r\n default: False\r\n\r\nflag lukko\r\n description: Use @lukko@ for file-locking, otherwise use @GHC.IO.Handle.Lock@\r\n manual: True\r\n default: True\r\n\r\nlibrary\r\n -- Most functionality is exported through the top-level entry points .Client\r\n -- and .Server; the other exported modules are intended for qualified imports.\r\n exposed-modules: Hackage.Security.Client\r\n Hackage.Security.Client.Formats\r\n Hackage.Security.Client.Repository\r\n Hackage.Security.Client.Repository.Cache\r\n Hackage.Security.Client.Repository.Local\r\n Hackage.Security.Client.Repository.Remote\r\n Hackage.Security.Client.Repository.HttpLib\r\n Hackage.Security.Client.Verify\r\n Hackage.Security.JSON\r\n Hackage.Security.Key.Env\r\n Hackage.Security.Server\r\n Hackage.Security.Trusted\r\n Hackage.Security.TUF.FileMap\r\n Hackage.Security.Util.Checked\r\n Hackage.Security.Util.Path\r\n Hackage.Security.Util.Pretty\r\n Hackage.Security.Util.Some\r\n Text.JSON.Canonical\r\n other-modules: Hackage.Security.Key\r\n Hackage.Security.Trusted.TCB\r\n Hackage.Security.TUF\r\n Hackage.Security.TUF.Common\r\n Hackage.Security.TUF.FileInfo\r\n Hackage.Security.TUF.Header\r\n Hackage.Security.TUF.Layout.Cache\r\n Hackage.Security.TUF.Layout.Index\r\n Hackage.Security.TUF.Layout.Repo\r\n Hackage.Security.TUF.Mirrors\r\n Hackage.Security.TUF.Paths\r\n Hackage.Security.TUF.Patterns\r\n Hackage.Security.TUF.Root\r\n Hackage.Security.TUF.Signed\r\n Hackage.Security.TUF.Snapshot\r\n Hackage.Security.TUF.Targets\r\n Hackage.Security.TUF.Timestamp\r\n Hackage.Security.Util.Base64\r\n Hackage.Security.Util.Exit\r\n Hackage.Security.Util.IO\r\n Hackage.Security.Util.JSON\r\n Hackage.Security.Util.Lens\r\n Hackage.Security.Util.Stack\r\n Hackage.Security.Util.TypedEmbedded\r\n MyPrelude\r\n -- We support ghc 7.4 (bundled with Cabal 1.14) and up\r\n build-depends: base >= 4.5 && < 4.18,\r\n base16-bytestring >= 0.1.1 && < 1.1,\r\n base64-bytestring >= 1.0 && < 1.3,\r\n bytestring >= 0.9 && < 0.12,\r\n containers >= 0.4 && < 0.7,\r\n ed25519 >= 0.0 && < 0.1,\r\n filepath >= 1.2 && < 1.5,\r\n parsec >= 3.1 && < 3.2,\r\n pretty >= 1.0 && < 1.2,\r\n cryptohash-sha256 >= 0.11 && < 0.12,\r\n -- 0.4.2 introduces TarIndex, 0.4.4 introduces more\r\n -- functionality, 0.5.0 changes type of serialise\r\n tar >= 0.5 && < 0.6,\r\n template-haskell >= 2.7 && < 2.20,\r\n time >= 1.2 && < 1.13,\r\n transformers >= 0.3 && < 0.7,\r\n zlib >= 0.5 && < 0.7,\r\n -- whatever versions are bundled with ghc:\r\n ghc-prim\r\n if flag(old-directory)\r\n build-depends: directory >= 1.1.0.2 && < 1.2,\r\n old-time >= 1 && < 1.2\r\n else\r\n build-depends: directory >= 1.2 && < 1.4\r\n\r\n if flag(mtl21)\r\n build-depends: mtl >= 2.1 && < 2.2,\r\n mtl-compat >= 0.2 && < 0.3\r\n else\r\n build-depends: mtl >= 2.2 && < 2.4\r\n\r\n if flag(lukko)\r\n build-depends: lukko >= 0.1 && < 0.2\r\n else\r\n build-depends: base >= 4.10\r\n\r\n if flag(Cabal-syntax) && impl(ghc >= 8.2)\r\n build-depends: Cabal-syntax >= 3.7 && < 3.10\r\n else\r\n build-depends: Cabal >= 1.14 && < 1.26\r\n || >= 2.0 && < 2.6\r\n || >= 3.0 && < 3.7,\r\n Cabal-syntax < 3.7\r\n\r\n hs-source-dirs: src\r\n default-language: Haskell2010\r\n default-extensions: DefaultSignatures\r\n DeriveDataTypeable\r\n DeriveFunctor\r\n FlexibleContexts\r\n FlexibleInstances\r\n GADTs\r\n GeneralizedNewtypeDeriving\r\n KindSignatures\r\n MultiParamTypeClasses\r\n NamedFieldPuns\r\n NoImplicitPrelude\r\n NoMonomorphismRestriction\r\n RankNTypes\r\n RecordWildCards\r\n ScopedTypeVariables\r\n StandaloneDeriving\r\n TupleSections\r\n TypeFamilies\r\n TypeOperators\r\n ViewPatterns\r\n other-extensions: BangPatterns\r\n CPP\r\n OverlappingInstances\r\n PackageImports\r\n UndecidableInstances\r\n\r\n -- use the new stage1/cross-compile-friendly DeriveLift extension for GHC 8.0+\r\n if impl(ghc >= 8.0)\r\n other-extensions: DeriveLift\r\n else\r\n other-extensions: TemplateHaskell\r\n\r\n ghc-options: -Wall\r\n\r\n if flag(base48)\r\n build-depends: base >= 4.8\r\n else\r\n build-depends: base < 4.8, old-locale == 1.0.*\r\n\r\n -- The URI type got split out off the network package after version 2.5, and\r\n -- moved to a separate network-uri package. Since we don't need the rest of\r\n -- network here, it would suffice to rely only on network-uri:\r\n --\r\n -- > if flag(use-network-uri)\r\n -- > build-depends: network-uri >= 2.6 && < 2.7\r\n -- > else\r\n -- > build-depends: network >= 2.5 && < 2.6\r\n --\r\n -- However, if we did the same in hackage-security-HTTP, Cabal would consider\r\n -- those two flag choices (hackage-security:use-network-uri and\r\n -- hackage-security-HTTP:use-network-uri) to be completely independent; but\r\n -- they aren't: if it links hackage-security against network-uri and\r\n -- hackage-security-HTTP against network, we will get type errors when\r\n -- hackage-security-HTTP tries to pass a URI to hackage-security.\r\n --\r\n -- It might seem we can solve this problem by re-exporting the URI type in\r\n -- hackage-security and avoid the dependency in hackage-security-HTTP\r\n -- altogether. However, this merely shifts the problem: hackage-security-HTTP\r\n -- relies on the HTTP library which--surprise!--makes the same choice between\r\n -- depending on network or network-uri. Cabal will not notice that we cannot\r\n -- build hackage-security and hackage-security-HTTP against network-uri but\r\n -- HTTP against network.\r\n --\r\n -- We solve the problem by explicitly relying on network-2.6 when choosing\r\n -- network-uri. This dependency is redundant, strictly speaking. However, it\r\n -- serves as a proxy for forcing flag choices: since all packages in a\r\n -- solution must be linked against the same version of network, having one\r\n -- version of network in one branch of the conditional and another version of\r\n -- network in the other branch forces the choice to be consistent throughout.\r\n -- (Note that the HTTP library does the same thing, though in this case the\r\n -- dependency in network is not redundant.)\r\n if flag(use-network-uri)\r\n build-depends: network-uri >= 2.6 && < 2.7,\r\n network >= 2.6 && < 2.9\r\n || >= 3.0 && < 3.2\r\n else\r\n build-depends: network >= 2.5 && < 2.6\r\n\r\n if impl(ghc >= 7.8)\r\n other-extensions: RoleAnnotations\r\n\r\n if impl(ghc >= 7.10)\r\n other-extensions: AllowAmbiguousTypes\r\n StaticPointers\r\n\r\ntest-suite TestSuite\r\n type: exitcode-stdio-1.0\r\n main-is: TestSuite.hs\r\n other-modules: TestSuite.HttpMem\r\n TestSuite.InMemCache\r\n TestSuite.InMemRepo\r\n TestSuite.InMemRepository\r\n TestSuite.JSON\r\n TestSuite.PrivateKeys\r\n TestSuite.Util.StrictMVar\r\n\r\n -- inherited constraints from lib:hackage-security component\r\n build-depends: hackage-security,\r\n base,\r\n containers,\r\n bytestring,\r\n network-uri,\r\n tar,\r\n text,\r\n time,\r\n zlib\r\n\r\n if flag(Cabal-syntax) && impl(ghc >= 8.2)\r\n build-depends: Cabal >= 3.7 && < 3.10,\r\n Cabal-syntax >= 3.7 && < 3.10\r\n else\r\n build-depends: Cabal >= 1.14 && < 1.26\r\n || >= 2.0 && < 2.6\r\n || >= 3.0 && < 3.7,\r\n Cabal-syntax < 3.7\r\n\r\n -- dependencies exclusive to test-suite\r\n build-depends: tasty >= 1.2 && < 1.5,\r\n tasty-hunit == 0.10.*,\r\n tasty-quickcheck == 0.10.*,\r\n QuickCheck >= 2.11 && <2.15,\r\n aeson == 1.4.* || == 1.5.* || == 2.0.* || == 2.1.*,\r\n vector == 0.12.*,\r\n unordered-containers >=0.2.8.0 && <0.3,\r\n temporary >= 1.2 && < 1.4\r\n\r\n hs-source-dirs: tests\r\n default-language: Haskell2010\r\n default-extensions: FlexibleContexts\r\n GADTs\r\n KindSignatures\r\n RankNTypes\r\n RecordWildCards\r\n ScopedTypeVariables\r\n ghc-options: -Wall\r\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/hashable.nix b/materialized/ghc927/cabal-install/cabal-files/hashable.nix new file mode 100644 index 0000000000..5cccd97566 --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/hashable.nix @@ -0,0 +1,90 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = { + integer-gmp = true; + random-initial-seed = false; + containers = true; + }; + package = { + specVersion = "1.12"; + identifier = { name = "hashable"; version = "1.4.1.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "Oleg Grenrus "; + author = "Milan Straka \nJohan Tibell "; + homepage = "http://github.com/haskell-unordered-containers/hashable"; + url = ""; + synopsis = "A class for types that can be converted to a hash value"; + description = "This package defines a class, 'Hashable', for types that\ncan be converted to a hash value. This class\nexists for the benefit of hashing-based data\nstructures. The package provides instances for\nbasic types and a way to combine hash values."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = (((([ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + ] ++ (pkgs.lib).optional (!(compiler.isGhc && (compiler.version).ge "9.2")) (hsPkgs."base-orphans" or (errorHandler.buildDepError "base-orphans"))) ++ (if compiler.isGhc && (compiler.version).ge "9" + then [ + (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) + ] ++ (pkgs.lib).optional (!(compiler.isGhc && (compiler.version).ge "9.0.2")) (hsPkgs."ghc-bignum-orphans" or (errorHandler.buildDepError "ghc-bignum-orphans")) + else if flags.integer-gmp + then [ + (hsPkgs."integer-gmp" or (errorHandler.buildDepError "integer-gmp")) + ] + else [ + (hsPkgs."integer-simple" or (errorHandler.buildDepError "integer-simple")) + ])) ++ (pkgs.lib).optionals (!(compiler.isGhc && (compiler.version).ge "8")) [ + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."transformers-compat" or (errorHandler.buildDepError "transformers-compat")) + ]) ++ [ + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + ]) ++ (pkgs.lib).optional (!(compiler.isGhc && (compiler.version).ge "8.0") || !flags.containers) (hsPkgs."functor-classes-compat" or (errorHandler.buildDepError "functor-classes-compat")); + buildable = true; + }; + tests = { + "hashable-tests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."test-framework" or (errorHandler.buildDepError "test-framework")) + (hsPkgs."test-framework-hunit" or (errorHandler.buildDepError "test-framework-hunit")) + (hsPkgs."test-framework-quickcheck2" or (errorHandler.buildDepError "test-framework-quickcheck2")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + ] ++ (pkgs.lib).optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + "hashable-examples" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/hashable-1.4.1.0.tar.gz"; + sha256 = "e1b305c280e66ad827edeaedd6933b9fc4174f626882877eab2a08344e665e87"; + }); + }) // { + package-description-override = "cabal-version: 1.12\nname: hashable\nversion: 1.4.1.0\nsynopsis: A class for types that can be converted to a hash value\ndescription:\n This package defines a class, 'Hashable', for types that\n can be converted to a hash value. This class\n exists for the benefit of hashing-based data\n structures. The package provides instances for\n basic types and a way to combine hash values.\n\nhomepage: http://github.com/haskell-unordered-containers/hashable\n\n-- SPDX-License-Identifier : BSD-3-Clause\nlicense: BSD3\nlicense-file: LICENSE\nauthor:\n Milan Straka \n Johan Tibell \n\nmaintainer: Oleg Grenrus \nbug-reports:\n https://github.com/haskell-unordered-containers/hashable/issues\n\nstability: Provisional\ncategory: Data\nbuild-type: Simple\ntested-with:\n GHC ==7.4.2\n || ==7.6.3\n || ==7.8.4\n || ==7.10.3\n || ==8.0.2\n || ==8.2.2\n || ==8.4.4\n || ==8.6.5\n || ==8.8.3\n || ==8.10.4\n || ==8.10.7\n || ==9.0.1\n || ==9.0.2\n || ==9.2.4\n || ==9.4.1\n\nextra-source-files:\n CHANGES.md\n include/HsHashable.h\n README.md\n\nflag integer-gmp\n description:\n Are we using @integer-gmp@ to provide fast Integer instances? No effect on GHC-9.0 or later.\n\n manual: False\n default: True\n\nflag random-initial-seed\n description:\n Randomly initialize the initial seed on each final executable invocation\n This is useful for catching cases when you rely on (non-existent)\n stability of hashable's hash functions.\n This is not a security feature.\n\n manual: True\n default: False\n\nflag containers\n description: 'containers >= 0.5.9.1'\n manual: False\n default: True\n\nlibrary\n exposed-modules:\n Data.Hashable\n Data.Hashable.Generic\n Data.Hashable.Lifted\n\n other-modules:\n Data.Hashable.Class\n Data.Hashable.Generic.Instances\n Data.Hashable.Imports\n Data.Hashable.LowLevel\n\n c-sources: cbits/fnv.c\n include-dirs: include\n hs-source-dirs: src\n build-depends:\n base >=4.5 && <4.18\n , bytestring >=0.9 && <0.12\n , containers >=0.4.2.1 && <0.7\n , deepseq >=1.3 && <1.5\n , ghc-prim\n , text >=1.2.3.0 && <1.3 || >=2.0 && <2.1\n\n if !impl(ghc >=9.2)\n build-depends: base-orphans >=0.8.6\n\n -- Integer internals\n if impl(ghc >=9)\n build-depends: ghc-bignum >=1.0 && <1.4\n\n if !impl(ghc >=9.0.2)\n build-depends: ghc-bignum-orphans >=0.1 && <0.2\n\n else\n if flag(integer-gmp)\n build-depends: integer-gmp >=0.4 && <1.1\n\n else\n -- this is needed for the automatic flag to be well-balanced\n build-depends: integer-simple\n\n if !impl(ghc >=8)\n build-depends:\n transformers >=0.3 && <0.7\n , transformers-compat >=0.7.1 && <0.8\n\n if (flag(random-initial-seed) && impl(ghc))\n cpp-options: -DHASHABLE_RANDOM_SEED=1\n\n if os(windows)\n c-sources: cbits-win/init.c\n\n else\n c-sources: cbits-unix/init.c\n\n -- containers flag mutually exclusive choice\n if flag(containers)\n build-depends: containers >=0.5.9.1\n else\n build-depends: containers <0.5.9.1\n\n -- we need functor-classes-compat on older GHCs always.\n -- we also need it if containers is too old.\n if !impl(ghc >=8.0) || !flag(containers)\n build-depends: functor-classes-compat >=2.0.0.2 && <2.1\n\n default-language: Haskell2010\n other-extensions:\n BangPatterns\n CPP\n DeriveDataTypeable\n FlexibleContexts\n FlexibleInstances\n GADTs\n KindSignatures\n MagicHash\n MultiParamTypeClasses\n ScopedTypeVariables\n Trustworthy\n TypeOperators\n UnliftedFFITypes\n\n ghc-options: -Wall -fwarn-tabs\n\n if impl(ghc >=9.0)\n -- these flags may abort compilation with GHC-8.10\n -- https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3295\n ghc-options: -Winferred-safe-imports -Wmissing-safe-haskell-mode\n\ntest-suite hashable-tests\n type: exitcode-stdio-1.0\n hs-source-dirs: tests\n main-is: Main.hs\n other-modules:\n Properties\n Regress\n\n build-depends:\n base\n , bytestring\n , ghc-prim\n , hashable\n , HUnit\n , QuickCheck >=2.4.0.1\n , random >=1.0 && <1.3\n , test-framework >=0.3.3\n , test-framework-hunit\n , test-framework-quickcheck2 >=0.2.9\n , text >=0.11.0.5\n\n if !os(windows)\n build-depends: unix\n cpp-options: -DHAVE_MMAP\n other-modules: Regress.Mmap\n other-extensions: CApiFFI\n\n ghc-options: -Wall -fno-warn-orphans\n default-language: Haskell2010\n\ntest-suite hashable-examples\n type: exitcode-stdio-1.0\n build-depends:\n base\n , ghc-prim\n , hashable\n\n hs-source-dirs: examples\n main-is: Main.hs\n default-language: Haskell2010\n\nsource-repository head\n type: git\n location:\n https://github.com/haskell-unordered-containers/hashable.git\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/hsc2hs.nix b/materialized/ghc927/cabal-install/cabal-files/hsc2hs.nix new file mode 100644 index 0000000000..71e6e92488 --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/hsc2hs.nix @@ -0,0 +1,57 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = { in-ghc-tree = false; }; + package = { + specVersion = "1.10"; + identifier = { name = "hsc2hs"; version = "0.68.8"; }; + license = "BSD-3-Clause"; + copyright = "2000, Marcin Kowalczyk"; + maintainer = "ghc-devs@haskell.org"; + author = "Marcin Kowalczyk "; + homepage = ""; + url = ""; + synopsis = "A preprocessor that helps with writing Haskell bindings to C code"; + description = "The hsc2hs program can be used to automate some parts of the\nprocess of writing Haskell bindings to C code. It reads an\nalmost-Haskell source file with embedded special constructs, and\noutputs a real Haskell file with these constructs processed, based\non information taken from some C headers. The extra constructs\nprovide Haskell counterparts of C types, values of C constants,\nincluding sizes of C types, and access to fields of C structs.\n\nFor more details, see the\n\nin the GHC User's Guide."; + buildType = "Simple"; + }; + components = { + exes = { + "hsc2hs" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + ] ++ (pkgs.lib).optional (system.isWindows) (hsPkgs."process" or (errorHandler.buildDepError "process")); + buildable = true; + }; + }; + tests = { + "spec" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."test-framework" or (errorHandler.buildDepError "test-framework")) + (hsPkgs."test-framework-hunit" or (errorHandler.buildDepError "test-framework-hunit")) + (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/hsc2hs-0.68.8.tar.gz"; + sha256 = "78341efbc917a84a07f2143bee9203e2555072054d495717aa73d89d9df77a52"; + }); + }) // { + package-description-override = "cabal-version: >=1.10\r\nName: hsc2hs\r\nVersion: 0.68.8\r\nx-revision: 1\r\n\r\nCopyright: 2000, Marcin Kowalczyk\r\nLicense: BSD3\r\nLicense-File: LICENSE\r\nAuthor: Marcin Kowalczyk \r\nMaintainer: ghc-devs@haskell.org\r\nSynopsis: A preprocessor that helps with writing Haskell bindings to C code\r\nBug-Reports: https://github.com/haskell/hsc2hs/issues\r\nDescription:\r\n The hsc2hs program can be used to automate some parts of the\r\n process of writing Haskell bindings to C code. It reads an\r\n almost-Haskell source file with embedded special constructs, and\r\n outputs a real Haskell file with these constructs processed, based\r\n on information taken from some C headers. The extra constructs\r\n provide Haskell counterparts of C types, values of C constants,\r\n including sizes of C types, and access to fields of C structs.\r\n .\r\n For more details, see the\r\n \r\n in the GHC User's Guide.\r\nCategory: Development\r\nData-Dir: data/\r\nData-Files: template-hsc.h\r\nbuild-type: Simple\r\ntested-with: GHC==8.10.1, GHC==8.8.3, GHC==8.6.5, GHC==8.4.4, GHC==8.2.2, GHC==8.0.2, GHC==7.10.3, GHC==7.8.4, GHC==7.6.3, GHC==7.4.2, GHC==7.2.2, GHC==7.0.4\r\n\r\nextra-source-files:\r\n changelog.md\r\n test/asm/*.s\r\n\r\nflag in-ghc-tree\r\n description: Are we in a GHC tree?\r\n default: False\r\n manual: True\r\n\r\nsource-repository head\r\n Type: git\r\n Location: https://github.com/haskell/hsc2hs.git\r\n\r\nExecutable hsc2hs\r\n Default-Language: Haskell2010\r\n Main-Is: Main.hs\r\n Hs-Source-Dirs: src/\r\n Other-Modules:\r\n C\r\n Common\r\n CrossCodegen\r\n DirectCodegen\r\n Flags\r\n HSCParser\r\n ATTParser\r\n UtilsCodegen\r\n Compat.ResponseFile\r\n Compat.TempFile\r\n Paths_hsc2hs\r\n\r\n c-sources:\r\n cbits/utils.c\r\n\r\n Other-Extensions: CPP, NoMonomorphismRestriction\r\n\r\n Build-Depends: base >= 4.3.0 && < 4.18,\r\n containers >= 0.4.0 && < 0.7,\r\n directory >= 1.1.0 && < 1.4,\r\n filepath >= 1.2.0 && < 1.5,\r\n process >= 1.1.0 && < 1.7\r\n\r\n if os(windows)\r\n -- N.B. Job object support was irreparably broken prior to 1.6.8.\r\n -- See https://github.com/haskell/process/issues/167.\r\n Build-Depends: process >= 1.6.8 && < 1.7\r\n\r\n ghc-options: -Wall\r\n if flag(in-ghc-tree)\r\n cpp-options: -DIN_GHC_TREE\r\n\r\ntest-suite spec\r\n main-is: Spec.hs\r\n hs-source-dirs: src/ test/\r\n other-modules: ATTParser Flags BDD\r\n ghc-options: -Wall -threaded\r\n type: exitcode-stdio-1.0\r\n build-depends: base,\r\n test-framework >=0.8.2.0 && <0.9,\r\n test-framework-hunit >=0.3.0.2 && <0.4,\r\n HUnit >=1.3.1.2 && <1.4 || >=1.6.0.0 && <1.7\r\n\r\n default-language: Haskell2010\r\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/lukko.nix b/materialized/ghc927/cabal-install/cabal-files/lukko.nix new file mode 100644 index 0000000000..f4f186f24b --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/lukko.nix @@ -0,0 +1,65 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = { ofd-locking = true; }; + package = { + specVersion = "2.2"; + identifier = { name = "lukko"; version = "0.1.1.3"; }; + license = "GPL-2.0-or-later AND BSD-3-Clause"; + copyright = ""; + maintainer = "Oleg Grenrus "; + author = ""; + homepage = ""; + url = ""; + synopsis = "File locking"; + description = "This package provides access to platform dependent file locking APIs:\n\n* on Linux (\"Lukko.OFD\")\n* BSD-style @flock(2)@ locks on UNIX platforms (\"Lukko.FLock\")\n* Windows locking via (\"Lukko.Windows\")\n* No-op locking, which throws exceptions (\"Lukko.NoOp\")\n* \"Lukko\" module exports the best option for the target platform with uniform API.\n\nThere are alternative file locking packages:\n\n* \"GHC.IO.Handle.Lock\" in @base >= 4.10@ is good enough for most use cases.\nHowever, uses only 'Handle's so these locks cannot be used for intra-process locking.\n(You should use e.g. 'MVar' in addition).\n\n* doesn't support OFD locking.\n\n/Lukko/ means lock in Finnish.\n\nSubmodules \"Lukko.OFD\", \"Lukko.Windows\" etc are available based on following conditions.\n\n@\nif os(windows)\n\\ cpp-options: -DHAS_WINDOWS_LOCK\n\nelif (os(linux) && flag(ofd-locking))\n\\ cpp-options: -DHAS_OFD_LOCKING\n\\ cpp-options: -DHAS_FLOCK\n\nelif !(os(solaris) || os(aix))\n\\ cpp-options: -DHAS_FLOCK\n@\n\n\"Lukko.FLock\" is available on not (Windows or Solaris or AIX).\n\"Lukko.NoOp\" is always available."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ (hsPkgs."base" or (errorHandler.buildDepError "base")) ]; + build-tools = [ + (hsPkgs.buildPackages.hsc2hs.components.exes.hsc2hs or (pkgs.buildPackages.hsc2hs or (errorHandler.buildToolDepError "hsc2hs:hsc2hs"))) + ]; + buildable = true; + }; + tests = { + "test-thread" = { + depends = [ + (hsPkgs."async" or (errorHandler.buildDepError "async")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."lukko" or (errorHandler.buildDepError "lukko")) + (hsPkgs."singleton-bool" or (errorHandler.buildDepError "singleton-bool")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-expected-failure" or (errorHandler.buildDepError "tasty-expected-failure")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + (hsPkgs."temporary" or (errorHandler.buildDepError "temporary")) + ] ++ (pkgs.lib).optional (!(compiler.isGhc && (compiler.version).ge "7.8")) (hsPkgs."tagged" or (errorHandler.buildDepError "tagged")); + buildable = true; + }; + "test-process" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."lukko" or (errorHandler.buildDepError "lukko")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/lukko-0.1.1.3.tar.gz"; + sha256 = "a80efb60cfa3dae18682c01980d76d5f7e413e191cd186992e1bf7388d48ab1f"; + }); + }) // { + package-description-override = "cabal-version: 2.2\nname: lukko\nversion: 0.1.1.3\nx-revision: 3\nsynopsis: File locking\ncategory: System, Concurrency\ndescription:\n This package provides access to platform dependent file locking APIs:\n .\n * on Linux (\"Lukko.OFD\")\n * BSD-style @flock(2)@ locks on UNIX platforms (\"Lukko.FLock\")\n * Windows locking via (\"Lukko.Windows\")\n * No-op locking, which throws exceptions (\"Lukko.NoOp\")\n * \"Lukko\" module exports the best option for the target platform with uniform API.\n .\n There are alternative file locking packages:\n .\n * \"GHC.IO.Handle.Lock\" in @base >= 4.10@ is good enough for most use cases.\n However, uses only 'Handle's so these locks cannot be used for intra-process locking.\n (You should use e.g. 'MVar' in addition).\n .\n * doesn't support OFD locking.\n .\n /Lukko/ means lock in Finnish.\n .\n Submodules \"Lukko.OFD\", \"Lukko.Windows\" etc are available based on following conditions.\n .\n @\n if os(windows)\n \\ cpp-options: -DHAS_WINDOWS_LOCK\n .\n elif (os(linux) && flag(ofd-locking))\n \\ cpp-options: -DHAS_OFD_LOCKING\n \\ cpp-options: -DHAS_FLOCK\n .\n elif !(os(solaris) || os(aix))\n \\ cpp-options: -DHAS_FLOCK\n @\n .\n \"Lukko.FLock\" is available on not (Windows or Solaris or AIX).\n \"Lukko.NoOp\" is always available.\n\nmaintainer: Oleg Grenrus \nlicense: GPL-2.0-or-later AND BSD-3-Clause\nlicense-files:\n LICENSE\n LICENSE.GPLv2\n LICENSE.GPLv3\n\nbuild-type: Simple\nextra-source-files: CHANGELOG.md\ntested-with:\n GHC ==7.6.3\n || ==7.8.4\n || ==7.10.3\n || ==8.0.2\n || ==8.2.2\n || ==8.4.4\n || ==8.6.5\n || ==8.8.4\n || ==8.10.7\n || ==9.0.2\n || ==9.2.4\n || ==9.4.1\n\nsource-repository head\n type: git\n location: https://github.com/haskellari/lukko/\n\nflag ofd-locking\n default: True\n manual: True\n description:\n Enable open file descriptor locking. Available on Linux (kernel 3.15, released Jun 8, 2014).\n\nlibrary\n default-language: Haskell2010\n hs-source-dirs: src\n build-depends: base >=4.5 && <4.18\n build-tool-depends: hsc2hs:hsc2hs >=0.67 && <0.69\n\n -- Main library module\n exposed-modules:\n Lukko\n Lukko.NoOp\n\n if os(windows)\n hs-source-dirs: src-windows\n cpp-options: -DUSE_WINDOWS_LOCK\n exposed-modules: Lukko.Windows\n c-sources: cbits/windows.c\n\n elif (os(linux) && flag(ofd-locking))\n hs-source-dirs: src-ofd\n hs-source-dirs: src-flock\n hs-source-dirs: src-unix\n cpp-options: -DUSE_OFD_LOCKING\n exposed-modules: Lukko.OFD\n\n elif !(os(solaris) || os(aix))\n hs-source-dirs: src-flock\n hs-source-dirs: src-unix\n cpp-options: -DUSE_FLOCK\n\n else\n hs-source-dirs: src-unix\n cpp-options: -DUSE_NOOP\n\n -- Cabal check is silly\n if (!os(windows) && !(os(solaris) || os(aix)))\n exposed-modules: Lukko.FLock\n\n other-modules:\n Lukko.Internal.FD\n Lukko.Internal.FillBytes\n Lukko.Internal.HandleToFD\n Lukko.Internal.Types\n\ntest-suite test-thread\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n hs-source-dirs: test\n main-is: Tests.hs\n ghc-options: -threaded\n build-depends:\n , async ^>=2.2.2\n , base\n , filepath ^>=1.3.0.0 || ^>=1.4.0.0\n , lukko\n , singleton-bool ^>=0.1.5\n , tasty ^>=1.4.0.1\n , tasty-expected-failure ^>=0.11.1.2 || ^>=0.12.2\n , tasty-hunit ^>=0.10.0.2\n , temporary ^>=1.3\n\n if !impl(ghc >=7.8)\n build-depends: tagged ^>=0.8.5\n\n if os(windows)\n cpp-options: -DHAS_WINDOWS_LOCK\n\n elif (os(linux) && flag(ofd-locking))\n cpp-options: -DHAS_OFD_LOCKING\n cpp-options: -DHAS_FLOCK\n\n elif !(os(solaris) || os(aix))\n cpp-options: -DHAS_FLOCK\n\ntest-suite test-process\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n hs-source-dirs: test\n main-is: TestProcess.hs\n ghc-options: -threaded\n build-depends:\n , base\n , bytestring >=0.9.2.1 && <0.12\n , lukko\n\n if os(windows)\n cpp-options: -DHAS_WINDOWS_LOCK\n\n elif (os(linux) && flag(ofd-locking))\n cpp-options: -DHAS_OFD_LOCKING\n cpp-options: -DHAS_FLOCK\n\n elif !(os(solaris) || os(aix))\n cpp-options: -DHAS_FLOCK\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/network-uri.nix b/materialized/ghc927/cabal-install/cabal-files/network-uri.nix new file mode 100644 index 0000000000..b21388c1cf --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/network-uri.nix @@ -0,0 +1,70 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "network-uri"; version = "2.6.4.1"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ezra@ezrakilty.net"; + author = ""; + homepage = "https://github.com/haskell/network-uri"; + url = ""; + synopsis = "URI manipulation"; + description = "This package provides facilities for parsing and unparsing URIs, and creating\nand resolving relative URI references, closely following the URI spec,\n.\n\n== Backward-compatibility\n\nIn @network-2.6@ the \"Network.URI\" module was split off from the\n@network@ package into this package. If you're using the \"Network.URI\"\nmodule you can be backward compatible and automatically get it from\nthe right package by using the\n\nin your @.cabal@ file's build-depends (along with dependencies for\nboth @network-uri@ and @network@):\n\n> build-depends:\n> network-uri-flag == 0.1.*\n\nOr you can do the same manually by adding this boilerplate to your\n@.cabal@ file:\n\n> flag network-uri\n> description: Get Network.URI from the network-uri package\n> default: True\n>\n> library\n> -- ...\n> if flag(network-uri)\n> build-depends: network-uri >= 2.6, network >= 2.6\n> else\n> build-depends: network-uri < 2.6, network < 2.6\n\nThat is, get the module from either @network < 2.6@ or from\n@network-uri >= 2.6@."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."parsec" or (errorHandler.buildDepError "parsec")) + (hsPkgs."th-compat" or (errorHandler.buildDepError "th-compat")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + ] ++ (pkgs.lib).optional (compiler.isGhc && (compiler.version).lt "7.6") (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")); + buildable = true; + }; + tests = { + "uri" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) + (hsPkgs."network-uri" or (errorHandler.buildDepError "network-uri")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + ]; + buildable = true; + }; + }; + benchmarks = { + "uri-bench" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) + (hsPkgs."network-uri" or (errorHandler.buildDepError "network-uri")) + (hsPkgs."criterion" or (errorHandler.buildDepError "criterion")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/network-uri-2.6.4.1.tar.gz"; + sha256 = "57856db93608a4d419f681b881c9b8d4448800d5a687587dc37e8a9e0b223584"; + }); + }) // { + package-description-override = "name: network-uri\nversion: 2.6.4.1\nsynopsis: URI manipulation\ndescription:\n This package provides facilities for parsing and unparsing URIs, and creating\n and resolving relative URI references, closely following the URI spec,\n .\n .\n == Backward-compatibility\n .\n In @network-2.6@ the \"Network.URI\" module was split off from the\n @network@ package into this package. If you're using the \"Network.URI\"\n module you can be backward compatible and automatically get it from\n the right package by using the\n \n in your @.cabal@ file's build-depends (along with dependencies for\n both @network-uri@ and @network@):\n .\n > build-depends:\n > network-uri-flag == 0.1.*\n .\n Or you can do the same manually by adding this boilerplate to your\n @.cabal@ file:\n .\n > flag network-uri\n > description: Get Network.URI from the network-uri package\n > default: True\n >\n > library\n > -- ...\n > if flag(network-uri)\n > build-depends: network-uri >= 2.6, network >= 2.6\n > else\n > build-depends: network-uri < 2.6, network < 2.6\n .\n That is, get the module from either @network < 2.6@ or from\n @network-uri >= 2.6@.\n\nhomepage: https://github.com/haskell/network-uri\nbug-reports: https://github.com/haskell/network-uri/issues\nlicense: BSD3\nlicense-file: LICENSE\nextra-source-files: README.md, CHANGELOG.md\nmaintainer: ezra@ezrakilty.net\ncategory: Network\nbuild-type: Simple\ncabal-version: >=1.10\ntested-with:\n GHC ==9.0.1\n || ==8.10.1\n || ==8.8.2\n || ==8.6.5\n || ==8.4.4\n || ==8.2.2\n || ==8.0.2\n || ==7.10.3\n || ==7.8.4\n || ==7.6.3\n || ==7.4.2\n || ==7.2.2\n || ==7.0.4\n\nlibrary\n exposed-modules:\n Network.URI\n Network.URI.Lens\n Network.URI.Static\n build-depends:\n base >= 3 && < 5,\n deepseq >= 1.1 && < 1.5,\n parsec >= 3.1.12.0 && < 3.2,\n th-compat >= 0.1.1 && < 1.0\n build-depends: template-haskell\n default-extensions: CPP, DeriveDataTypeable\n if impl(ghc < 7.6)\n build-depends: ghc-prim\n if impl(ghc >= 7.2)\n default-extensions: DeriveGeneric\n ghc-options: -Wall -fwarn-tabs\n default-language: Haskell98\n\ntest-suite uri\n hs-source-dirs: tests\n main-is: uri001.hs\n type: exitcode-stdio-1.0\n\n build-depends:\n base < 5,\n HUnit,\n network-uri,\n tasty,\n tasty-hunit,\n tasty-quickcheck,\n QuickCheck\n\n ghc-options: -Wall -fwarn-tabs\n default-language: Haskell98\n\nbenchmark uri-bench\n hs-source-dirs: tests\n main-is: uri-bench.hs\n type: exitcode-stdio-1.0\n\n build-depends:\n base < 5,\n HUnit,\n network-uri,\n criterion,\n deepseq\n\n ghc-options: -Wall -fwarn-tabs\n default-language: Haskell98\n\nsource-repository head\n type: git\n location: git://github.com/haskell/network-uri.git\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/network.nix b/materialized/ghc927/cabal-install/cabal-files/network.nix new file mode 100644 index 0000000000..6c014c6b9d --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/network.nix @@ -0,0 +1,80 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = { devel = false; }; + package = { + specVersion = "1.18"; + identifier = { name = "network"; version = "3.1.2.7"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "Kazu Yamamoto, Evan Borden"; + author = ""; + homepage = "https://github.com/haskell/network"; + url = ""; + synopsis = "Low-level networking interface"; + description = "This package provides a low-level networking interface.\n\n=== High-Level Packages\nOther packages provide higher level interfaces:\n\n* connection\n* hookup\n* network-simple\n\n=== Extended Packages\n@network@ seeks to provide a cross-platform core for networking. As such some\nAPIs live in extended libraries. Packages in the @network@ ecosystem are\noften prefixed with @network-@.\n\n==== @network-bsd@\nIn @network-3.0.0.0@ the @Network.BSD@ module was split off into its own\npackage, @network-bsd-3.0.0.0@.\n\n==== @network-uri@\nIn @network-2.6@ the @Network.URI@ module was split off into its own package,\n@network-uri-2.6@. If you're using the @Network.URI@ module you can\nautomatically get it from the right package by adding this to your @.cabal@\nfile:\n\n> library\n> build-depends: network-uri-flag"; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + ]; + libs = (pkgs.lib).optionals (system.isSolaris) [ + (pkgs."nsl" or (errorHandler.sysDepError "nsl")) + (pkgs."socket" or (errorHandler.sysDepError "socket")) + ] ++ (pkgs.lib).optionals (system.isWindows) [ + (pkgs."ws2_32" or (errorHandler.sysDepError "ws2_32")) + (pkgs."iphlpapi" or (errorHandler.sysDepError "iphlpapi")) + (pkgs."mswsock" or (errorHandler.sysDepError "mswsock")) + ]; + build-tools = [ + (hsPkgs.buildPackages.hsc2hs.components.exes.hsc2hs or (pkgs.buildPackages.hsc2hs or (errorHandler.buildToolDepError "hsc2hs:hsc2hs"))) + ]; + buildable = true; + }; + tests = { + "spec" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) + (hsPkgs."network" or (errorHandler.buildDepError "network")) + (hsPkgs."temporary" or (errorHandler.buildDepError "temporary")) + (hsPkgs."hspec" or (errorHandler.buildDepError "hspec")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + ]; + build-tools = [ + (hsPkgs.buildPackages.hspec-discover.components.exes.hspec-discover or (pkgs.buildPackages.hspec-discover or (errorHandler.buildToolDepError "hspec-discover:hspec-discover"))) + ]; + buildable = true; + }; + "doctests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."doctest" or (errorHandler.buildDepError "doctest")) + (hsPkgs."network" or (errorHandler.buildDepError "network")) + ]; + buildable = false; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/network-3.1.2.7.tar.gz"; + sha256 = "7f7620fef1a1af3d3d6747f510e73223a5c600e7d7fd9ace073d1222bdc63d85"; + }); + }) // { + package-description-override = "cabal-version: 1.18\nname: network\nversion: 3.1.2.7\nlicense: BSD3\nlicense-file: LICENSE\nmaintainer: Kazu Yamamoto, Evan Borden\nsynopsis: Low-level networking interface\ndescription:\n This package provides a low-level networking interface.\n .\n === High-Level Packages\n Other packages provide higher level interfaces:\n .\n * connection\n * hookup\n * network-simple\n .\n === Extended Packages\n @network@ seeks to provide a cross-platform core for networking. As such some\n APIs live in extended libraries. Packages in the @network@ ecosystem are\n often prefixed with @network-@.\n .\n ==== @network-bsd@\n In @network-3.0.0.0@ the @Network.BSD@ module was split off into its own\n package, @network-bsd-3.0.0.0@.\n .\n ==== @network-uri@\n In @network-2.6@ the @Network.URI@ module was split off into its own package,\n @network-uri-2.6@. If you're using the @Network.URI@ module you can\n automatically get it from the right package by adding this to your @.cabal@\n file:\n .\n > library\n > build-depends: network-uri-flag\ncategory: Network\nbuild-type: Configure\nextra-tmp-files:\n config.log config.status autom4te.cache network.buildinfo\n include/HsNetworkConfig.h\nextra-source-files:\n README.md CHANGELOG.md\n examples/*.hs tests/*.hs config.guess config.sub install-sh\n configure.ac configure\n include/HsNetworkConfig.h.in include/HsNet.h include/HsNetDef.h\n -- C sources only used on some systems\n cbits/asyncAccept.c cbits/initWinSock.c\n cbits/winSockErr.c cbits/cmsg.c\nhomepage: https://github.com/haskell/network\nbug-reports: https://github.com/haskell/network/issues\ntested-with: GHC == 8.0.2\n , GHC == 8.2.2\n , GHC == 8.4.4\n , GHC == 8.6.5\n , GHC == 8.8.3\n , GHC == 8.10.1\n\nflag devel\n description: using tests for developers\n default: False\n\nlibrary\n default-language: Haskell2010\n exposed-modules:\n Network.Socket\n Network.Socket.Address\n Network.Socket.ByteString\n Network.Socket.ByteString.Lazy\n Network.Socket.Internal\n other-modules:\n Network.Socket.Buffer\n Network.Socket.ByteString.IO\n Network.Socket.ByteString.Internal\n Network.Socket.Cbits\n Network.Socket.Fcntl\n Network.Socket.Flag\n Network.Socket.Handle\n Network.Socket.If\n Network.Socket.Imports\n Network.Socket.Info\n Network.Socket.Name\n Network.Socket.Options\n Network.Socket.ReadShow\n Network.Socket.Shutdown\n Network.Socket.SockAddr\n Network.Socket.Syscall\n Network.Socket.Types\n Network.Socket.Unix\n\n build-depends:\n base >= 4.9 && < 5,\n bytestring >= 0.10 && < 0.12,\n deepseq,\n directory\n\n include-dirs: include\n includes: HsNet.h HsNetDef.h alignment.h win32defs.h\n install-includes: HsNet.h HsNetDef.h alignment.h win32defs.h\n c-sources: cbits/HsNet.c cbits/cmsg.c\n ghc-options: -Wall -fwarn-tabs\n build-tools: hsc2hs\n\n\n -- Add some platform specific stuff\n if !os(windows)\n other-modules:\n Network.Socket.ByteString.Lazy.Posix\n Network.Socket.Posix.Cmsg\n Network.Socket.Posix.CmsgHdr\n Network.Socket.Posix.IOVec\n Network.Socket.Posix.MsgHdr\n\n if os(solaris)\n extra-libraries: nsl, socket\n cpp-options: -D__EXTENSIONS__ -D_XOPEN_SOURCE=500\n cc-options: -D__EXTENSIONS__ -D_XOPEN_SOURCE=500\n\n if os(windows)\n other-modules:\n Network.Socket.ByteString.Lazy.Windows\n Network.Socket.Win32.Cmsg\n Network.Socket.Win32.CmsgHdr\n Network.Socket.Win32.WSABuf\n Network.Socket.Win32.MsgHdr\n c-sources: cbits/initWinSock.c, cbits/winSockErr.c, cbits/asyncAccept.c\n extra-libraries: ws2_32, iphlpapi, mswsock\n -- See https://github.com/haskell/network/pull/362\n if impl(ghc >= 7.10)\n cpp-options: -D_WIN32_WINNT=0x0600\n cc-options: -D_WIN32_WINNT=0x0600\n\ntest-suite spec\n default-language: Haskell2010\n hs-source-dirs: tests\n main-is: Spec.hs\n if flag(devel)\n cpp-options: -DDEVELOPMENT\n other-modules:\n Network.Test.Common\n Network.SocketSpec\n Network.Socket.ByteStringSpec\n Network.Socket.ByteString.LazySpec\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded\n -- NB: make sure to versions of hspec and hspec-discover\n -- that work together; easiest way is to constraint\n -- both packages to a small enough version range.\n build-tools: hspec-discover >= 2.6\n build-depends:\n base >= 4.9 && < 5,\n bytestring,\n directory,\n HUnit,\n network,\n temporary,\n hspec >= 2.6,\n QuickCheck\n\ntest-suite doctests\n buildable: False\n default-language: Haskell2010\n hs-source-dirs: tests\n main-is: doctests.hs\n type: exitcode-stdio-1.0\n\n build-depends:\n base >= 4.9 && < 5,\n doctest >= 0.10.1,\n network\n\n ghc-options: -Wall\n\nsource-repository head\n type: git\n location: git://github.com/haskell/network.git\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/random.nix b/materialized/ghc927/cabal-install/cabal-files/random.nix new file mode 100644 index 0000000000..c2f8f753b4 --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/random.nix @@ -0,0 +1,113 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "random"; version = "1.2.1.1"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "core-libraries-committee@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Pseudo-random number generation"; + description = "This package provides basic pseudo-random number generation, including the\nability to split random number generators.\n\n== \"System.Random\": pure pseudo-random number interface\n\nIn pure code, use 'System.Random.uniform' and 'System.Random.uniformR' from\n\"System.Random\" to generate pseudo-random numbers with a pure pseudo-random\nnumber generator like 'System.Random.StdGen'.\n\nAs an example, here is how you can simulate rolls of a six-sided die using\n'System.Random.uniformR':\n\n>>> let roll = uniformR (1, 6) :: RandomGen g => g -> (Word, g)\n>>> let rolls = unfoldr (Just . roll) :: RandomGen g => g -> [Word]\n>>> let pureGen = mkStdGen 42\n>>> take 10 (rolls pureGen) :: [Word]\n[1,1,3,2,4,5,3,4,6,2]\n\nSee \"System.Random\" for more details.\n\n== \"System.Random.Stateful\": monadic pseudo-random number interface\n\nIn monadic code, use 'System.Random.Stateful.uniformM' and\n'System.Random.Stateful.uniformRM' from \"System.Random.Stateful\" to generate\npseudo-random numbers with a monadic pseudo-random number generator, or\nusing a monadic adapter.\n\nAs an example, here is how you can simulate rolls of a six-sided die using\n'System.Random.Stateful.uniformRM':\n\n>>> let rollM = uniformRM (1, 6) :: StatefulGen g m => g -> m Word\n>>> let pureGen = mkStdGen 42\n>>> runStateGen_ pureGen (replicateM 10 . rollM) :: [Word]\n[1,1,3,2,4,5,3,4,6,2]\n\nThe monadic adapter 'System.Random.Stateful.runStateGen_' is used here to lift\nthe pure pseudo-random number generator @pureGen@ into the\n'System.Random.Stateful.StatefulGen' context.\n\nThe monadic interface can also be used with existing monadic pseudo-random\nnumber generators. In this example, we use the one provided in the\n package:\n\n>>> import System.Random.MWC as MWC\n>>> let rollM = uniformRM (1, 6) :: StatefulGen g m => g -> m Word\n>>> monadicGen <- MWC.create\n>>> replicateM 10 (rollM monadicGen) :: IO [Word]\n[2,3,6,6,4,4,3,1,5,4]\n\nSee \"System.Random.Stateful\" for more details."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + (hsPkgs."splitmix" or (errorHandler.buildDepError "splitmix")) + ] ++ (pkgs.lib).optional (compiler.isGhc && (compiler.version).lt "8.0") (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")); + buildable = true; + }; + tests = { + "legacy-test" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + ]; + buildable = true; + }; + "doctests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."doctest" or (errorHandler.buildDepError "doctest")) + ] ++ (pkgs.lib).optionals (compiler.isGhc && (compiler.version).ge "8.2" && (compiler.isGhc && (compiler.version).lt "8.10")) [ + (hsPkgs."mwc-random" or (errorHandler.buildDepError "mwc-random")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."stm" or (errorHandler.buildDepError "stm")) + (hsPkgs."unliftio" or (errorHandler.buildDepError "unliftio")) + (hsPkgs."vector" or (errorHandler.buildDepError "vector")) + ]; + buildable = true; + }; + "spec" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."smallcheck" or (errorHandler.buildDepError "smallcheck")) + (hsPkgs."stm" or (errorHandler.buildDepError "stm")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-smallcheck" or (errorHandler.buildDepError "tasty-smallcheck")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + ]; + buildable = true; + }; + "spec-inspection" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + ] ++ (pkgs.lib).optional (compiler.isGhc && (compiler.version).ge "8.0") (hsPkgs."tasty-inspection-testing" or (errorHandler.buildDepError "tasty-inspection-testing")); + buildable = true; + }; + }; + benchmarks = { + "legacy-bench" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."rdtsc" or (errorHandler.buildDepError "rdtsc")) + (hsPkgs."split" or (errorHandler.buildDepError "split")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + ]; + buildable = true; + }; + "bench" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."splitmix" or (errorHandler.buildDepError "splitmix")) + (hsPkgs."tasty-bench" or (errorHandler.buildDepError "tasty-bench")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/random-1.2.1.1.tar.gz"; + sha256 = "3e1272f7ed6a4d7bd1712b90143ec326fee9b225789222379fea20a9c90c9b76"; + }); + }) // { + package-description-override = "cabal-version: >=1.10\nname: random\nversion: 1.2.1.1\nlicense: BSD3\nlicense-file: LICENSE\nmaintainer: core-libraries-committee@haskell.org\nbug-reports: https://github.com/haskell/random/issues\nsynopsis: Pseudo-random number generation\ndescription:\n This package provides basic pseudo-random number generation, including the\n ability to split random number generators.\n .\n == \"System.Random\": pure pseudo-random number interface\n .\n In pure code, use 'System.Random.uniform' and 'System.Random.uniformR' from\n \"System.Random\" to generate pseudo-random numbers with a pure pseudo-random\n number generator like 'System.Random.StdGen'.\n .\n As an example, here is how you can simulate rolls of a six-sided die using\n 'System.Random.uniformR':\n .\n >>> let roll = uniformR (1, 6) :: RandomGen g => g -> (Word, g)\n >>> let rolls = unfoldr (Just . roll) :: RandomGen g => g -> [Word]\n >>> let pureGen = mkStdGen 42\n >>> take 10 (rolls pureGen) :: [Word]\n [1,1,3,2,4,5,3,4,6,2]\n .\n See \"System.Random\" for more details.\n .\n == \"System.Random.Stateful\": monadic pseudo-random number interface\n .\n In monadic code, use 'System.Random.Stateful.uniformM' and\n 'System.Random.Stateful.uniformRM' from \"System.Random.Stateful\" to generate\n pseudo-random numbers with a monadic pseudo-random number generator, or\n using a monadic adapter.\n .\n As an example, here is how you can simulate rolls of a six-sided die using\n 'System.Random.Stateful.uniformRM':\n .\n >>> let rollM = uniformRM (1, 6) :: StatefulGen g m => g -> m Word\n >>> let pureGen = mkStdGen 42\n >>> runStateGen_ pureGen (replicateM 10 . rollM) :: [Word]\n [1,1,3,2,4,5,3,4,6,2]\n .\n The monadic adapter 'System.Random.Stateful.runStateGen_' is used here to lift\n the pure pseudo-random number generator @pureGen@ into the\n 'System.Random.Stateful.StatefulGen' context.\n .\n The monadic interface can also be used with existing monadic pseudo-random\n number generators. In this example, we use the one provided in the\n package:\n .\n >>> import System.Random.MWC as MWC\n >>> let rollM = uniformRM (1, 6) :: StatefulGen g m => g -> m Word\n >>> monadicGen <- MWC.create\n >>> replicateM 10 (rollM monadicGen) :: IO [Word]\n [2,3,6,6,4,4,3,1,5,4]\n .\n See \"System.Random.Stateful\" for more details.\n\ncategory: System\nbuild-type: Simple\nextra-source-files:\n README.md\n CHANGELOG.md\ntested-with: GHC == 7.10.2\n , GHC == 7.10.3\n , GHC == 8.0.2\n , GHC == 8.2.2\n , GHC == 8.4.3\n , GHC == 8.4.4\n , GHC == 8.6.3\n , GHC == 8.6.4\n , GHC == 8.6.5\n , GHC == 8.8.1\n , GHC == 8.8.2\n , GHC == 8.10.1\n\nsource-repository head\n type: git\n location: https://github.com/haskell/random.git\n\n\nlibrary\n exposed-modules:\n System.Random\n System.Random.Internal\n System.Random.Stateful\n other-modules:\n System.Random.GFinite\n\n hs-source-dirs: src\n default-language: Haskell2010\n ghc-options:\n -Wall\n if impl(ghc >= 8.0)\n ghc-options:\n -Wincomplete-record-updates -Wincomplete-uni-patterns\n\n build-depends:\n base >=4.8 && <5,\n bytestring >=0.10.4 && <0.12,\n deepseq >=1.1 && <2,\n mtl >=2.2 && <2.4,\n splitmix >=0.1 && <0.2\n if impl(ghc < 8.0)\n build-depends:\n transformers\n\ntest-suite legacy-test\n type: exitcode-stdio-1.0\n main-is: Legacy.hs\n hs-source-dirs: test-legacy\n other-modules:\n T7936\n TestRandomIOs\n TestRandomRs\n Random1283\n RangeTest\n\n default-language: Haskell2010\n ghc-options: -with-rtsopts=-M8M\n if impl(ghc >= 8.0)\n ghc-options:\n -Wno-deprecations\n build-depends:\n base,\n containers >=0.5 && <0.7,\n random\n\ntest-suite doctests\n type: exitcode-stdio-1.0\n main-is: doctests.hs\n hs-source-dirs: test\n default-language: Haskell2010\n build-depends:\n base,\n doctest >=0.15 && <0.21\n if impl(ghc >= 8.2) && impl(ghc < 8.10)\n build-depends:\n mwc-random >=0.13 && <0.16,\n primitive >=0.6 && <0.8,\n random,\n stm,\n unliftio >=0.2 && <0.3,\n vector >= 0.10 && <0.14\n\ntest-suite spec\n type: exitcode-stdio-1.0\n main-is: Spec.hs\n hs-source-dirs: test\n other-modules:\n Spec.Range\n Spec.Run\n Spec.Stateful\n\n default-language: Haskell2010\n ghc-options: -Wall\n build-depends:\n base,\n bytestring,\n random,\n smallcheck >=1.2 && <1.3,\n stm,\n tasty >=1.0 && <1.5,\n tasty-smallcheck >=0.8 && <0.9,\n tasty-hunit >=0.10 && <0.11,\n transformers\n\n-- Note. Fails when compiled with coverage:\n-- https://github.com/haskell/random/issues/107\ntest-suite spec-inspection\n type: exitcode-stdio-1.0\n main-is: Spec.hs\n hs-source-dirs: test-inspection\n build-depends:\n\n default-language: Haskell2010\n ghc-options: -Wall\n build-depends:\n base,\n random,\n tasty >=1.0 && <1.5\n if impl(ghc >= 8.0)\n build-depends:\n tasty-inspection-testing\n other-modules:\n Spec.Inspection\n\nbenchmark legacy-bench\n type: exitcode-stdio-1.0\n main-is: SimpleRNGBench.hs\n hs-source-dirs: bench-legacy\n other-modules: BinSearch\n default-language: Haskell2010\n ghc-options:\n -Wall -O2 -threaded -rtsopts -with-rtsopts=-N\n if impl(ghc >= 8.0)\n ghc-options:\n -Wno-deprecations\n\n build-depends:\n base,\n random,\n rdtsc,\n split >=0.2 && <0.3,\n time >=1.4 && <1.13\n\nbenchmark bench\n type: exitcode-stdio-1.0\n main-is: Main.hs\n hs-source-dirs: bench\n default-language: Haskell2010\n ghc-options: -Wall -O2\n build-depends:\n base,\n mtl,\n primitive >= 0.7.1,\n random,\n splitmix >=0.1 && <0.2,\n tasty-bench\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/regex-base.nix b/materialized/ghc927/cabal-install/cabal-files/regex-base.nix new file mode 100644 index 0000000000..7c2da31be7 --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/regex-base.nix @@ -0,0 +1,47 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "1.12"; + identifier = { name = "regex-base"; version = "0.94.0.2"; }; + license = "BSD-3-Clause"; + copyright = "Copyright (c) 2006, Christopher Kuklewicz"; + maintainer = "Andreas Abel"; + author = "Christopher Kuklewicz"; + homepage = "https://wiki.haskell.org/Regular_expressions"; + url = ""; + synopsis = "Common \"Text.Regex.*\" API for Regex matching"; + description = "This package does not provide the ability to do regular expression matching.\nInstead, it provides the type classes that constitute the abstract API\nthat is implemented by @regex-*@ backends such as:\n\n* \n\n* \n\n* \n\n* \n\n* \n\nSee also for more information."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = ([ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + ] ++ (pkgs.lib).optionals (compiler.isGhc && (compiler.version).ge "7.4") [ + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + ]) ++ (pkgs.lib).optional (!(compiler.isGhc && (compiler.version).ge "8")) (hsPkgs."fail" or (errorHandler.buildDepError "fail")); + buildable = true; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/regex-base-0.94.0.2.tar.gz"; + sha256 = "7b99408f580f5bb67a1c413e0bc735886608251331ad36322020f2169aea2ef1"; + }); + }) // { + package-description-override = "cabal-version: 1.12\nname: regex-base\nversion: 0.94.0.2\nx-revision: 1\n\nbuild-type: Simple\nlicense: BSD3\nlicense-file: LICENSE\ncopyright: Copyright (c) 2006, Christopher Kuklewicz\nauthor: Christopher Kuklewicz\nmaintainer: Andreas Abel\nhomepage: https://wiki.haskell.org/Regular_expressions\nbug-reports: https://github.com/haskell-hvr/regex-base/issues\nsynopsis: Common \"Text.Regex.*\" API for Regex matching\ncategory: Text\ndescription:\n This package does not provide the ability to do regular expression matching.\n Instead, it provides the type classes that constitute the abstract API\n that is implemented by @regex-*@ backends such as:\n .\n * \n .\n * \n .\n * \n .\n * \n .\n * \n .\n See also for more information.\n\nextra-source-files:\n ChangeLog.md\n README.md\n\ntested-with:\n GHC == 9.4.1\n GHC == 9.2.2\n GHC == 9.0.2\n GHC == 8.10.7\n GHC == 8.8.4\n GHC == 8.6.5\n GHC == 8.4.4\n GHC == 8.2.2\n GHC == 8.0.2\n GHC == 7.10.3\n GHC == 7.8.4\n GHC == 7.6.3\n GHC == 7.4.2\n GHC == 7.2.2\n GHC == 7.0.4\n\nsource-repository head\n type: git\n location: https://github.com/haskell-hvr/regex-base.git\n\nsource-repository this\n type: git\n location: https://github.com/haskell-hvr/regex-base.git\n tag: v0.94.0.2\n\nlibrary\n hs-source-dirs: src\n\n exposed-modules:\n Text.Regex.Base\n Text.Regex.Base.RegexLike\n Text.Regex.Base.Context\n Text.Regex.Base.Impl\n\n other-modules:\n Paths_regex_base\n\n default-language: Haskell2010\n other-extensions:\n MultiParamTypeClasses\n FunctionalDependencies\n TypeSynonymInstances\n FlexibleInstances\n FlexibleContexts\n\n if impl(ghc >= 7.4)\n default-extensions: Safe\n build-depends: containers >= 0.4.2.1\n , bytestring >= 0.9.2.1\n\n build-depends: base >= 4.3 && < 5\n , containers >= 0.4 && < 0.7\n , bytestring >= 0.9 && < 0.12\n , array >= 0.3 && < 0.6\n , text >= 1.2.3 && < 1.3 || >=2.0 && <2.1\n\n if !impl(ghc >= 8)\n build-depends: fail == 4.9.*\n\n ghc-options: -Wall\n if impl(ghc >= 8)\n ghc-options: -Wcompat\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/regex-posix.nix b/materialized/ghc927/cabal-install/cabal-files/regex-posix.nix new file mode 100644 index 0000000000..5e1f121ba9 --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/regex-posix.nix @@ -0,0 +1,44 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = { _regex-posix-clib = false; }; + package = { + specVersion = "1.12"; + identifier = { name = "regex-posix"; version = "0.96.0.1"; }; + license = "BSD-3-Clause"; + copyright = "Copyright (c) 2007-2010, Christopher Kuklewicz"; + maintainer = "Andreas Abel"; + author = "Christopher Kuklewicz"; + homepage = ""; + url = ""; + synopsis = "POSIX Backend for \"Text.Regex\" (regex-base)"; + description = "The POSIX regex backend for .\n\nThe main appeal of this backend is that it's very lightweight due to its reliance on the ubiquitous facility that is provided by the standard C library on most POSIX platforms.\n\nSee also for more information."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = ([ + (hsPkgs."regex-base" or (errorHandler.buildDepError "regex-base")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + ] ++ (pkgs.lib).optional (flags._regex-posix-clib || system.isWindows) (hsPkgs."regex-posix-clib" or (errorHandler.buildDepError "regex-posix-clib"))) ++ (pkgs.lib).optional (compiler.isGhc && (compiler.version).lt "8") (hsPkgs."fail" or (errorHandler.buildDepError "fail")); + buildable = true; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/regex-posix-0.96.0.1.tar.gz"; + sha256 = "c7827c391919227711e1cff0a762b1678fd8739f9c902fc183041ff34f59259c"; + }); + }) // { + package-description-override = "cabal-version: 1.12\nname: regex-posix\nversion: 0.96.0.1\nx-revision: 1\n\nbuild-type: Simple\nlicense: BSD3\nlicense-file: LICENSE\ncopyright: Copyright (c) 2007-2010, Christopher Kuklewicz\nauthor: Christopher Kuklewicz\nmaintainer: Andreas Abel\nbug-reports: https://github.com/haskell-hvr/regex-posix\nsynopsis: POSIX Backend for \"Text.Regex\" (regex-base)\ncategory: Text\ndescription:\n The POSIX regex backend for .\n .\n The main appeal of this backend is that it's very lightweight due to its reliance on the ubiquitous facility that is provided by the standard C library on most POSIX platforms.\n .\n See also for more information.\n\nextra-source-files:\n ChangeLog.md\n cbits/myfree.h\n\ntested-with:\n GHC == 9.4.1\n GHC == 9.2.2\n GHC == 9.0.2\n GHC == 8.10.7\n GHC == 8.8.4\n GHC == 8.6.5\n GHC == 8.4.4\n GHC == 8.2.2\n GHC == 8.0.2\n GHC == 7.10.3\n GHC == 7.8.4\n GHC == 7.6.3\n GHC == 7.4.2\n GHC == 7.2.2\n GHC == 7.0.4\n\nsource-repository head\n type: git\n location: https://github.com/hvr/regex-posix.git\n\nsource-repository this\n type: git\n location: https://github.com/hvr/regex-base.git\n tag: v0.96.0.1-r1\n\nflag _regex-posix-clib\n manual: False\n default: False\n description: Use package (used by default on Windows)\n\nlibrary\n hs-source-dirs: src\n exposed-modules:\n Text.Regex.Posix\n Text.Regex.Posix.Wrap\n Text.Regex.Posix.String\n Text.Regex.Posix.Sequence\n Text.Regex.Posix.ByteString\n Text.Regex.Posix.ByteString.Lazy\n\n other-modules:\n Paths_regex_posix\n\n c-sources: cbits/myfree.c\n include-dirs: cbits\n\n if flag(_regex-posix-clib) || os(windows)\n build-depends: regex-posix-clib == 2.7.*\n -- Otherwise, use POSIX.2 regex implementation from @libc@.\n -- However, Windows/msys2 doesn't provide a POSIX.2 regex impl in its @libc@.\n\n default-language: Haskell2010\n default-extensions:\n MultiParamTypeClasses\n FunctionalDependencies\n ForeignFunctionInterface\n GeneralizedNewtypeDeriving\n FlexibleContexts\n TypeSynonymInstances\n -- ^ for ghc 7.0, subsumed under FlexibleInstances later\n FlexibleInstances\n\n build-depends: regex-base == 0.94.*\n , base >= 4.3 && < 5\n , containers >= 0.4 && < 0.7\n , bytestring >= 0.9 && < 0.12\n , array >= 0.3 && < 0.6\n\n if impl(ghc < 8)\n build-depends: fail == 4.9.*\n\n -- Warnings\n\n ghc-options:\n -Wall\n -fno-warn-unused-imports\n\n if impl(ghc >= 8)\n ghc-options:\n -Wcompat\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/resolv.nix b/materialized/ghc927/cabal-install/cabal-files/resolv.nix new file mode 100644 index 0000000000..f550110b3e --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/resolv.nix @@ -0,0 +1,58 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "2.2"; + identifier = { name = "resolv"; version = "0.1.2.0"; }; + license = "GPL-2.0-or-later"; + copyright = ""; + maintainer = "hvr@gnu.org"; + author = "Herbert Valerio Riedel"; + homepage = ""; + url = ""; + synopsis = "Domain Name Service (DNS) lookup via the libresolv standard library routines"; + description = "This package implements an API for accessing\nthe [Domain Name Service (DNS)](https://tools.ietf.org/html/rfc1035)\nresolver service via the standard @libresolv@ system library (whose\nAPI is often available directly via the standard @libc@ C library) on\nUnix systems.\n\nThis package also includes support for decoding message record types\nas defined in the following RFCs:\n\n- [RFC 1035](https://tools.ietf.org/html/rfc1035): Domain Names - Implementation And Specification\n- [RFC 1183](https://tools.ietf.org/html/rfc1183): New DNS RR Definitions\n- [RFC 2782](https://tools.ietf.org/html/rfc2782): A DNS RR for specifying the location of services (DNS SRV)\n- [RFC 2915](https://tools.ietf.org/html/rfc2915): The Naming Authority Pointer (NAPTR) DNS Resource Record\n- [RFC 3596](https://tools.ietf.org/html/rfc3596): DNS Extensions to Support IP Version 6\n- [RFC 4034](https://tools.ietf.org/html/rfc4034): Resource Records for the DNS Security Extensions\n- [RFC 4255](https://tools.ietf.org/html/rfc4255): Using DNS to Securely Publish Secure Shell (SSH) Key Fingerprints\n- [RFC 4408](https://tools.ietf.org/html/rfc4408): Sender Policy Framework (SPF) for Authorizing Use of Domains in E-Mail, Version 1\n- [RFC 5155](https://tools.ietf.org/html/rfc5155): DNS Security (DNSSEC) Hashed Authenticated Denial of Existence\n- [RFC 6844](https://tools.ietf.org/html/rfc6844): DNS Certification Authority Authorization (CAA) Resource Record\n- [RFC 6891](https://tools.ietf.org/html/rfc6891): Extension Mechanisms for DNS (EDNS(0))\n- [RFC 7553](https://tools.ietf.org/html/rfc7553): The Uniform Resource Identifier (URI) DNS Resource Record\n\nFor Windows, the package [windns](https://hackage.haskell.org/package/windns)\nprovides a compatible subset of this package's API."; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."base16-bytestring" or (errorHandler.buildDepError "base16-bytestring")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + ]; + buildable = true; + }; + tests = { + "resolv." = { + depends = [ + (hsPkgs."resolv" or (errorHandler.buildDepError "resolv")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/resolv-0.1.2.0.tar.gz"; + sha256 = "81a2bafad484db123cf8d17a02d98bb388a127fd0f822fa022589468a0e64671"; + }); + }) // { + package-description-override = "cabal-version: 2.2\r\n\r\nname: resolv\r\nversion: 0.1.2.0\r\nx-revision: 5\r\n\r\nsynopsis: Domain Name Service (DNS) lookup via the libresolv standard library routines\r\ndescription: {\r\n\r\nThis package implements an API for accessing\r\nthe [Domain Name Service (DNS)](https://tools.ietf.org/html/rfc1035)\r\nresolver service via the standard @libresolv@ system library (whose\r\nAPI is often available directly via the standard @libc@ C library) on\r\nUnix systems.\r\n.\r\nThis package also includes support for decoding message record types\r\nas defined in the following RFCs:\r\n.\r\n- [RFC 1035](https://tools.ietf.org/html/rfc1035): Domain Names - Implementation And Specification\r\n- [RFC 1183](https://tools.ietf.org/html/rfc1183): New DNS RR Definitions\r\n- [RFC 2782](https://tools.ietf.org/html/rfc2782): A DNS RR for specifying the location of services (DNS SRV)\r\n- [RFC 2915](https://tools.ietf.org/html/rfc2915): The Naming Authority Pointer (NAPTR) DNS Resource Record\r\n- [RFC 3596](https://tools.ietf.org/html/rfc3596): DNS Extensions to Support IP Version 6\r\n- [RFC 4034](https://tools.ietf.org/html/rfc4034): Resource Records for the DNS Security Extensions\r\n- [RFC 4255](https://tools.ietf.org/html/rfc4255): Using DNS to Securely Publish Secure Shell (SSH) Key Fingerprints\r\n- [RFC 4408](https://tools.ietf.org/html/rfc4408): Sender Policy Framework (SPF) for Authorizing Use of Domains in E-Mail, Version 1\r\n- [RFC 5155](https://tools.ietf.org/html/rfc5155): DNS Security (DNSSEC) Hashed Authenticated Denial of Existence\r\n- [RFC 6844](https://tools.ietf.org/html/rfc6844): DNS Certification Authority Authorization (CAA) Resource Record\r\n- [RFC 6891](https://tools.ietf.org/html/rfc6891): Extension Mechanisms for DNS (EDNS(0))\r\n- [RFC 7553](https://tools.ietf.org/html/rfc7553): The Uniform Resource Identifier (URI) DNS Resource Record\r\n.\r\nFor Windows, the package [windns](https://hackage.haskell.org/package/windns)\r\nprovides a compatible subset of this package's API.\r\n}\r\n\r\nlicense: GPL-2.0-or-later\r\nlicense-files: LICENSE LICENSE.GPLv2 LICENSE.GPLv3\r\nauthor: Herbert Valerio Riedel\r\nmaintainer: hvr@gnu.org\r\ncategory: Network\r\nbuild-type: Configure\r\nbug-reports: https://github.com/hvr/resolv/issues\r\nextra-source-files: ChangeLog.md\r\n\r\nextra-source-files: cbits/hs_resolv.h\r\n cbits/hs_resolv_config.h.in\r\n testdata/msg/*.bin\r\n testdata/msg/*.show\r\n resolv.buildinfo.in\r\n configure\r\n\r\nextra-tmp-files: autom4te.cache\r\n config.log\r\n config.status\r\n resolv.buildinfo\r\n cbits/hs_resolv_config.h\r\n\r\ntested-with:\r\n GHC ==8.10.1\r\n || ==8.8.3\r\n || ==8.6.5\r\n || ==8.4.4\r\n || ==8.2.2\r\n || ==8.0.2\r\n || ==7.10.3\r\n || ==7.10.1\r\n || ==7.8.4\r\n || ==7.6.3\r\n || ==7.4.2\r\n\r\nsource-repository head\r\n type: git\r\n location: https://github.com/hvr/resolv.git\r\n\r\nlibrary\r\n default-language: Haskell2010\r\n other-extensions: BangPatterns\r\n CApiFFI\r\n CPP\r\n DeriveDataTypeable\r\n DeriveFoldable\r\n DeriveFunctor\r\n DeriveTraversable\r\n GeneralizedNewtypeDeriving\r\n OverloadedStrings\r\n RecordWildCards\r\n Trustworthy\r\n\r\n hs-source-dirs: src\r\n exposed-modules: Network.DNS\r\n other-modules: Network.DNS.Message\r\n Network.DNS.FFI\r\n Compat\r\n\r\n -- we need binary-0.7.3 for isolate\r\n build-depends: base >= 4.5 && <4.18\r\n , base16-bytestring ^>= 0.1 || ^>=1.0.0.0\r\n , binary ^>=0.7.3 || ^>= 0.8\r\n , bytestring ^>=0.9.2 || ^>= 0.10 || ^>= 0.11\r\n , containers ^>=0.4.2.1 || ^>= 0.5 || ^>= 0.6\r\n\r\n ghc-options: -Wall\r\n include-dirs: cbits\r\n\r\ntest-suite resolv.\r\n default-language: Haskell2010\r\n hs-source-dirs: src-test\r\n main-is: Tests1.hs\r\n type: exitcode-stdio-1.0\r\n\r\n -- dependencies whose version constraints are inherited via lib:resolv component\r\n build-depends: resolv\r\n , base\r\n , bytestring\r\n\r\n -- additional dependencies not inherited\r\n build-depends: tasty ^>= 1.2.3 || ^>=1.3.1\r\n , tasty-hunit ^>= 0.10.0\r\n , directory ^>= 1.1.0 || ^>= 1.2.0 || ^>= 1.3.0\r\n , filepath ^>= 1.3.0 || ^>= 1.4.0\r\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/safe-exceptions.nix b/materialized/ghc927/cabal-install/cabal-files/safe-exceptions.nix new file mode 100644 index 0000000000..8d5861b4e9 --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/safe-exceptions.nix @@ -0,0 +1,55 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "safe-exceptions"; version = "0.1.7.3"; }; + license = "MIT"; + copyright = "2016 FP Complete"; + maintainer = "michael@fpcomplete.com"; + author = "Michael Snoyman"; + homepage = "https://github.com/fpco/safe-exceptions#readme"; + url = ""; + synopsis = "Safe, consistent, and easy exception handling"; + description = "Please see README.md"; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."exceptions" or (errorHandler.buildDepError "exceptions")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + ]; + buildable = true; + }; + tests = { + "safe-exceptions-test" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."hspec" or (errorHandler.buildDepError "hspec")) + (hsPkgs."safe-exceptions" or (errorHandler.buildDepError "safe-exceptions")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."void" or (errorHandler.buildDepError "void")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/safe-exceptions-0.1.7.3.tar.gz"; + sha256 = "91ce28d8f8a6efd31788d4827ed5cdcb9a546ad4053a86c56f7947c66a30b5bf"; + }); + }) // { + package-description-override = "name: safe-exceptions\nversion: 0.1.7.3\nsynopsis: Safe, consistent, and easy exception handling\ndescription: Please see README.md\nhomepage: https://github.com/fpco/safe-exceptions#readme\nlicense: MIT\nlicense-file: LICENSE\nauthor: Michael Snoyman\nmaintainer: michael@fpcomplete.com\ncopyright: 2016 FP Complete\ncategory: Control\nbuild-type: Simple\nextra-source-files: README.md ChangeLog.md COOKBOOK.md\ncabal-version: >=1.10\n\nlibrary\n hs-source-dirs: src\n exposed-modules: Control.Exception.Safe\n build-depends: base >= 4.11 && < 5\n , deepseq >= 1.2 && < 1.5\n , exceptions >= 0.10 && < 0.11\n , transformers >= 0.2 && < 0.7\n default-language: Haskell2010\n\ntest-suite safe-exceptions-test\n type: exitcode-stdio-1.0\n hs-source-dirs: test\n main-is: Spec.hs\n other-modules: Control.Exception.SafeSpec\n build-depends: base\n , hspec\n , safe-exceptions\n , transformers\n , void\n ghc-options: -threaded -rtsopts -with-rtsopts=-N\n default-language: Haskell2010\n\nsource-repository head\n type: git\n location: https://github.com/fpco/safe-exceptions\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/splitmix.nix b/materialized/ghc927/cabal-install/cabal-files/splitmix.nix new file mode 100644 index 0000000000..38134b30eb --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/splitmix.nix @@ -0,0 +1,140 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = { optimised-mixer = false; }; + package = { + specVersion = "1.10"; + identifier = { name = "splitmix"; version = "0.1.0.4"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "Oleg Grenrus "; + author = ""; + homepage = ""; + url = ""; + synopsis = "Fast Splittable PRNG"; + description = "Pure Haskell implementation of SplitMix described in\n\nGuy L. Steele, Jr., Doug Lea, and Christine H. Flood. 2014.\nFast splittable pseudorandom number generators. In Proceedings\nof the 2014 ACM International Conference on Object Oriented\nProgramming Systems Languages & Applications (OOPSLA '14). ACM,\nNew York, NY, USA, 453-472. DOI:\n\n\nThe paper describes a new algorithm /SplitMix/ for /splittable/\npseudorandom number generator that is quite fast: 9 64 bit arithmetic/logical\noperations per 64 bits generated.\n\n/SplitMix/ is tested with two standard statistical test suites (DieHarder and\nTestU01, this implementation only using the former) and it appears to be\nadequate for \"everyday\" use, such as Monte Carlo algorithms and randomized\ndata structures where speed is important.\n\nIn particular, it __should not be used for cryptographic or security applications__,\nbecause generated sequences of pseudorandom values are too predictable\n(the mixing functions are easily inverted, and two successive outputs\nsuffice to reconstruct the internal state)."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + ] ++ (pkgs.lib).optionals (!(compiler.isGhcjs && true)) ((pkgs.lib).optional (!(compiler.isGhc && true)) (hsPkgs."time" or (errorHandler.buildDepError "time"))); + buildable = true; + }; + tests = { + "examples" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) + (hsPkgs."splitmix" or (errorHandler.buildDepError "splitmix")) + ]; + buildable = true; + }; + "splitmix-tests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."base-compat" or (errorHandler.buildDepError "base-compat")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) + (hsPkgs."math-functions" or (errorHandler.buildDepError "math-functions")) + (hsPkgs."splitmix" or (errorHandler.buildDepError "splitmix")) + (hsPkgs."test-framework" or (errorHandler.buildDepError "test-framework")) + (hsPkgs."test-framework-hunit" or (errorHandler.buildDepError "test-framework-hunit")) + ]; + buildable = true; + }; + "montecarlo-pi" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."splitmix" or (errorHandler.buildDepError "splitmix")) + ]; + buildable = true; + }; + "montecarlo-pi-32" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."splitmix" or (errorHandler.buildDepError "splitmix")) + ]; + buildable = true; + }; + "splitmix-dieharder" = { + depends = [ + (hsPkgs."async" or (errorHandler.buildDepError "async")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."base-compat-batteries" or (errorHandler.buildDepError "base-compat-batteries")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."splitmix" or (errorHandler.buildDepError "splitmix")) + (hsPkgs."tf-random" or (errorHandler.buildDepError "tf-random")) + (hsPkgs."vector" or (errorHandler.buildDepError "vector")) + ]; + buildable = true; + }; + "splitmix-testu01" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."base-compat-batteries" or (errorHandler.buildDepError "base-compat-batteries")) + (hsPkgs."splitmix" or (errorHandler.buildDepError "splitmix")) + ]; + libs = [ (pkgs."testu01" or (errorHandler.sysDepError "testu01")) ]; + buildable = if !system.isLinux then false else true; + }; + "initialization" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) + (hsPkgs."splitmix" or (errorHandler.buildDepError "splitmix")) + ]; + buildable = true; + }; + }; + benchmarks = { + "comparison" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."criterion" or (errorHandler.buildDepError "criterion")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."splitmix" or (errorHandler.buildDepError "splitmix")) + (hsPkgs."tf-random" or (errorHandler.buildDepError "tf-random")) + ]; + buildable = true; + }; + "simple-sum" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."splitmix" or (errorHandler.buildDepError "splitmix")) + ]; + buildable = true; + }; + "range" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."clock" or (errorHandler.buildDepError "clock")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."splitmix" or (errorHandler.buildDepError "splitmix")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/splitmix-0.1.0.4.tar.gz"; + sha256 = "6d065402394e7a9117093dbb4530a21342c9b1e2ec509516c8a8d0ffed98ecaa"; + }); + }) // { + package-description-override = "cabal-version: >=1.10\nname: splitmix\nversion: 0.1.0.4\nx-revision: 1\nsynopsis: Fast Splittable PRNG\ndescription:\n Pure Haskell implementation of SplitMix described in\n .\n Guy L. Steele, Jr., Doug Lea, and Christine H. Flood. 2014.\n Fast splittable pseudorandom number generators. In Proceedings\n of the 2014 ACM International Conference on Object Oriented\n Programming Systems Languages & Applications (OOPSLA '14). ACM,\n New York, NY, USA, 453-472. DOI:\n \n .\n The paper describes a new algorithm /SplitMix/ for /splittable/\n pseudorandom number generator that is quite fast: 9 64 bit arithmetic/logical\n operations per 64 bits generated.\n .\n /SplitMix/ is tested with two standard statistical test suites (DieHarder and\n TestU01, this implementation only using the former) and it appears to be\n adequate for \"everyday\" use, such as Monte Carlo algorithms and randomized\n data structures where speed is important.\n .\n In particular, it __should not be used for cryptographic or security applications__,\n because generated sequences of pseudorandom values are too predictable\n (the mixing functions are easily inverted, and two successive outputs\n suffice to reconstruct the internal state).\n\nlicense: BSD3\nlicense-file: LICENSE\nmaintainer: Oleg Grenrus \nbug-reports: https://github.com/haskellari/splitmix/issues\ncategory: System, Random\nbuild-type: Simple\ntested-with:\n GHC ==7.0.4\n || ==7.2.2\n || ==7.4.2\n || ==7.6.3\n || ==7.8.4\n || ==7.10.3\n || ==8.0.2\n || ==8.2.2\n || ==8.4.4\n || ==8.6.5\n || ==8.8.4\n || ==8.10.4\n || ==9.0.2\n || ==9.2.4\n || ==9.4.1\n , GHCJS ==8.4\n\nextra-source-files:\n Changelog.md\n make-hugs.sh\n README.md\n test-hugs.sh\n\nflag optimised-mixer\n description: Use JavaScript for mix32\n manual: True\n default: False\n\nlibrary\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: src src-compat\n exposed-modules:\n System.Random.SplitMix\n System.Random.SplitMix32\n\n other-modules:\n Data.Bits.Compat\n System.Random.SplitMix.Init\n\n -- dump-core\n -- build-depends: dump-core\n -- ghc-options: -fplugin=DumpCore -fplugin-opt DumpCore:core-html\n\n build-depends:\n base >=4.3 && <4.18\n , deepseq >=1.3.0.0 && <1.5\n\n if flag(optimised-mixer)\n cpp-options: -DOPTIMISED_MIX32=1\n\n -- We don't want to depend on time, nor unix or Win32 packages\n -- because it's valuable that splitmix and QuickCheck doesn't\n -- depend on about anything\n\n if impl(ghcjs)\n cpp-options: -DSPLITMIX_INIT_GHCJS=1\n\n else\n if impl(ghc)\n cpp-options: -DSPLITMIX_INIT_C=1\n\n if os(windows)\n c-sources: cbits-win/init.c\n\n else\n c-sources: cbits-unix/init.c\n\n else\n cpp-options: -DSPLITMIX_INIT_COMPAT=1\n build-depends: time >=1.2.0.3 && <1.13\n\nsource-repository head\n type: git\n location: https://github.com/haskellari/splitmix.git\n\nbenchmark comparison\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench\n main-is: Bench.hs\n build-depends:\n base\n , containers >=0.4.2.1 && <0.7\n , criterion >=1.1.0.0 && <1.6\n , random\n , splitmix\n , tf-random >=0.5 && <0.6\n\nbenchmark simple-sum\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench\n main-is: SimpleSum.hs\n build-depends:\n base\n , random\n , splitmix\n\nbenchmark range\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench src-compat\n main-is: Range.hs\n other-modules: Data.Bits.Compat\n build-depends:\n base\n , clock >=0.8 && <0.9\n , random\n , splitmix\n\ntest-suite examples\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: Examples.hs\n build-depends:\n base\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , splitmix\n\ntest-suite splitmix-tests\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: Tests.hs\n other-modules:\n MiniQC\n Uniformity\n\n build-depends:\n base\n , base-compat >=0.11.1 && <0.13\n , containers >=0.4.0.0 && <0.7\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , math-functions ==0.1.7.0 || >=0.3.3.0 && <0.4\n , splitmix\n , test-framework >=0.8.2.0 && <0.9\n , test-framework-hunit >=0.3.0.2 && <0.4\n\ntest-suite montecarlo-pi\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: SplitMixPi.hs\n build-depends:\n base\n , splitmix\n\ntest-suite montecarlo-pi-32\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: SplitMixPi32.hs\n build-depends:\n base\n , splitmix\n\ntest-suite splitmix-dieharder\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: Dieharder.hs\n build-depends:\n async >=2.2.1 && <2.3\n , base\n , base-compat-batteries >=0.10.5 && <0.13\n , bytestring >=0.9.1.8 && <0.12\n , deepseq\n , process >=1.0.1.5 && <1.7\n , random\n , splitmix\n , tf-random >=0.5 && <0.6\n , vector >=0.11.0.0 && <0.13\n\ntest-suite splitmix-testu01\n if !os(linux)\n buildable: False\n\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: TestU01.hs\n c-sources: tests/cbits/testu01.c\n extra-libraries: testu01\n build-depends:\n base\n , base-compat-batteries >=0.10.5 && <0.13\n , splitmix\n\ntest-suite initialization\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: Initialization.hs\n build-depends:\n base\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , splitmix\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/tar.nix b/materialized/ghc927/cabal-install/cabal-files/tar.nix new file mode 100644 index 0000000000..6ee54907fc --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/tar.nix @@ -0,0 +1,106 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = { old-time = false; old-bytestring = false; }; + package = { + specVersion = "1.12"; + identifier = { name = "tar"; version = "0.5.1.1"; }; + license = "BSD-3-Clause"; + copyright = "2007 Bjorn Bringert \n2008-2016 Duncan Coutts "; + maintainer = "Duncan Coutts "; + author = "Duncan Coutts \nBjorn Bringert "; + homepage = ""; + url = ""; + synopsis = "Reading, writing and manipulating \".tar\" archive files."; + description = "This library is for working with \\\"@.tar@\\\" archive files. It\ncan read and write a range of common variations of archive\nformat including V7, POSIX USTAR and GNU formats.\n\nIt provides support for packing and unpacking portable\narchives. This makes it suitable for distribution but not\nbackup because details like file ownership and exact\npermissions are not preserved.\n\nIt also provides features for random access to archive\ncontent using an index."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = (([ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + ] ++ (if flags.old-time + then [ + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."old-time" or (errorHandler.buildDepError "old-time")) + ] + else [ + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + ])) ++ (if flags.old-bytestring + then [ + (hsPkgs."bytestring-builder" or (errorHandler.buildDepError "bytestring-builder")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + ] + else [ + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + ])) ++ (pkgs.lib).optional (!(compiler.isGhc && (compiler.version).ge "8.0")) (hsPkgs."semigroups" or (errorHandler.buildDepError "semigroups")); + buildable = true; + }; + tests = { + "properties" = { + depends = (([ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."bytestring-handle" or (errorHandler.buildDepError "bytestring-handle")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + ] ++ (if flags.old-time + then [ + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."old-time" or (errorHandler.buildDepError "old-time")) + ] + else [ + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + ])) ++ (if flags.old-bytestring + then [ + (hsPkgs."bytestring-builder" or (errorHandler.buildDepError "bytestring-builder")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + ] + else [ + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + ])) ++ (pkgs.lib).optional (!(compiler.isGhc && (compiler.version).ge "8.0")) (hsPkgs."semigroups" or (errorHandler.buildDepError "semigroups")); + buildable = true; + }; + }; + benchmarks = { + "bench" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."criterion" or (errorHandler.buildDepError "criterion")) + ] ++ (pkgs.lib).optional (!(compiler.isGhc && (compiler.version).ge "8.0")) (hsPkgs."semigroups" or (errorHandler.buildDepError "semigroups")); + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/tar-0.5.1.1.tar.gz"; + sha256 = "b384449f62b2b0aa3e6d2cb1004b8060b01f21ec93e7b63e7af6d8fad8a9f1de"; + }); + }) // { + package-description-override = "cabal-version: 1.12\r\nname: tar\r\nversion: 0.5.1.1\r\nx-revision: 5\r\n\r\nlicense: BSD3\r\nlicense-file: LICENSE\r\nauthor: Duncan Coutts \r\n Bjorn Bringert \r\nmaintainer: Duncan Coutts \r\nbug-reports: https://github.com/haskell/tar/issues\r\ncopyright: 2007 Bjorn Bringert \r\n 2008-2016 Duncan Coutts \r\ncategory: Codec\r\nsynopsis: Reading, writing and manipulating \".tar\" archive files.\r\ndescription: This library is for working with \\\"@.tar@\\\" archive files. It\r\n can read and write a range of common variations of archive\r\n format including V7, POSIX USTAR and GNU formats.\r\n .\r\n It provides support for packing and unpacking portable\r\n archives. This makes it suitable for distribution but not\r\n backup because details like file ownership and exact\r\n permissions are not preserved.\r\n .\r\n It also provides features for random access to archive\r\n content using an index.\r\nbuild-type: Simple\r\nextra-source-files: changelog.md\r\ntested-with: GHC==7.0.4, GHC==7.2.2, GHC==7.4.2, GHC==7.6.3,\r\n GHC==7.8.4, GHC==7.10.3, GHC==8.0.2, GHC==8.2.2, GHC==8.4.4,\r\n GHC==8.6.5, GHC==8.8.3, GHC==8.10.4, GHC==9.0.1\r\n\r\nsource-repository head\r\n type: git\r\n location: https://github.com/haskell/tar.git\r\n\r\nflag old-time\r\n default: False\r\n\r\nflag old-bytestring\r\n default: False\r\n\r\nlibrary\r\n\r\n build-depends: base >= 4 && < 4.18,\r\n filepath < 1.5,\r\n array < 0.6,\r\n containers >= 0.2 && < 0.7,\r\n deepseq >= 1.1 && < 1.5\r\n\r\n if flag(old-time)\r\n build-depends: directory < 1.2, old-time < 1.2\r\n else\r\n build-depends: directory >= 1.2 && < 1.4, time < 1.13\r\n\r\n if flag(old-bytestring)\r\n build-depends: bytestring-builder >= 0.10.4.0.2 && < 0.11, bytestring == 0.9.*\r\n else\r\n build-depends: bytestring >= 0.10 && < 0.12\r\n\r\n if !impl(ghc >= 8.0)\r\n build-depends: semigroups >= 0.18 && < 0.20\r\n\r\n exposed-modules:\r\n Codec.Archive.Tar\r\n Codec.Archive.Tar.Entry\r\n Codec.Archive.Tar.Check\r\n Codec.Archive.Tar.Index\r\n\r\n other-modules:\r\n Codec.Archive.Tar.Types\r\n Codec.Archive.Tar.Read\r\n Codec.Archive.Tar.Write\r\n Codec.Archive.Tar.Pack\r\n Codec.Archive.Tar.Unpack\r\n Codec.Archive.Tar.Index.StringTable\r\n Codec.Archive.Tar.Index.IntTrie\r\n\r\n default-language: Haskell2010\r\n -- Previously, the package used GHC's default Haskell mode which implies\r\n -- NDI; so we keep it transitionally enabled here until we've reviewed the\r\n -- code to make sure there isn't any code relies on NDI and keeps compiling\r\n -- albeit with different semantics even without NDI\r\n default-extensions: NondecreasingIndentation\r\n\r\n other-extensions:\r\n BangPatterns\r\n CPP\r\n DeriveDataTypeable\r\n GeneralizedNewtypeDeriving\r\n PatternGuards\r\n ScopedTypeVariables\r\n\r\n\r\n ghc-options: -Wall -fno-warn-unused-imports\r\n\r\ntest-suite properties\r\n type: exitcode-stdio-1.0\r\n build-depends: base,\r\n filepath,\r\n array,\r\n containers,\r\n deepseq,\r\n bytestring-handle,\r\n QuickCheck == 2.*,\r\n tasty >= 0.10 && <1.5,\r\n tasty-quickcheck >= 0.8 && <0.11\r\n\r\n if flag(old-time)\r\n build-depends: directory < 1.2, old-time\r\n else\r\n build-depends: directory >= 1.2, time\r\n\r\n if flag(old-bytestring)\r\n build-depends: bytestring-builder, bytestring >= 0.9 && <0.10\r\n else\r\n build-depends: bytestring >= 0.10\r\n\r\n if !impl(ghc >= 8.0)\r\n build-depends: semigroups >= 0.18 && <0.20\r\n\r\n default-language: Haskell2010\r\n\r\n hs-source-dirs: . test\r\n\r\n main-is: test/Properties.hs\r\n cpp-options: -DTESTS\r\n\r\n other-modules:\r\n Codec.Archive.Tar.Index\r\n Codec.Archive.Tar.Index.StringTable\r\n Codec.Archive.Tar.Index.IntTrie\r\n\r\n -- shared w/ lib:tar component\r\n other-modules:\r\n Codec.Archive.Tar\r\n Codec.Archive.Tar.Check\r\n Codec.Archive.Tar.Pack\r\n Codec.Archive.Tar.Read\r\n Codec.Archive.Tar.Types\r\n Codec.Archive.Tar.Unpack\r\n Codec.Archive.Tar.Write\r\n\r\n other-extensions:\r\n CPP\r\n BangPatterns,\r\n DeriveDataTypeable\r\n ScopedTypeVariables\r\n\r\n ghc-options: -fno-ignore-asserts\r\n\r\nbenchmark bench\r\n type: exitcode-stdio-1.0\r\n hs-source-dirs: . bench\r\n main-is: bench/Main.hs\r\n build-depends: base,\r\n bytestring >= 0.10,\r\n filepath,\r\n directory >= 1.2,\r\n array,\r\n containers,\r\n deepseq,\r\n time,\r\n criterion >= 1.0\r\n\r\n if !impl(ghc >= 8.0)\r\n build-depends: semigroups >= 0.18 && <0.20\r\n\r\n default-language: Haskell2010\r\n\r\n -- shared w/ lib:tar component\r\n other-modules:\r\n Codec.Archive.Tar\r\n Codec.Archive.Tar.Check\r\n Codec.Archive.Tar.Index\r\n Codec.Archive.Tar.Index.IntTrie\r\n Codec.Archive.Tar.Index.StringTable\r\n Codec.Archive.Tar.Pack\r\n Codec.Archive.Tar.Read\r\n Codec.Archive.Tar.Types\r\n Codec.Archive.Tar.Unpack\r\n Codec.Archive.Tar.Write\r\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/th-compat.nix b/materialized/ghc927/cabal-install/cabal-files/th-compat.nix new file mode 100644 index 0000000000..c0a648df75 --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/th-compat.nix @@ -0,0 +1,63 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "th-compat"; version = "0.1.4"; }; + license = "BSD-3-Clause"; + copyright = "(C) 2020 Ryan Scott"; + maintainer = "Ryan Scott "; + author = "Ryan Scott"; + homepage = "https://github.com/haskell-compat/th-compat"; + url = ""; + synopsis = "Backward- (and forward-)compatible Quote and Code types"; + description = "This package defines a \"Language.Haskell.TH.Syntax.Compat\"\nmodule, which backports the @Quote@ and @Code@ types to\nwork across a wide range of @template-haskell@ versions.\nThe @makeRelativeToProject@ utility is also backported.\nOn recent versions of @template-haskell@ (2.17.0.0 or\nlater), this module simply reexports definitions\nfrom \"Language.Haskell.TH.Syntax\". Refer to the Haddocks\nfor \"Language.Haskell.TH.Syntax.Compat\" for examples of\nhow to use this module."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = ([ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + ] ++ (pkgs.lib).optionals (!(compiler.isGhc && (compiler.version).ge "8.0")) [ + (hsPkgs."fail" or (errorHandler.buildDepError "fail")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + ]) ++ (pkgs.lib).optionals (!(compiler.isGhc && (compiler.version).ge "9.4")) [ + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + ]; + buildable = true; + }; + tests = { + "spec" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."base-compat" or (errorHandler.buildDepError "base-compat")) + (hsPkgs."hspec" or (errorHandler.buildDepError "hspec")) + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."th-compat" or (errorHandler.buildDepError "th-compat")) + ]; + build-tools = [ + (hsPkgs.buildPackages.hspec-discover.components.exes.hspec-discover or (pkgs.buildPackages.hspec-discover or (errorHandler.buildToolDepError "hspec-discover:hspec-discover"))) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/th-compat-0.1.4.tar.gz"; + sha256 = "d8f97ac14ab47b6b8a7b0fdb4ff95426322ec56badd01652ac15da4a44d4bab8"; + }); + }) // { + package-description-override = "cabal-version: >=1.10\nname: th-compat\nversion: 0.1.4\nsynopsis: Backward- (and forward-)compatible Quote and Code types\ndescription: This package defines a \"Language.Haskell.TH.Syntax.Compat\"\n module, which backports the @Quote@ and @Code@ types to\n work across a wide range of @template-haskell@ versions.\n The @makeRelativeToProject@ utility is also backported.\n On recent versions of @template-haskell@ (2.17.0.0 or\n later), this module simply reexports definitions\n from \"Language.Haskell.TH.Syntax\". Refer to the Haddocks\n for \"Language.Haskell.TH.Syntax.Compat\" for examples of\n how to use this module.\nhomepage: https://github.com/haskell-compat/th-compat\nbug-reports: https://github.com/haskell-compat/th-compat/issues\nlicense: BSD3\nlicense-file: LICENSE\nauthor: Ryan Scott\nmaintainer: Ryan Scott \ncopyright: (C) 2020 Ryan Scott\ncategory: Text\nbuild-type: Simple\ntested-with: GHC == 7.0.4\n , GHC == 7.2.2\n , GHC == 7.4.2\n , GHC == 7.6.3\n , GHC == 7.8.4\n , GHC == 7.10.3\n , GHC == 8.0.2\n , GHC == 8.2.2\n , GHC == 8.4.4\n , GHC == 8.6.5\n , GHC == 8.8.4\n , GHC == 8.10.7\n , GHC == 9.0.2\n , GHC == 9.2.3\n , GHC == 9.4.1\nextra-source-files: CHANGELOG.md, README.md\n\nsource-repository head\n type: git\n location: https://github.com/haskell-compat/th-compat\n\nlibrary\n exposed-modules: Language.Haskell.TH.Syntax.Compat\n build-depends: base >= 4.3 && < 5\n , template-haskell >= 2.5 && < 2.20\n if !impl(ghc >= 8.0)\n build-depends: fail == 4.9.*\n , transformers >= 0.2 && < 0.7\n if !impl(ghc >= 9.4)\n build-depends: filepath >= 1.2.0.0 && < 1.5\n , directory >= 1.1.0.0 && < 1.4\n hs-source-dirs: src\n default-language: Haskell2010\n ghc-options: -Wall\n if impl(ghc >= 8.6)\n ghc-options: -Wno-star-is-type\n\ntest-suite spec\n type: exitcode-stdio-1.0\n main-is: Spec.hs\n other-modules: Language.Haskell.TH.Syntax.CompatSpec\n Types\n build-depends: base >= 4.3 && < 5\n , base-compat >= 0.6 && < 0.13\n , hspec >= 2 && < 3\n , mtl >= 2.1 && < 2.4\n , template-haskell >= 2.5 && < 2.20\n , th-compat\n build-tool-depends: hspec-discover:hspec-discover >= 2\n hs-source-dirs: tests\n default-language: Haskell2010\n ghc-options: -Wall -threaded -rtsopts\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/cabal-files/zlib.nix b/materialized/ghc927/cabal-install/cabal-files/zlib.nix new file mode 100644 index 0000000000..22f1df6993 --- /dev/null +++ b/materialized/ghc927/cabal-install/cabal-files/zlib.nix @@ -0,0 +1,60 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = { + non-blocking-ffi = false; + pkg-config = false; + bundled-c-zlib = false; + }; + package = { + specVersion = "1.10"; + identifier = { name = "zlib"; version = "0.6.3.0"; }; + license = "BSD-3-Clause"; + copyright = "(c) 2006-2016 Duncan Coutts"; + maintainer = "Duncan Coutts , Andrew Lelechenko , Emily Pillmore , Herbert Valerio Riedel "; + author = "Duncan Coutts "; + homepage = ""; + url = ""; + synopsis = "Compression and decompression in the gzip and zlib formats"; + description = "This package provides a pure interface for compressing and\ndecompressing streams of data represented as lazy\n'ByteString's. It uses the\n\nso it has high performance. It supports the \\\"zlib\\\",\n\\\"gzip\\\" and \\\"raw\\\" compression formats.\n\nIt provides a convenient high level API suitable for most\ntasks and for the few cases where more control is needed it\nprovides access to the full zlib feature set."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + ] ++ (pkgs.lib).optional (compiler.isGhc && ((compiler.version).ge "7.0" && (compiler.version).lt "8.0.3")) (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")); + libs = (pkgs.lib).optionals (!(flags.pkg-config && !(compiler.isGhcjs && true) && !system.isGhcjs)) ((pkgs.lib).optional (!system.isWindows && !flags.bundled-c-zlib && !(compiler.isGhcjs && true) && !system.isGhcjs) (pkgs."z" or (errorHandler.sysDepError "z"))); + pkgconfig = (pkgs.lib).optional (flags.pkg-config && !(compiler.isGhcjs && true) && !system.isGhcjs) (pkgconfPkgs."zlib" or (errorHandler.pkgConfDepError "zlib")); + buildable = true; + }; + tests = { + "tests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."zlib" or (errorHandler.buildDepError "zlib")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + ]; + buildable = true; + }; + }; + }; + } // { + src = (pkgs.lib).mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/zlib-0.6.3.0.tar.gz"; + sha256 = "9eaa989ad4534438b5beb51c1d3a4c8f6a088fdff0b259a5394fbf39aaee04da"; + }); + }) // { + package-description-override = "cabal-version: >= 1.10\nname: zlib\nversion: 0.6.3.0\n\ncopyright: (c) 2006-2016 Duncan Coutts\nlicense: BSD3\nlicense-file: LICENSE\nauthor: Duncan Coutts \nmaintainer: Duncan Coutts , Andrew Lelechenko , Emily Pillmore , Herbert Valerio Riedel \nbug-reports: https://github.com/haskell/zlib/issues\ncategory: Codec\nsynopsis: Compression and decompression in the gzip and zlib formats\ndescription: This package provides a pure interface for compressing and\n decompressing streams of data represented as lazy\n 'ByteString's. It uses the\n \n so it has high performance. It supports the \\\"zlib\\\",\n \\\"gzip\\\" and \\\"raw\\\" compression formats.\n .\n It provides a convenient high level API suitable for most\n tasks and for the few cases where more control is needed it\n provides access to the full zlib feature set.\nbuild-type: Simple\n\ntested-with: GHC == 7.0.4\n , GHC == 7.2.2\n , GHC == 7.4.2\n , GHC == 7.6.3\n , GHC == 7.8.4\n , GHC == 7.10.3\n , GHC == 8.0.2\n , GHC == 8.2.2\n , GHC == 8.4.4\n , GHC == 8.6.5\n , GHC == 8.8.4\n , GHC == 8.10.7\n , GHC == 9.0.2\n , GHC == 9.2.2\n\nextra-source-files: changelog\n README.md\n -- zlib C sources (for Windows)\n cbits/crc32.h cbits/inffast.h cbits/inflate.h\n cbits/trees.h cbits/deflate.h cbits/inffixed.h\n cbits/inftrees.h cbits/zutil.h cbits/gzguts.h\n -- test data files\n test/data/bad-crc.gz test/data/custom-dict.zlib\n test/data/custom-dict.zlib-dict test/data/hello.gz\n test/data/not-gzip test/data/two-files.gz\n -- demo programs:\n examples/gzip.hs examples/gunzip.hs\n\nsource-repository head\n type: git\n location: https://github.com/haskell/zlib.git\n\nflag non-blocking-ffi\n default: False\n manual: True\n description: The (de)compression calls can sometimes take a long time, which\n prevents other Haskell threads running. Enabling this flag\n avoids this unfairness, but with greater overall cost.\n\nflag pkg-config\n default: False\n manual: True\n description: Use @pkg-config(1)@ to locate foreign @zlib@ library.\n\nflag bundled-c-zlib\n default: False\n manual: True\n description: Use the bundled zlib C sources. Requires pkg-config to be False.\n For windows, this is the default.\n\n\nlibrary\n exposed-modules: Codec.Compression.GZip,\n Codec.Compression.Zlib,\n Codec.Compression.Zlib.Raw,\n Codec.Compression.Zlib.Internal\n other-modules: Codec.Compression.Zlib.Stream,\n Codec.Compression.Zlib.ByteStringCompat\n\n if impl(ghc < 7)\n default-language: Haskell98\n default-extensions: PatternGuards\n else\n default-language: Haskell2010\n\n other-extensions: CPP, ForeignFunctionInterface, RankNTypes, BangPatterns,\n DeriveDataTypeable\n if impl(ghc >= 7.2)\n other-extensions: DeriveGeneric\n if impl(ghc >= 7.6)\n other-extensions: CApiFFI\n\n build-depends: base >= 4 && < 4.18,\n bytestring >= 0.9 && < 0.12\n if impl(ghc >= 7.0 && < 8.0.3)\n build-depends: ghc-prim\n\n includes: zlib.h\n ghc-options: -Wall -fwarn-tabs\n if flag(non-blocking-ffi)\n cpp-options: -DNON_BLOCKING_FFI\n if flag(pkg-config) && !impl(ghcjs) && !os(ghcjs)\n -- NB: pkg-config is available on windows as well when using msys2\n pkgconfig-depends: zlib\n else\n -- don't use pkg-config\n if !os(windows) && !flag(bundled-c-zlib) && !impl(ghcjs) && !os(ghcjs)\n -- Normally we use the the standard system zlib.\n extra-libraries: z\n else\n -- However for the benefit of users of Windows (which does not have zlib\n -- by default) we bundle a complete copy of the C sources of zlib-1.2.11\n c-sources: cbits/adler32.c cbits/compress.c cbits/crc32.c\n cbits/deflate.c cbits/infback.c\n cbits/inffast.c cbits/inflate.c cbits/inftrees.c\n cbits/trees.c cbits/uncompr.c cbits/zutil.c\n include-dirs: cbits\n install-includes: zlib.h zconf.h\n\ntest-suite tests\n type: exitcode-stdio-1.0\n main-is: Test.hs\n other-modules: Utils,\n Test.Codec.Compression.Zlib.Internal,\n Test.Codec.Compression.Zlib.Stream\n hs-source-dirs: test\n default-language: Haskell2010\n build-depends: base, bytestring, zlib,\n QuickCheck == 2.*,\n tasty >= 0.8 && < 1.5,\n tasty-quickcheck >= 0.8 && < 0.11\n ghc-options: -Wall\n"; + } \ No newline at end of file diff --git a/materialized/ghc927/cabal-install/default.nix b/materialized/ghc927/cabal-install/default.nix new file mode 100644 index 0000000000..2a49aa6e4f --- /dev/null +++ b/materialized/ghc927/cabal-install/default.nix @@ -0,0 +1,190 @@ +{ + pkgs = hackage: + { + packages = { + Cabal-syntax.revision = import ./cabal-files/Cabal-syntax.nix; + bytestring.revision = (((hackage.bytestring)."0.11.4.0").revisions).default; + safe-exceptions.revision = import ./cabal-files/safe-exceptions.nix; + echo.revision = import ./cabal-files/echo.nix; + echo.flags.example = false; + exceptions.revision = (((hackage.exceptions)."0.10.4").revisions).default; + directory.revision = (((hackage.directory)."1.3.6.2").revisions).default; + tar.revision = import ./cabal-files/tar.nix; + tar.flags.old-bytestring = false; + tar.flags.old-time = false; + filepath.revision = (((hackage.filepath)."1.4.2.2").revisions).default; + network.revision = import ./cabal-files/network.nix; + network.flags.devel = false; + mtl.revision = (((hackage.mtl)."2.2.2").revisions).default; + HTTP.revision = import ./cabal-files/HTTP.nix; + HTTP.flags.warp-tests = false; + HTTP.flags.network-uri = true; + HTTP.flags.conduit10 = false; + HTTP.flags.warn-as-error = false; + ghc-bignum.revision = (((hackage.ghc-bignum)."1.2").revisions).default; + zlib.revision = import ./cabal-files/zlib.nix; + zlib.flags.non-blocking-ffi = false; + zlib.flags.bundled-c-zlib = false; + zlib.flags.pkg-config = false; + ghc-prim.revision = (((hackage.ghc-prim)."0.8.0").revisions).default; + base16-bytestring.revision = import ./cabal-files/base16-bytestring.nix; + parsec.revision = (((hackage.parsec)."3.1.15.0").revisions).default; + lukko.revision = import ./cabal-files/lukko.nix; + lukko.flags.ofd-locking = true; + Cabal.revision = import ./cabal-files/Cabal.nix; + splitmix.revision = import ./cabal-files/splitmix.nix; + splitmix.flags.optimised-mixer = false; + ed25519.revision = import ./cabal-files/ed25519.nix; + ed25519.flags.test-hlint = true; + ed25519.flags.test-properties = true; + ed25519.flags.no-donna = true; + ed25519.flags.test-doctests = true; + containers.revision = (((hackage.containers)."0.6.5.1").revisions).default; + stm.revision = (((hackage.stm)."2.5.0.2").revisions).default; + regex-posix.revision = import ./cabal-files/regex-posix.nix; + regex-posix.flags._regex-posix-clib = false; + network-uri.revision = import ./cabal-files/network-uri.nix; + base.revision = (((hackage.base)."4.16.4.0").revisions).default; + time.revision = (((hackage.time)."1.11.1.1").revisions).default; + hackage-security.revision = import ./cabal-files/hackage-security.nix; + hackage-security.flags.cabal-syntax = true; + hackage-security.flags.base48 = true; + hackage-security.flags.lukko = true; + hackage-security.flags.use-network-uri = true; + hackage-security.flags.old-directory = false; + hackage-security.flags.mtl21 = false; + hsc2hs.revision = import ./cabal-files/hsc2hs.nix; + hsc2hs.flags.in-ghc-tree = false; + async.revision = import ./cabal-files/async.nix; + async.flags.bench = false; + random.revision = import ./cabal-files/random.nix; + deepseq.revision = (((hackage.deepseq)."1.4.6.1").revisions).default; + rts.revision = (((hackage.rts)."1.0.2").revisions).default; + edit-distance.revision = import ./cabal-files/edit-distance.nix; + template-haskell.revision = (((hackage.template-haskell)."2.18.0.0").revisions).default; + binary.revision = (((hackage.binary)."0.8.9.0").revisions).default; + base64-bytestring.revision = import ./cabal-files/base64-bytestring.nix; + regex-base.revision = import ./cabal-files/regex-base.nix; + process.revision = (((hackage.process)."1.6.16.0").revisions).default; + unix.revision = (((hackage.unix)."2.7.2.2").revisions).default; + transformers.revision = (((hackage.transformers)."0.5.6.2").revisions).default; + cabal-install-solver.revision = import ./cabal-files/cabal-install-solver.nix; + cabal-install-solver.flags.debug-conflict-sets = false; + cabal-install-solver.flags.debug-expensive-assertions = false; + cabal-install-solver.flags.debug-tracetree = false; + text.revision = (((hackage.text)."1.2.5.0").revisions).default; + th-compat.revision = import ./cabal-files/th-compat.nix; + array.revision = (((hackage.array)."0.5.4.0").revisions).default; + ghc-boot-th.revision = (((hackage.ghc-boot-th)."9.2.7").revisions).default; + resolv.revision = import ./cabal-files/resolv.nix; + pretty.revision = (((hackage.pretty)."1.1.3.6").revisions).default; + hashable.revision = import ./cabal-files/hashable.nix; + hashable.flags.containers = true; + hashable.flags.random-initial-seed = false; + hashable.flags.integer-gmp = true; + cryptohash-sha256.revision = import ./cabal-files/cryptohash-sha256.nix; + cryptohash-sha256.flags.exe = false; + cryptohash-sha256.flags.use-cbits = true; + }; + compiler = { + version = "9.2.7"; + nix-name = "ghc927"; + packages = { + "pretty" = "1.1.3.6"; + "text" = "1.2.5.0"; + "array" = "0.5.4.0"; + "mtl" = "2.2.2"; + "parsec" = "3.1.15.0"; + "bytestring" = "0.11.4.0"; + "filepath" = "1.4.2.2"; + "stm" = "2.5.0.2"; + "ghc-prim" = "0.8.0"; + "ghc-boot-th" = "9.2.7"; + "base" = "4.16.4.0"; + "time" = "1.11.1.1"; + "process" = "1.6.16.0"; + "ghc-bignum" = "1.2"; + "directory" = "1.3.6.2"; + "exceptions" = "0.10.4"; + "rts" = "1.0.2"; + "transformers" = "0.5.6.2"; + "template-haskell" = "2.18.0.0"; + "deepseq" = "1.4.6.1"; + "unix" = "2.7.2.2"; + "binary" = "0.8.9.0"; + "containers" = "0.6.5.1"; + }; + }; + }; + extras = hackage: + { packages = { cabal-install = ./.plan.nix/cabal-install.nix; }; }; + modules = [ + ({ lib, ... }: + { + packages = { + "cabal-install" = { + flags = { + "lukko" = lib.mkOverride 900 true; + "native-dns" = lib.mkOverride 900 true; + }; + }; + }; + }) + ({ lib, ... }: + { + packages = { + "Cabal-syntax".components.library.planned = lib.mkOverride 900 true; + "base16-bytestring".components.library.planned = lib.mkOverride 900 true; + "echo".components.library.planned = lib.mkOverride 900 true; + "filepath".components.library.planned = lib.mkOverride 900 true; + "ed25519".components.library.planned = lib.mkOverride 900 true; + "pretty".components.library.planned = lib.mkOverride 900 true; + "Cabal".components.library.planned = lib.mkOverride 900 true; + "bytestring".components.library.planned = lib.mkOverride 900 true; + "zlib".components.library.planned = lib.mkOverride 900 true; + "cryptohash-sha256".components.library.planned = lib.mkOverride 900 true; + "exceptions".components.library.planned = lib.mkOverride 900 true; + "safe-exceptions".components.library.planned = lib.mkOverride 900 true; + "ghc-prim".components.library.planned = lib.mkOverride 900 true; + "array".components.library.planned = lib.mkOverride 900 true; + "cabal-install".components.library.planned = lib.mkOverride 900 true; + "binary".components.library.planned = lib.mkOverride 900 true; + "ghc-boot-th".components.library.planned = lib.mkOverride 900 true; + "splitmix".components.library.planned = lib.mkOverride 900 true; + "rts".components.library.planned = lib.mkOverride 900 true; + "unix".components.library.planned = lib.mkOverride 900 true; + "hsc2hs".components.exes."hsc2hs".planned = lib.mkOverride 900 true; + "resolv".components.library.planned = lib.mkOverride 900 true; + "edit-distance".components.library.planned = lib.mkOverride 900 true; + "regex-base".components.library.planned = lib.mkOverride 900 true; + "directory".components.library.planned = lib.mkOverride 900 true; + "time".components.library.planned = lib.mkOverride 900 true; + "network".components.library.planned = lib.mkOverride 900 true; + "cabal-install-solver".components.library.planned = lib.mkOverride 900 true; + "ghc-bignum".components.library.planned = lib.mkOverride 900 true; + "network-uri".components.library.planned = lib.mkOverride 900 true; + "regex-posix".components.library.planned = lib.mkOverride 900 true; + "HTTP".components.library.planned = lib.mkOverride 900 true; + "process".components.library.planned = lib.mkOverride 900 true; + "template-haskell".components.library.planned = lib.mkOverride 900 true; + "stm".components.library.planned = lib.mkOverride 900 true; + "async".components.library.planned = lib.mkOverride 900 true; + "th-compat".components.library.planned = lib.mkOverride 900 true; + "mtl".components.library.planned = lib.mkOverride 900 true; + "transformers".components.library.planned = lib.mkOverride 900 true; + "tar".components.library.planned = lib.mkOverride 900 true; + "parsec".components.library.planned = lib.mkOverride 900 true; + "deepseq".components.library.planned = lib.mkOverride 900 true; + "hackage-security".components.library.planned = lib.mkOverride 900 true; + "text".components.library.planned = lib.mkOverride 900 true; + "random".components.library.planned = lib.mkOverride 900 true; + "base".components.library.planned = lib.mkOverride 900 true; + "containers".components.library.planned = lib.mkOverride 900 true; + "lukko".components.library.planned = lib.mkOverride 900 true; + "base64-bytestring".components.library.planned = lib.mkOverride 900 true; + "hashable".components.library.planned = lib.mkOverride 900 true; + "cabal-install".components.exes."cabal".planned = lib.mkOverride 900 true; + }; + }) + ]; + } \ No newline at end of file