Chores

Fixes #106

.gitlab-ci.yml

@@ -1,3 +1,8 @@
+stages:
+  - hlint
+  - test
+  - release
+
 variables:
   GIT_SSL_NO_VERIFY: "1"
 
@@ -14,7 +19,7 @@ variables:
     - x86_64-linux
   variables:
     OS: "LINUX"
-    BIT: "64"
+    ARCH: "64"
 
 .alpine:64bit:
   image: "alpine:3.12"
@@ -22,7 +27,7 @@ variables:
     - x86_64-linux
   variables:
     OS: "LINUX"
-    BIT: "64"
+    ARCH: "64"
 
 .alpine:32bit:
   image: "i386/alpine:3.12"
@@ -30,21 +35,37 @@ variables:
     - x86_64-linux
   variables:
     OS: "LINUX"
-    BIT: "32"
+    ARCH: "32"
+
+.linux:armv7:
+  image: "arm32v7/fedora"
+  tags:
+    - armv7-linux
+  variables:
+    OS: "LINUX"
+    ARCH: "ARM"
+
+.linux:aarch64:
+  image: "arm64v8/fedora"
+  tags:
+    - aarch64-linux
+  variables:
+    OS: "LINUX"
+    ARCH: "ARM64"
 
 .darwin:
   tags:
     - x86_64-darwin
   variables:
     OS: "DARWIN"
-    BIT: "64"
+    ARCH: "64"
 
 .freebsd:
   tags:
     - x86_64-freebsd
   variables:
     OS: "FREEBSD"
-    BIT: "64"
+    ARCH: "64"
 
 .root_cleanup:
   after_script:
@@ -81,6 +102,20 @@ variables:
   before_script:
     - ./.gitlab/before_script/linux/alpine/install_deps.sh
 
+.test_ghcup_version:armv7:
+  extends:
+    - .test_ghcup_version
+    - .linux:armv7
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps_manual.sh
+
+.test_ghcup_version:aarch64:
+  extends:
+    - .test_ghcup_version
+    - .linux:aarch64
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps_manual.sh
+
 .test_ghcup_version:darwin:
   extends:
     - .test_ghcup_version
@@ -106,88 +141,131 @@ variables:
       - out
   only:
     - tags
+  variables:
+    JSON_VERSION: "0.0.4"
 
 ######## stack test ########
 
 test:linux:stack:
+  stage: test
   before_script:
     - ./.gitlab/before_script/linux/install_deps_minimal.sh
   script:
     - ./.gitlab/script/ghcup_stack.sh
   extends:
     - .debian
+  needs: []
 
 ######## bootstrap test ########
 
 test:linux:bootstrap_script:
+  stage: test
   before_script:
     - ./.gitlab/before_script/linux/install_deps_minimal.sh
   script:
     - ./.gitlab/script/ghcup_bootstrap.sh
   variables:
-    GHC_VERSION: "8.8.4"
-    CABAL_VERSION: "3.2.0.0"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
   extends:
     - .debian
+  needs: []
 
 ######## linux test ########
 
 test:linux:recommended:
+  stage: test
   extends: .test_ghcup_version:linux
   variables:
-    GHC_VERSION: "8.8.4"
-    CABAL_VERSION: "3.2.0.0"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  needs: []
 
 test:linux:latest:
+  stage: test
   extends: .test_ghcup_version:linux
   variables:
-    GHC_VERSION: "8.10.2"
-    CABAL_VERSION: "3.2.0.0"
-  allow_failure: true
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  needs: []
 
 ######## linux 32bit test ########
 
 test:linux:recommended:32bit:
+  stage: test
   extends: .test_ghcup_version:linux32
   variables:
-    GHC_VERSION: "8.8.4"
+    GHC_VERSION: "8.10.4"
     CABAL_VERSION: "3.2.0.0"
+  needs: []
+
+######## arm tests ########
+
+test:linux:recommended:armv7:
+  stage: test
+  extends: .test_ghcup_version:armv7
+  variables:
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  when: manual
+  needs: []
+
+test:linux:recommended:aarch64:
+  stage: test
+  extends: .test_ghcup_version:aarch64
+  variables:
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  when: manual
+  needs: []
 
 ######## darwin test ########
 
 test:mac:recommended:
+  stage: test
   extends: .test_ghcup_version:darwin
   variables:
-    GHC_VERSION: "8.8.4"
-    CABAL_VERSION: "3.2.0.0"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  needs: []
 
 test:mac:latest:
+  stage: test
   extends: .test_ghcup_version:darwin
   variables:
-    GHC_VERSION: "8.10.2"
-    CABAL_VERSION: "3.2.0.0"
-  allow_failure: true
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  needs: []
 
 
 ######## freebsd test ########
 
 test:freebsd:recommended:
+  stage: test
   extends: .test_ghcup_version:freebsd
   variables:
-    GHC_VERSION: "8.8.4"
-    CABAL_VERSION: "3.2.0.0"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  allow_failure: true # freebsd runners are unreliable
+  when: manual
+  needs: []
 
 test:freebsd:latest:
+  stage: test
   extends: .test_ghcup_version:freebsd
   variables:
-    GHC_VERSION: "8.10.2"
-    CABAL_VERSION: "3.2.0.0"
-  allow_failure: true
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  allow_failure: true # freebsd runners are unreliable
+  when: manual
+  needs: []
 
 
 ######## linux release ########
 
 release:linux:64bit:
+  stage: release
+  needs: ["test:linux:recommended", "test:linux:latest"]
   extends:
     - .alpine:64bit
     - .release_ghcup
@@ -195,11 +273,13 @@ release:linux:64bit:
     - ./.gitlab/before_script/linux/alpine/install_deps.sh
   variables:
     ARTIFACT: "x86_64-linux-ghcup"
-    GHC_VERSION: "8.8.4"
-    CABAL_VERSION: "3.2.0.0"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
 
 
 release:linux:32bit:
+  stage: release
+  needs: ["test:linux:recommended:32bit"]
   extends:
     - .alpine:32bit
     - .release_ghcup
@@ -207,13 +287,40 @@ release:linux:32bit:
     - ./.gitlab/before_script/linux/alpine/install_deps.sh
   variables:
     ARTIFACT: "i386-linux-ghcup"
-    GHC_VERSION: "8.8.4"
+    GHC_VERSION: "8.10.4"
     CABAL_VERSION: "3.2.0.0"
 
+release:linux:armv7:
+  stage: release
+  needs: ["test:linux:recommended:armv7"]
+  extends:
+    - .linux:armv7
+    - .release_ghcup
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps_manual.sh
+  variables:
+    ARTIFACT: "armv7-linux-ghcup"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+
+release:linux:aarch64:
+  stage: release
+  needs: ["test:linux:recommended:aarch64"]
+  extends:
+    - .linux:aarch64
+    - .release_ghcup
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps_manual.sh
+  variables:
+    ARTIFACT: "aarch64-linux-ghcup"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
 
 ######## darwin release ########
 
 release:darwin:
+  stage: release
+  needs: ["test:mac:recommended", "test:mac:latest"]
   extends:
     - .darwin
     - .release_ghcup
@@ -222,14 +329,16 @@ release:darwin:
     - ./.gitlab/before_script/darwin/install_deps.sh
   variables:
     ARTIFACT: "x86_64-apple-darwin-ghcup"
-    GHC_VERSION: "8.8.3"
-    CABAL_VERSION: "3.2.0.0"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
     MACOSX_DEPLOYMENT_TARGET: "10.7"
 
 
 ######## freebsd release ########
 
 release:freebsd:
+  stage: release
+  needs: ["test:freebsd:recommended", "test:freebsd:latest"]
   extends:
     - .freebsd
     - .release_ghcup
@@ -238,6 +347,27 @@ release:freebsd:
     - ./.gitlab/before_script/freebsd/install_deps.sh
   variables:
     ARTIFACT: "x86_64-portbld-freebsd-ghcup"
-    GHC_VERSION: "8.8.3"
-    CABAL_VERSION: "3.2.0.0"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
 
+
+######## hlint ########
+
+hlint:
+  stage: hlint
+  extends:
+    - .alpine:64bit
+  before_script:
+    - ./.gitlab/before_script/linux/alpine/install_deps.sh
+  script:
+    - ./.gitlab/script/hlint.sh
+  variables:
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+    JSON_VERSION: "0.0.4"
+  allow_failure: true
+  artifacts:
+    expire_in: 2 week
+    paths:
+      - report.html
+    when: on_failure

.gitlab/before_script/darwin/install_deps.sh

@@ -9,8 +9,9 @@ mkdir -p "${TMPDIR}"
 curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-apple-darwin-ghcup > ./ghcup-bin
 chmod +x ghcup-bin
 
-./ghcup-bin install ${GHC_VERSION}
-./ghcup-bin set ${GHC_VERSION}
-./ghcup-bin install-cabal ${CABAL_VERSION}
+./ghcup-bin upgrade -i -f
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
 
 exit 0

.gitlab/before_script/freebsd/install_deps.sh

@@ -11,8 +11,9 @@ mkdir -p "${TMPDIR}"
 curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-portbld-freebsd-ghcup > ./ghcup-bin
 chmod +x ghcup-bin
 
-./ghcup-bin install ${GHC_VERSION}
-./ghcup-bin install-cabal ${CABAL_VERSION}
-./ghcup-bin set ${GHC_VERSION}
+./ghcup-bin upgrade -i -f
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
 
 exit 0

.gitlab/before_script/linux/alpine/install_deps.sh

@@ -10,6 +10,9 @@ apk add --no-cache \
 	curl \
 	gcc \
 	g++ \
+	binutils \
+	binutils-gold \
+	bsd-compat-headers \
 	gmp-dev \
 	ncurses-dev \
 	libffi-dev \
@@ -18,14 +21,15 @@ apk add --no-cache \
 	tar \
 	perl
 
-if [ "${BIT}" = "32" ] ; then
+if [ "${ARCH}" = "32" ] ; then
 	curl -sSfL https://downloads.haskell.org/ghcup/i386-linux-ghcup > ./ghcup-bin
 else
 	curl -sSfL https://downloads.haskell.org/ghcup/x86_64-linux-ghcup > ./ghcup-bin
 fi
 chmod +x ghcup-bin
-./ghcup-bin install ${GHC_VERSION}
-./ghcup-bin install-cabal ${CABAL_VERSION}
+./ghcup-bin upgrade -i -f
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
 
 # utils
 apk add --no-cache \

.gitlab/before_script/linux/install_deps.sh

@@ -12,7 +12,8 @@ sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev li
 curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-linux-ghcup > ./ghcup-bin
 chmod +x ghcup-bin
 
-./ghcup-bin install ${GHC_VERSION}
-./ghcup-bin set ${GHC_VERSION}
-./ghcup-bin install-cabal ${CABAL_VERSION}
+./ghcup-bin upgrade -i -f
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
 

.gitlab/before_script/linux/install_deps_manual.sh

@@ -0,0 +1,64 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+mkdir -p "${TMPDIR}"
+
+ednf() {
+	case "${ARCH}" in
+		"ARM")
+			sudo dnf -y --forcearch armv7hl "$@"
+			;;
+		"ARM64")
+			sudo dnf -y --forcearch aarch64 "$@"
+			;;
+		*) exit 1 ;;
+	esac
+}
+
+ednf update
+ednf install gcc gcc-c++ gmp gmp-devel make ncurses ncurses-devel xz xz-devel perl zlib zlib-devel openssl-devel openssl-libs openssl libffi libffi-devel
+if [ "${ARCH}" = "ARM64" ] ; then
+	ednf install numactl numactl-libs numactl-devel
+fi
+ednf install bash wget curl git tar
+ednf install llvm9.0 llvm9.0-devel llvm9.0-libs llvm9.0-static
+
+case "${ARCH}" in
+	"ARM")
+		ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-armv7-deb10-linux.tar.xz
+		cabal_url=home.smart-cactus.org/~ben/cabal-install-${CABAL_VERSION}-armv7-linux-bootstrapped.tar.xz
+		;;
+	"ARM64")
+		ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-aarch64-deb10-linux.tar.xz
+		cabal_url=https://downloads.haskell.org/~cabal/cabal-install-${CABAL_VERSION}/cabal-install-${CABAL_VERSION}-aarch64-ubuntu-18.04.tar.xz
+		;;
+	*) exit 1 ;;
+esac
+
+mkdir -p "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin
+
+curl -O "${ghc_url}"
+tar -xf ghc-*.tar.*
+cd ghc-${GHC_VERSION}
+./configure --prefix="${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}
+make install
+for i in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}/bin/*-${GHC_VERSION} ; do
+	ln -s "${i}" "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/${i##*/}
+done
+for x in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/*-${GHC_VERSION} ; do
+	ln -s ${x##*/} ${x%-${GHC_VERSION}}
+done
+cd ..
+rm -rf ghc-${GHC_VERSION} ghc-*.tar.*
+unset x i
+
+mkdir cabal-install
+cd cabal-install
+curl -O "${cabal_url}"
+tar -xf cabal-install-*
+mv cabal "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/cabal
+cd ..
+rm -rf cabal-install

.gitlab/script/ghcup_release.sh

@@ -16,15 +16,17 @@ git describe
 ecabal update
 
 if [ "${OS}" = "LINUX" ] ; then
-	if [ "${BIT}" = "32" ] ; then
+	if [ "${ARCH}" = "32" ] ; then
 		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui -ftar
-	else
+	elif [ "${ARCH}" = "64" ] ; then
 		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui
+	else
+		ecabal build -w ghc-${GHC_VERSION} -ftui
 	fi
 elif [ "${OS}" = "FREEBSD" ] ; then
-	ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections' --constraint="zlib static" -ftui
+	ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections' --constraint="zlib +bundled-c-zlib" -ftui
 else
-	ecabal build -w ghc-${GHC_VERSION} --constraint="zlib static" --constraint="lzma static" -ftui
+	ecabal build -w ghc-${GHC_VERSION} --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" -ftui
 fi
 
 mkdir out

.gitlab/script/ghcup_version.sh

@@ -20,13 +20,16 @@ git describe --always
 
 ecabal update
 
-ecabal install -w ghc-${GHC_VERSION} --installdir="$CI_PROJECT_DIR"/.local/bin hspec-discover
+(
+	cd /tmp
+	ecabal install -w ghc-${GHC_VERSION} --installdir="$CI_PROJECT_DIR"/.local/bin hspec-discover
+)
 
 if [ "${OS}" = "DARWIN" ] ; then
 	ecabal build -w ghc-${GHC_VERSION} -ftui
 	ecabal test -w ghc-${GHC_VERSION} -ftui ghcup-test
 elif [ "${OS}" = "LINUX" ] ; then
-	if [ "${BIT}" = "32" ] ; then
+	if [ "${ARCH}" = "32" ] ; then
 		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar
 		ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar ghcup-test
 	else
@@ -80,17 +83,17 @@ ghci-$(ghc --numeric-version) --version
 # test installing new ghc doesn't mess with currently set GHC
 # https://gitlab.haskell.org/haskell/ghcup-hs/issues/7
 if [ "${OS}" = "LINUX" ] ; then
-	eghcup --downloader=wget install 8.4.4
+	eghcup --downloader=wget install 8.10.3
 else # test wget a bit
-	eghcup install 8.4.4
+	eghcup install 8.10.3
 fi
 [ "$(ghc --numeric-version)" = "${ghc_ver}" ]
-eghcup set 8.4.4
-eghcup set 8.4.4
-[ "$(ghc --numeric-version)" = "8.4.4" ]
+eghcup set 8.10.3
+eghcup set 8.10.3
+[ "$(ghc --numeric-version)" = "8.10.3" ]
 eghcup set ${GHC_VERSION}
 [ "$(ghc --numeric-version)" = "${ghc_ver}" ]
-eghcup rm 8.4.4
+eghcup rm 8.10.3
 [ "$(ghc --numeric-version)" = "${ghc_ver}" ]
 
 # install hls
@@ -98,7 +101,7 @@ if [ "${OS}" = "DARWIN" ] ; then
 	eghcup install hls
 	haskell-language-server-wrapper --version
 elif [ "${OS}" = "LINUX" ] ; then
-	if [ "${BIT}" = "64" ] ; then
+	if [ "${ARCH}" = "64" ] ; then
 		eghcup install hls
 		haskell-language-server-wrapper --version
 	fi
@@ -107,6 +110,10 @@ fi
 
 eghcup rm $(ghc --numeric-version)
 
+# https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/116
+eghcup install cabal -u https://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-ubuntu-16.04.tar.xz 3.4.0.0-rc4
+eghcup rm cabal 3.4.0.0-rc4
+
 eghcup upgrade
 eghcup upgrade -f
 

.gitlab/script/hlint.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
+
+mkdir -p "$CI_PROJECT_DIR"/.local/bin
+
+ecabal() {
+	cabal --store-dir="$(pwd)"/.store "$@"
+}
+
+git describe
+
+ecabal update
+ecabal install -w ghc-${GHC_VERSION} --installdir="$CI_PROJECT_DIR"/.local/bin hlint
+
+hlint -r lib/ test/ 
+

.hlint.yaml

@@ -0,0 +1,83 @@
+# HLint configuration file
+# https://github.com/ndmitchell/hlint
+##########################
+
+# This file contains a template configuration file, which is typically
+# placed as .hlint.yaml in the root of your project
+
+
+# Warnings currently triggered by your code
+- ignore: {name: "Redundant bang pattern"}
+- ignore: {name: "Use camelCase"}
+- ignore: {name: "Use if"}
+- ignore: {name: "Use newtype instead of data"}
+- ignore: {name: "Use <$>"}
+- ignore: {name: "Use mapMaybe"}
+- ignore: {name: "Use const"}
+- ignore: {name: "Use list comprehension"}
+- ignore: {name: "Redundant multi-way if"}
+- ignore: {name: "Redundant lambda"}
+- ignore: {name: "Avoid lambda"}
+- ignore: {name: "Use uncurry"}
+- ignore: {name: "Use replicateM"}
+- ignore: {name: "Redundant irrefutable pattern"}
+
+
+# Specify additional command line arguments
+#
+# - arguments: [--color, --cpp-simple, -XQuasiQuotes]
+
+
+# Control which extensions/flags/modules/functions can be used
+#
+# - extensions:
+#   - default: false # all extension are banned by default
+#   - name: [PatternGuards, ViewPatterns] # only these listed extensions can be used
+#   - {name: CPP, within: CrossPlatform} # CPP can only be used in a given module
+#
+# - flags:
+#   - {name: -w, within: []} # -w is allowed nowhere
+#
+# - modules:
+#   - {name: [Data.Set, Data.HashSet], as: Set} # if you import Data.Set qualified, it must be as 'Set'
+#   - {name: Control.Arrow, within: []} # Certain modules are banned entirely
+#
+# - functions:
+#   - {name: unsafePerformIO, within: []} # unsafePerformIO can only appear in no modules
+
+
+# Add custom hints for this project
+#
+# Will suggest replacing "wibbleMany [myvar]" with "wibbleOne myvar"
+# - error: {lhs: "wibbleMany [x]", rhs: wibbleOne x}
+
+# The hints are named by the string they display in warning messages.
+# For example, if you see a warning starting like
+#
+# Main.hs:116:51: Warning: Redundant ==
+#
+# You can refer to that hint with `{name: Redundant ==}` (see below).
+
+# Turn on hints that are off by default
+#
+# Ban "module X(module X) where", to require a real export list
+# - warn: {name: Use explicit module export list}
+#
+# Replace a $ b $ c with a . b $ c
+# - group: {name: dollar, enabled: true}
+#
+# Generalise map to fmap, ++ to <>
+# - group: {name: generalise, enabled: true}
+
+
+# Ignore some builtin hints
+# - ignore: {name: Use let}
+# - ignore: {name: Use const, within: SpecialModule} # Only within certain modules
+
+
+# Define some custom infix operators
+# - fixity: infixr 3 ~^#^~
+
+
+# To generate a suitable file for HLint do:
+# $ hlint --default > .hlint.yaml

.travis/build.sh

@@ -2,23 +2,21 @@
 
 set -ex
 
-## install ghc via old ghcup
-
 mkdir -p ~/.ghcup/bin
-curl https://gitlab.haskell.org/haskell/ghcup/raw/master/ghcup > ~/.ghcup/bin/ghcup
+curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-apple-darwin-ghcup > ~/.ghcup/bin/ghcup
 chmod +x ~/.ghcup/bin/ghcup
 
 export PATH="$HOME/.ghcup/bin:$PATH"
 
-ghcup install 8.8.3
-ghcup install-cabal 3.2.0.0
-ghcup set 8.8.3
+ghcup install 8.10.4
+ghcup install-cabal 3.4.0.0
+ghcup set 8.10.4
 
 
 ## install ghcup
 
 cabal update
-cabal build --constraint="zlib static" --constraint="lzma static" -ftui
+cabal build --constraint="zlib +static" --constraint="lzma +static" -ftui
 cp "$(cabal new-exec --verbose=0 --offline sh -- -c 'command -v ghcup')" .
 strip ./ghcup
 cp ghcup "./${ARTIFACT}"

3rdparty/zlib/.travis.yml

@@ -1,173 +0,0 @@
-# This Travis job script has been generated by a script via
-#
-#   haskell-ci '-o' '.travis.yml' '--irc-channels=irc.freenode.org#hackage' 'zlib.cabal' '--apt=zlib1g-dev' '--tests-jobs=>=7.4'
-#
-# For more information, see https://github.com/haskell-CI/haskell-ci
-#
-# version: 0.9.20200325
-#
-version: ~> 1.0
-language: c
-os: linux
-dist: xenial
-git:
-  # whether to recursively clone submodules
-  submodules: false
-notifications:
-  irc:
-    channels:
-      - irc.freenode.org#hackage
-    skip_join: true
-    template:
-      - "\x0313zlib\x03/\x0306%{branch}\x03 \x0314%{commit}\x03 %{build_url} %{message}"
-cache:
-  directories:
-    - $HOME/.cabal/packages
-    - $HOME/.cabal/store
-    - $HOME/.hlint
-before_cache:
-  - rm -fv $CABALHOME/packages/hackage.haskell.org/build-reports.log
-  # remove files that are regenerated by 'cabal update'
-  - rm -fv $CABALHOME/packages/hackage.haskell.org/00-index.*
-  - rm -fv $CABALHOME/packages/hackage.haskell.org/*.json
-  - rm -fv $CABALHOME/packages/hackage.haskell.org/01-index.cache
-  - rm -fv $CABALHOME/packages/hackage.haskell.org/01-index.tar
-  - rm -fv $CABALHOME/packages/hackage.haskell.org/01-index.tar.idx
-  - rm -rfv $CABALHOME/packages/head.hackage
-jobs:
-  include:
-    - compiler: ghc-8.10.1
-      addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-8.10.1","cabal-install-3.2","zlib1g-dev"]}}
-      os: linux
-    - compiler: ghc-8.8.3
-      addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-8.8.3","cabal-install-3.0","zlib1g-dev"]}}
-      os: linux
-    - compiler: ghc-8.6.5
-      addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-8.6.5","cabal-install-3.0","zlib1g-dev"]}}
-      os: linux
-    - compiler: ghc-8.4.4
-      addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-8.4.4","cabal-install-3.0","zlib1g-dev"]}}
-      os: linux
-    - compiler: ghc-8.2.2
-      addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-8.2.2","cabal-install-3.0","zlib1g-dev"]}}
-      os: linux
-    - compiler: ghc-8.0.2
-      addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-8.0.2","cabal-install-3.0","zlib1g-dev"]}}
-      os: linux
-    - compiler: ghc-8.0.1
-      addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-8.0.1","cabal-install-3.0","zlib1g-dev"]}}
-      os: linux
-    - compiler: ghc-7.10.3
-      addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-7.10.3","cabal-install-3.0","zlib1g-dev"]}}
-      os: linux
-    - compiler: ghc-7.8.4
-      addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-7.8.4","cabal-install-3.0","zlib1g-dev"]}}
-      os: linux
-    - compiler: ghc-7.6.3
-      addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-7.6.3","cabal-install-3.0","zlib1g-dev"]}}
-      os: linux
-    - compiler: ghc-7.4.2
-      addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-7.4.2","cabal-install-3.0","zlib1g-dev"]}}
-      os: linux
-    - compiler: ghc-7.2.2
-      addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-7.2.2","cabal-install-3.0","zlib1g-dev"]}}
-      os: linux
-    - compiler: ghc-7.0.4
-      addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-7.0.4","cabal-install-3.0","zlib1g-dev"]}}
-      os: linux
-before_install:
-  - HC=$(echo "/opt/$CC/bin/ghc" | sed 's/-/\//')
-  - WITHCOMPILER="-w $HC"
-  - HADDOCK=$(echo "/opt/$CC/bin/haddock" | sed 's/-/\//')
-  - HCPKG="$HC-pkg"
-  - unset CC
-  - CABAL=/opt/ghc/bin/cabal
-  - CABALHOME=$HOME/.cabal
-  - export PATH="$CABALHOME/bin:$PATH"
-  - TOP=$(pwd)
-  - "HCNUMVER=$(${HC} --numeric-version|perl -ne '/^(\\d+)\\.(\\d+)\\.(\\d+)(\\.(\\d+))?$/; print(10000 * $1 + 100 * $2 + ($3 == 0 ? $5 != 1 : $3))')"
-  - echo $HCNUMVER
-  - CABAL="$CABAL -vnormal+nowrap"
-  - set -o pipefail
-  - TEST=--enable-tests
-  - if [ $HCNUMVER -lt 70400 ] ; then TEST=--disable-tests ; fi
-  - BENCH=--enable-benchmarks
-  - HEADHACKAGE=false
-  - rm -f $CABALHOME/config
-  - |
-    echo "verbose: normal +nowrap +markoutput"          >> $CABALHOME/config
-    echo "remote-build-reporting: anonymous"            >> $CABALHOME/config
-    echo "write-ghc-environment-files: always"          >> $CABALHOME/config
-    echo "remote-repo-cache: $CABALHOME/packages"       >> $CABALHOME/config
-    echo "logs-dir:          $CABALHOME/logs"           >> $CABALHOME/config
-    echo "world-file:        $CABALHOME/world"          >> $CABALHOME/config
-    echo "extra-prog-path:   $CABALHOME/bin"            >> $CABALHOME/config
-    echo "symlink-bindir:    $CABALHOME/bin"            >> $CABALHOME/config
-    echo "installdir:        $CABALHOME/bin"            >> $CABALHOME/config
-    echo "build-summary:     $CABALHOME/logs/build.log" >> $CABALHOME/config
-    echo "store-dir:         $CABALHOME/store"          >> $CABALHOME/config
-    echo "install-dirs user"                            >> $CABALHOME/config
-    echo "  prefix: $CABALHOME"                         >> $CABALHOME/config
-    echo "repository hackage.haskell.org"               >> $CABALHOME/config
-    echo "  url: http://hackage.haskell.org/"           >> $CABALHOME/config
-install:
-  - ${CABAL} --version
-  - echo "$(${HC} --version) [$(${HC} --print-project-git-commit-id 2> /dev/null || echo '?')]"
-  - |
-    echo "program-default-options"                >> $CABALHOME/config
-    echo "  ghc-options: $GHCJOBS +RTS -M6G -RTS" >> $CABALHOME/config
-  - cat $CABALHOME/config
-  - rm -fv cabal.project cabal.project.local cabal.project.freeze
-  - travis_retry ${CABAL} v2-update -v
-  # Generate cabal.project
-  - rm -rf cabal.project cabal.project.local cabal.project.freeze
-  - touch cabal.project
-  - |
-    echo "packages: ." >> cabal.project
-  - |
-  - "for pkg in $($HCPKG list --simple-output); do echo $pkg | sed 's/-[^-]*$//' | (grep -vE -- '^(zlib)$' || true) | sed 's/^/constraints: /' | sed 's/$/ installed/' >> cabal.project.local; done"
-  - cat cabal.project || true
-  - cat cabal.project.local || true
-  - if [ -f "./configure.ac" ]; then (cd "." && autoreconf -i); fi
-  - ${CABAL} v2-freeze $WITHCOMPILER ${TEST} ${BENCH}
-  - "cat cabal.project.freeze | sed -E 's/^(constraints: *| *)//' | sed 's/any.//'"
-  - rm  cabal.project.freeze
-  - travis_wait 40 ${CABAL} v2-build $WITHCOMPILER ${TEST} ${BENCH} --dep -j2 all
-  - travis_wait 40 ${CABAL} v2-build $WITHCOMPILER --disable-tests --disable-benchmarks --dep -j2 all
-script:
-  - DISTDIR=$(mktemp -d /tmp/dist-test.XXXX)
-  # Packaging...
-  - ${CABAL} v2-sdist all
-  # Unpacking...
-  - mv dist-newstyle/sdist/*.tar.gz ${DISTDIR}/
-  - cd ${DISTDIR} || false
-  - find . -maxdepth 1 -type f -name '*.tar.gz' -exec tar -xvf '{}' \;
-  - find . -maxdepth 1 -type f -name '*.tar.gz' -exec rm       '{}' \;
-  - PKGDIR_zlib="$(find . -maxdepth 1 -type d -regex '.*/zlib-[0-9.]*')"
-  # Generate cabal.project
-  - rm -rf cabal.project cabal.project.local cabal.project.freeze
-  - touch cabal.project
-  - |
-    echo "packages: ${PKGDIR_zlib}" >> cabal.project
-  - |
-  - "for pkg in $($HCPKG list --simple-output); do echo $pkg | sed 's/-[^-]*$//' | (grep -vE -- '^(zlib)$' || true) | sed 's/^/constraints: /' | sed 's/$/ installed/' >> cabal.project.local; done"
-  - cat cabal.project || true
-  - cat cabal.project.local || true
-  # Building...
-  # this builds all libraries and executables (without tests/benchmarks)
-  - ${CABAL} v2-build $WITHCOMPILER --disable-tests --disable-benchmarks all
-  # Building with tests and benchmarks...
-  # build & run tests, build benchmarks
-  - ${CABAL} v2-build $WITHCOMPILER ${TEST} ${BENCH} all
-  # Testing...
-  - if [ $HCNUMVER -ge 70400 ] ; then ${CABAL} v2-test $WITHCOMPILER ${TEST} ${BENCH} all ; fi
-  # cabal check...
-  - (cd ${PKGDIR_zlib} && ${CABAL} -vnormal check)
-  # haddock...
-  - ${CABAL} v2-haddock $WITHCOMPILER --with-haddock $HADDOCK ${TEST} ${BENCH} all
-  # Building without installed constraints for packages in global-db...
-  - rm -f cabal.project.local
-  - ${CABAL} v2-build $WITHCOMPILER --disable-tests --disable-benchmarks all
-
-# REGENDATA ("0.9.20200325",["-o",".travis.yml","--irc-channels=irc.freenode.org#hackage","zlib.cabal","--apt=zlib1g-dev","--tests-jobs=>=7.4"])
-# EOF

3rdparty/zlib/Codec/Compression/GZip.hs

@@ -1,128 +0,0 @@
------------------------------------------------------------------------------
--- |
--- Copyright   :  (c) 2006-2014 Duncan Coutts
--- License     :  BSD-style
---
--- Maintainer  :  duncan@community.haskell.org
---
--- Compression and decompression of data streams in the gzip format.
---
--- The format is described in detail in RFC #1952:
--- <http://www.ietf.org/rfc/rfc1952.txt>
---
--- See also the zlib home page: <http://zlib.net/>
---
------------------------------------------------------------------------------
-module Codec.Compression.GZip (
-
-  -- | This module provides pure functions for compressing and decompressing
-  -- streams of data in the gzip format and represented by lazy 'ByteString's.
-  -- This makes it easy to use either in memory or with disk or network IO.
-  --
-  -- For example a simple gzip compression program is just:
-  --
-  -- > import qualified Data.ByteString.Lazy as ByteString
-  -- > import qualified Codec.Compression.GZip as GZip
-  -- >
-  -- > main = ByteString.interact GZip.compress
-  --
-  -- Or you could lazily read in and decompress a @.gz@ file using:
-  --
-  -- > content <- fmap GZip.decompress (readFile file)
-  --
-
-  -- * Simple compression and decompression
-  compress,
-  decompress,
-
-  -- * Extended api with control over compression parameters
-  compressWith,
-  decompressWith,
-
-  CompressParams(..), defaultCompressParams,
-  DecompressParams(..), defaultDecompressParams,
-
-  -- ** The compression parameter types
-  CompressionLevel(..),
-    defaultCompression,
-    noCompression,
-    bestSpeed,
-    bestCompression,
-    compressionLevel,
-  Method(..),
-    deflateMethod,
-  WindowBits(..),
-    defaultWindowBits,
-    windowBits,
-  MemoryLevel(..),
-    defaultMemoryLevel,
-    minMemoryLevel,
-    maxMemoryLevel,
-    memoryLevel,
-  CompressionStrategy(..),
-    defaultStrategy,
-    filteredStrategy,
-    huffmanOnlyStrategy,
-
-  ) where
-
-import Data.ByteString.Lazy (ByteString)
-
-import qualified Codec.Compression.Zlib.Internal as Internal
-import Codec.Compression.Zlib.Internal hiding (compress, decompress)
-
-
--- | Decompress a stream of data in the gzip format.
---
--- There are a number of errors that can occur. In each case an exception will
--- be thrown. The possible error conditions are:
---
--- * if the stream does not start with a valid gzip header
---
--- * if the compressed stream is corrupted
---
--- * if the compressed stream ends permaturely
---
--- Note that the decompression is performed /lazily/. Errors in the data stream
--- may not be detected until the end of the stream is demanded (since it is
--- only at the end that the final checksum can be checked). If this is
--- important to you, you must make sure to consume the whole decompressed
--- stream before doing any IO action that depends on it.
---
-decompress :: ByteString -> ByteString
-decompress = decompressWith defaultDecompressParams
-
-
--- | Like 'decompress' but with the ability to specify various decompression
--- parameters. Typical usage:
---
--- > decompressWith defaultCompressParams { ... }
---
-decompressWith :: DecompressParams -> ByteString -> ByteString
-decompressWith = Internal.decompress gzipFormat
-
-
--- | Compress a stream of data into the gzip format.
---
--- This uses the default compression parameters. In partiular it uses the
--- default compression level which favours a higher compression ratio over
--- compression speed, though it does not use the maximum compression level.
---
--- Use 'compressWith' to adjust the compression level or other compression
--- parameters.
---
-compress :: ByteString -> ByteString
-compress = compressWith defaultCompressParams
-
-
--- | Like 'compress' but with the ability to specify various compression
--- parameters. Typical usage:
---
--- > compressWith defaultCompressParams { ... }
---
--- In particular you can set the compression level:
---
--- > compressWith defaultCompressParams { compressLevel = BestCompression }
---
-compressWith :: CompressParams -> ByteString -> ByteString
-compressWith = Internal.compress gzipFormat

3rdparty/zlib/Codec/Compression/Zlib.hs

@@ -1,116 +0,0 @@
------------------------------------------------------------------------------
--- |
--- Copyright   :  (c) 2006-2014 Duncan Coutts
--- License     :  BSD-style
---
--- Maintainer  :  duncan@community.haskell.org
---
--- Compression and decompression of data streams in the zlib format.
---
--- The format is described in detail in RFC #1950:
--- <http://www.ietf.org/rfc/rfc1950.txt>
---
--- See also the zlib home page: <http://zlib.net/>
---
------------------------------------------------------------------------------
-module Codec.Compression.Zlib (
-
-  -- | This module provides pure functions for compressing and decompressing
-  -- streams of data in the zlib format and represented by lazy 'ByteString's.
-  -- This makes it easy to use either in memory or with disk or network IO.
-
-  -- * Simple compression and decompression
-  compress,
-  decompress,
-
-  -- * Extended api with control over compression parameters
-  compressWith,
-  decompressWith,
-
-  CompressParams(..), defaultCompressParams,
-  DecompressParams(..), defaultDecompressParams,
-
-  -- ** The compression parameter types
-  CompressionLevel(..),
-    defaultCompression,
-    noCompression,
-    bestSpeed,
-    bestCompression,
-    compressionLevel,
-  Method(..),
-    deflateMethod,
-  WindowBits(..),
-    defaultWindowBits,
-    windowBits,
-  MemoryLevel(..),
-    defaultMemoryLevel,
-    minMemoryLevel,
-    maxMemoryLevel,
-    memoryLevel,
-  CompressionStrategy(..),
-    defaultStrategy,
-    filteredStrategy,
-    huffmanOnlyStrategy,
-
-  ) where
-
-import Data.ByteString.Lazy (ByteString)
-
-import qualified Codec.Compression.Zlib.Internal as Internal
-import Codec.Compression.Zlib.Internal hiding (compress, decompress)
-
-
--- | Decompress a stream of data in the zlib format.
---
--- There are a number of errors that can occur. In each case an exception will
--- be thrown. The possible error conditions are:
---
--- * if the stream does not start with a valid gzip header
---
--- * if the compressed stream is corrupted
---
--- * if the compressed stream ends permaturely
---
--- Note that the decompression is performed /lazily/. Errors in the data stream
--- may not be detected until the end of the stream is demanded (since it is
--- only at the end that the final checksum can be checked). If this is
--- important to you, you must make sure to consume the whole decompressed
--- stream before doing any IO action that depends on it.
---
-decompress :: ByteString -> ByteString
-decompress = decompressWith defaultDecompressParams
-
-
--- | Like 'decompress' but with the ability to specify various decompression
--- parameters. Typical usage:
---
--- > decompressWith defaultCompressParams { ... }
---
-decompressWith :: DecompressParams -> ByteString -> ByteString
-decompressWith = Internal.decompress zlibFormat
-
-
--- | Compress a stream of data into the zlib format.
---
--- This uses the default compression parameters. In partiular it uses the
--- default compression level which favours a higher compression ratio over
--- compression speed, though it does not use the maximum compression level.
---
--- Use 'compressWith' to adjust the compression level or other compression
--- parameters.
---
-compress :: ByteString -> ByteString
-compress = compressWith defaultCompressParams
-
-
--- | Like 'compress' but with the ability to specify various compression
--- parameters. Typical usage:
---
--- > compressWith defaultCompressParams { ... }
---
--- In particular you can set the compression level:
---
--- > compressWith defaultCompressParams { compressLevel = BestCompression }
---
-compressWith :: CompressParams -> ByteString -> ByteString
-compressWith = Internal.compress zlibFormat

3rdparty/zlib/Codec/Compression/Zlib/Internal.hs

@@ -1,953 +0,0 @@
-{-# LANGUAGE CPP, RankNTypes, DeriveDataTypeable, BangPatterns #-}
-#if __GLASGOW_HASKELL__ >= 702
-{-# LANGUAGE Trustworthy #-}
-#endif
------------------------------------------------------------------------------
--- |
--- Copyright   :  (c) 2006-2015 Duncan Coutts
--- License     :  BSD-style
---
--- Maintainer  :  duncan@community.haskell.org
---
--- Pure and IO stream based interfaces to lower level zlib wrapper
---
------------------------------------------------------------------------------
-module Codec.Compression.Zlib.Internal (
-
-  -- * Pure interface
-  compress,
-  decompress,
-
-  -- * Monadic incremental interface
-  -- $incremental-compression
-
-  -- ** Using incremental compression
-  -- $using-incremental-compression
-
-  CompressStream(..),
-  compressST,
-  compressIO,
-  foldCompressStream,
-  foldCompressStreamWithInput,
-
-  -- ** Using incremental decompression
-  -- $using-incremental-decompression
-
-  DecompressStream(..),
-  DecompressError(..),
-  decompressST,
-  decompressIO,
-  foldDecompressStream,
-  foldDecompressStreamWithInput,
-
-  -- * The compression parameter types
-  CompressParams(..),
-  defaultCompressParams,
-  DecompressParams(..),
-  defaultDecompressParams,
-  Stream.Format(..),
-    Stream.gzipFormat,
-    Stream.zlibFormat,
-    Stream.rawFormat,
-    Stream.gzipOrZlibFormat,
-  Stream.CompressionLevel(..),
-    Stream.defaultCompression,
-    Stream.noCompression,
-    Stream.bestSpeed,
-    Stream.bestCompression,
-    Stream.compressionLevel,
-  Stream.Method(..),
-    Stream.deflateMethod,
-  Stream.WindowBits(..),
-    Stream.defaultWindowBits,
-    Stream.windowBits,
-  Stream.MemoryLevel(..),
-    Stream.defaultMemoryLevel,
-    Stream.minMemoryLevel,
-    Stream.maxMemoryLevel,
-    Stream.memoryLevel,
-  Stream.CompressionStrategy(..),
-    Stream.defaultStrategy,
-    Stream.filteredStrategy,
-    Stream.huffmanOnlyStrategy,
-
-  ) where
-
-import Prelude hiding (length)
-import Control.Monad (when)
-import Control.Exception (Exception, throw, assert)
-import Control.Monad.ST.Lazy hiding (stToIO)
-import Control.Monad.ST.Strict (stToIO)
-#if __GLASGOW_HASKELL__ >= 702
-import qualified Control.Monad.ST.Unsafe as Unsafe (unsafeIOToST)
-#else
-import qualified Control.Monad.ST.Strict as Unsafe (unsafeIOToST)
-#endif
-import Data.Typeable (Typeable)
-import qualified Data.ByteString.Lazy as L
-import qualified Data.ByteString.Lazy.Internal as L
-import qualified Data.ByteString          as S
-import qualified Data.ByteString.Internal as S
-import Data.Word (Word8)
-import GHC.IO (noDuplicate)
-
-import qualified Codec.Compression.Zlib.Stream as Stream
-import Codec.Compression.Zlib.Stream (Stream)
-
--- | The full set of parameters for compression. The defaults are
--- 'defaultCompressParams'.
---
--- The 'compressBufferSize' is the size of the first output buffer containing
--- the compressed data. If you know an approximate upper bound on the size of
--- the compressed data then setting this parameter can save memory. The default
--- compression output buffer size is @16k@. If your extimate is wrong it does
--- not matter too much, the default buffer size will be used for the remaining
--- chunks.
---
-data CompressParams = CompressParams {
-  compressLevel       :: !Stream.CompressionLevel,
-  compressMethod      :: !Stream.Method,
-  compressWindowBits  :: !Stream.WindowBits,
-  compressMemoryLevel :: !Stream.MemoryLevel,
-  compressStrategy    :: !Stream.CompressionStrategy,
-  compressBufferSize  :: !Int,
-  compressDictionary  :: Maybe S.ByteString
-} deriving Show
-
--- | The full set of parameters for decompression. The defaults are
--- 'defaultDecompressParams'.
---
--- The 'decompressBufferSize' is the size of the first output buffer,
--- containing the uncompressed data. If you know an exact or approximate upper
--- bound on the size of the decompressed data then setting this parameter can
--- save memory. The default decompression output buffer size is @32k@. If your
--- extimate is wrong it does not matter too much, the default buffer size will
--- be used for the remaining chunks.
---
--- One particular use case for setting the 'decompressBufferSize' is if you
--- know the exact size of the decompressed data and want to produce a strict
--- 'Data.ByteString.ByteString'. The compression and deccompression functions
--- use lazy 'Data.ByteString.Lazy.ByteString's but if you set the
--- 'decompressBufferSize' correctly then you can generate a lazy
--- 'Data.ByteString.Lazy.ByteString' with exactly one chunk, which can be
--- converted to a strict 'Data.ByteString.ByteString' in @O(1)@ time using
--- @'Data.ByteString.concat' . 'Data.ByteString.Lazy.toChunks'@.
---
-data DecompressParams = DecompressParams {
-  decompressWindowBits :: !Stream.WindowBits,
-  decompressBufferSize :: !Int,
-  decompressDictionary :: Maybe S.ByteString,
-  decompressAllMembers :: Bool
-} deriving Show
-
--- | The default set of parameters for compression. This is typically used with
--- the @compressWith@ function with specific parameters overridden.
---
-defaultCompressParams :: CompressParams
-defaultCompressParams = CompressParams {
-  compressLevel       = Stream.defaultCompression,
-  compressMethod      = Stream.deflateMethod,
-  compressWindowBits  = Stream.defaultWindowBits,
-  compressMemoryLevel = Stream.defaultMemoryLevel,
-  compressStrategy    = Stream.defaultStrategy,
-  compressBufferSize  = defaultCompressBufferSize,
-  compressDictionary  = Nothing
-}
-
--- | The default set of parameters for decompression. This is typically used with
--- the @compressWith@ function with specific parameters overridden.
---
-defaultDecompressParams :: DecompressParams
-defaultDecompressParams = DecompressParams {
-  decompressWindowBits = Stream.defaultWindowBits,
-  decompressBufferSize = defaultDecompressBufferSize,
-  decompressDictionary = Nothing,
-  decompressAllMembers = True
-}
-
--- | The default chunk sizes for the output of compression and decompression
--- are 16k and 32k respectively (less a small accounting overhead).
---
-defaultCompressBufferSize, defaultDecompressBufferSize :: Int
-defaultCompressBufferSize   = 16 * 1024 - L.chunkOverhead
-defaultDecompressBufferSize = 32 * 1024 - L.chunkOverhead
-
--- | The unfolding of the decompression process, where you provide a sequence
--- of compressed data chunks as input and receive a sequence of uncompressed
--- data chunks as output. The process is incremental, in that the demand for
--- input and provision of output are interleaved.
---
--- To indicate the end of the input supply an empty input chunk. Note that
--- for 'gzipFormat' with the default 'decompressAllMembers' @True@ you will
--- have to do this, as the decompressor will look for any following members.
--- With 'decompressAllMembers' @False@ the decompressor knows when the data
--- ends and will produce 'DecompressStreamEnd' without you having to supply an
--- empty chunk to indicate the end of the input.
---
-data DecompressStream m =
-
-     DecompressInputRequired {
-         decompressSupplyInput :: S.ByteString -> m (DecompressStream m)
-       }
-
-   | DecompressOutputAvailable {
-         decompressOutput :: !S.ByteString,
-         decompressNext   :: m (DecompressStream m)
-       }
-
-   -- | Includes any trailing unconsumed /input/ data.
-   | DecompressStreamEnd {
-         decompressUnconsumedInput :: S.ByteString
-       }
-
-   -- | An error code
-   | DecompressStreamError {
-         decompressStreamError :: DecompressError
-       }
-
--- | The possible error cases when decompressing a stream.
---
--- This can be 'show'n to give a human readable error message.
---
-data DecompressError =
-     -- | The compressed data stream ended prematurely. This may happen if the
-     -- input data stream was truncated.
-     TruncatedInput
-
-     -- | It is possible to do zlib compression with a custom dictionary. This
-     -- allows slightly higher compression ratios for short files. However such
-     -- compressed streams require the same dictionary when decompressing. This
-     -- error is for when we encounter a compressed stream that needs a
-     -- dictionary, and it's not provided.
-   | DictionaryRequired
-
-     -- | If the stream requires a dictionary and you provide one with the
-     -- wrong 'DictionaryHash' then you will get this error.
-   | DictionaryMismatch
-
-     -- | If the compressed data stream is corrupted in any way then you will
-     -- get this error, for example if the input data just isn't a compressed
-     -- zlib data stream. In particular if the data checksum turns out to be
-     -- wrong then you will get all the decompressed data but this error at the
-     -- end, instead of the normal sucessful 'StreamEnd'.
-   | DataFormatError String
-  deriving (Eq, Typeable)
-
-instance Show DecompressError where
-  show TruncatedInput     = modprefix "premature end of compressed data stream"
-  show DictionaryRequired = modprefix "compressed data stream requires custom dictionary"
-  show DictionaryMismatch = modprefix "given dictionary does not match the expected one"
-  show (DataFormatError detail) = modprefix ("compressed data stream format error (" ++ detail ++ ")")
-
-modprefix :: ShowS
-modprefix = ("Codec.Compression.Zlib: " ++)
-
-instance Exception DecompressError
-
--- | A fold over the 'DecompressStream' in the given monad.
---
--- One way to look at this is that it runs the stream, using callback functions
--- for the four stream events.
---
-foldDecompressStream :: Monad m
-                     => ((S.ByteString -> m a) -> m a)
-                     -> (S.ByteString -> m a -> m a)
-                     -> (S.ByteString -> m a)
-                     -> (DecompressError -> m a)
-                     -> DecompressStream m -> m a
-foldDecompressStream input output end err = fold
-  where
-    fold (DecompressInputRequired next) =
-      input (\x -> next x >>= fold)
-
-    fold (DecompressOutputAvailable outchunk next) =
-      output outchunk (next >>= fold)
-
-    fold (DecompressStreamEnd inchunk) = end inchunk
-    fold (DecompressStreamError derr)  = err derr
-
--- | A variant on 'foldCompressStream' that is pure rather than operating in a
--- monad and where the input is provided by a lazy 'L.ByteString'. So we only
--- have to deal with the output, end and error parts, making it like a foldr on
--- a list of output chunks.
---
--- For example:
---
--- > toChunks = foldDecompressStreamWithInput (:) [] throw
---
-foldDecompressStreamWithInput :: (S.ByteString -> a -> a)
-                              -> (L.ByteString -> a)
-                              -> (DecompressError -> a)
-                              -> (forall s. DecompressStream (ST s))
-                              -> L.ByteString
-                              -> a
-foldDecompressStreamWithInput chunk end err = \s lbs ->
-    runST (fold s (L.toChunks lbs))
-  where
-    fold (DecompressInputRequired next) [] =
-      next S.empty >>= \strm -> fold strm []
-
-    fold (DecompressInputRequired next) (inchunk:inchunks) =
-      next inchunk >>= \s -> fold s inchunks
-
-    fold (DecompressOutputAvailable outchunk next) inchunks = do
-      r <- next >>= \s -> fold s inchunks
-      return $ chunk outchunk r
-
-    fold (DecompressStreamEnd inchunk) inchunks =
-      return $ end (L.fromChunks (inchunk:inchunks))
-
-    fold (DecompressStreamError derr) _ =
-      return $ err derr
-
-
--- $incremental-compression
--- The pure 'compress' and 'decompress' functions are streaming in the sense
--- that they can produce output without demanding all input, however they need
--- the input data stream as a lazy 'L.ByteString'. Having the input data
--- stream as a lazy 'L.ByteString' often requires using lazy I\/O which is not
--- appropriate in all cicumstances.
---
--- For these cases an incremental interface is more appropriate. This interface
--- allows both incremental input and output. Chunks of input data are supplied
--- one by one (e.g. as they are obtained from an input source like a file or
--- network source). Output is also produced chunk by chunk.
---
--- The incremental input and output is managed via the 'CompressStream' and
--- 'DecompressStream' types. They represents the unfolding of the process of
--- compressing and decompressing. They operates in either the 'ST' or 'IO'
--- monads. They can be lifted into other incremental abstractions like pipes or
--- conduits, or they can be used directly in the following style.
-
--- $using-incremental-compression
---
--- In a loop:
---
---  * Inspect the status of the stream
---
---  * When it is 'CompressInputRequired' then you should call the action,
---    passing a chunk of input (or 'BS.empty' when no more input is available)
---    to get the next state of the stream and continue the loop.
---
---  * When it is 'CompressOutputAvailable' then do something with the given
---    chunk of output, and call the action to get the next state of the stream
---    and continue the loop.
---
---  * When it is 'CompressStreamEnd' then terminate the loop.
---
--- Note that you cannot stop as soon as you have no more input, you need to
--- carry on until all the output has been collected, i.e. until you get to
--- 'CompressStreamEnd'.
---
--- Here is an example where we get input from one file handle and send the
--- compressed output to another file handle.
---
--- > go :: Handle -> Handle -> CompressStream IO -> IO ()
--- > go inh outh (CompressInputRequired next) = do
--- >    inchunk <- BS.hGet inh 4096
--- >    go inh outh =<< next inchunk
--- > go inh outh (CompressOutputAvailable outchunk next) =
--- >    BS.hPut outh outchunk
--- >    go inh outh =<< next
--- > go _ _ CompressStreamEnd = return ()
---
--- The same can be achieved with 'foldCompressStream':
---
--- > foldCompressStream
--- >   (\next -> do inchunk <- BS.hGet inh 4096; next inchunk)
--- >   (\outchunk next -> do BS.hPut outh outchunk; next)
--- >   (return ())
-
--- $using-incremental-decompression
---
--- The use of 'DecompressStream' is very similar to 'CompressStream' but with
--- a few differences:
---
--- * There is the extra possibility of a 'DecompressStreamError'
---
--- * There can be extra trailing data after a compressed stream, and the
---   'DecompressStreamEnd' includes that.
---
--- Otherwise the same loop style applies, and there are fold functions.
-
--- | The unfolding of the compression process, where you provide a sequence
--- of uncompressed data chunks as input and receive a sequence of compressed
--- data chunks as output. The process is incremental, in that the demand for
--- input and provision of output are interleaved.
---
-data CompressStream m =
-     CompressInputRequired {
-         compressSupplyInput :: S.ByteString -> m (CompressStream m)
-       }
-
-   | CompressOutputAvailable {
-        compressOutput :: !S.ByteString,
-        compressNext   :: m (CompressStream m)
-      }
-
-   | CompressStreamEnd
-
--- | A fold over the 'CompressStream' in the given monad.
---
--- One way to look at this is that it runs the stream, using callback functions
--- for the three stream events.
---
-foldCompressStream :: Monad m
-                   => ((S.ByteString -> m a) -> m a)
-                   -> (S.ByteString -> m a -> m a)
-                   -> m a
-                   -> CompressStream m -> m a
-foldCompressStream input output end = fold
-  where
-    fold (CompressInputRequired next) =
-      input (\x -> next x >>= fold)
-
-    fold (CompressOutputAvailable outchunk next) =
-      output outchunk (next >>= fold)
-
-    fold CompressStreamEnd =
-      end
-
--- | A variant on 'foldCompressStream' that is pure rather than operating in a
--- monad and where the input is provided by a lazy 'L.ByteString'. So we only
--- have to deal with the output and end parts, making it just like a foldr on a
--- list of output chunks.
---
--- For example:
---
--- > toChunks = foldCompressStreamWithInput (:) []
---
-foldCompressStreamWithInput :: (S.ByteString -> a -> a)
-                            -> a
-                            -> (forall s. CompressStream (ST s))
-                            -> L.ByteString
-                            -> a
-foldCompressStreamWithInput chunk end = \s lbs ->
-    runST (fold s (L.toChunks lbs))
-  where
-    fold (CompressInputRequired next) [] =
-      next S.empty >>= \strm -> fold strm []
-
-    fold (CompressInputRequired next) (inchunk:inchunks) =
-      next inchunk >>= \s -> fold s inchunks
-
-    fold (CompressOutputAvailable outchunk next) inchunks = do
-      r <- next >>= \s -> fold s inchunks
-      return $ chunk outchunk r
-
-    fold CompressStreamEnd _inchunks =
-      return end
-
-
--- | Compress a data stream provided as a lazy 'L.ByteString'.
---
--- There are no expected error conditions. All input data streams are valid. It
--- is possible for unexpected errors to occur, such as running out of memory,
--- or finding the wrong version of the zlib C library, these are thrown as
--- exceptions.
---
-compress   :: Stream.Format -> CompressParams -> L.ByteString -> L.ByteString
-
--- | Incremental compression in the 'ST' monad. Using 'ST' makes it possible
--- to write pure /lazy/ functions while making use of incremental compression.
---
-compressST :: Stream.Format -> CompressParams -> CompressStream (ST s)
-
--- | Incremental compression in the 'IO' monad.
---
-compressIO :: Stream.Format -> CompressParams -> CompressStream IO
-
-compress   format params = foldCompressStreamWithInput
-                             L.Chunk L.Empty
-                             (compressStreamST format params)
-compressST format params = compressStreamST  format params
-compressIO format params = compressStreamIO  format params
-
-compressStream :: Stream.Format -> CompressParams -> S.ByteString
-               -> Stream (CompressStream Stream)
-compressStream format (CompressParams compLevel method bits memLevel
-                                strategy initChunkSize mdict) =
-
-    \chunk -> do
-      Stream.deflateInit format compLevel method bits memLevel strategy
-      setDictionary mdict
-      case chunk of
-        _ | S.null chunk ->
-          fillBuffers 20   --gzip header is 20 bytes, others even smaller
-
-        S.PS inFPtr offset length -> do
-          Stream.pushInputBuffer inFPtr offset length
-          fillBuffers initChunkSize
-
-  where
-    -- we flick between two states:
-    --   * where one or other buffer is empty
-    --       - in which case we refill one or both
-    --   * where both buffers are non-empty
-    --       - in which case we compress until a buffer is empty
-
-  fillBuffers :: Int -> Stream (CompressStream Stream)
-  fillBuffers outChunkSize = do
-#ifdef DEBUG
-    Stream.consistencyCheck
-#endif
-
-    -- in this state there are two possabilities:
-    --   * no outbut buffer space is available
-    --       - in which case we must make more available
-    --   * no input buffer is available
-    --       - in which case we must supply more
-    inputBufferEmpty <- Stream.inputBufferEmpty
-    outputBufferFull <- Stream.outputBufferFull
-
-    assert (inputBufferEmpty || outputBufferFull) $ return ()
-
-    when outputBufferFull $ do
-      outFPtr <- Stream.unsafeLiftIO (S.mallocByteString outChunkSize)
-      Stream.pushOutputBuffer outFPtr 0 outChunkSize
-
-    if inputBufferEmpty
-      then return $ CompressInputRequired $ \chunk ->
-           case chunk of
-             _ | S.null chunk          -> drainBuffers True
-             S.PS inFPtr offset length -> do
-                Stream.pushInputBuffer inFPtr offset length
-                drainBuffers False
-      else drainBuffers False
-
-
-  drainBuffers :: Bool -> Stream (CompressStream Stream)
-  drainBuffers lastChunk = do
-
-    inputBufferEmpty' <- Stream.inputBufferEmpty
-    outputBufferFull' <- Stream.outputBufferFull
-    assert(not outputBufferFull'
-       && (lastChunk || not inputBufferEmpty')) $ return ()
-    -- this invariant guarantees we can always make forward progress
-    -- and that therefore a BufferError is impossible
-
-    let flush = if lastChunk then Stream.Finish else Stream.NoFlush
-    status <- Stream.deflate flush
-
-    case status of
-      Stream.Ok -> do
-        outputBufferFull <- Stream.outputBufferFull
-        if outputBufferFull
-          then do (outFPtr, offset, length) <- Stream.popOutputBuffer
-                  let chunk = S.PS outFPtr offset length
-                  return $ CompressOutputAvailable chunk $ do
-                    fillBuffers defaultCompressBufferSize
-          else do fillBuffers defaultCompressBufferSize
-
-      Stream.StreamEnd -> do
-        inputBufferEmpty <- Stream.inputBufferEmpty
-        assert inputBufferEmpty $ return ()
-        outputBufferBytesAvailable <- Stream.outputBufferBytesAvailable
-        if outputBufferBytesAvailable > 0
-          then do (outFPtr, offset, length) <- Stream.popOutputBuffer
-                  let chunk = S.PS outFPtr offset length
-                  Stream.finalise
-                  return $ CompressOutputAvailable chunk (return CompressStreamEnd)
-          else do Stream.finalise
-                  return CompressStreamEnd
-
-      Stream.Error code msg -> case code of
-        Stream.BufferError  -> fail "BufferError should be impossible!"
-        Stream.NeedDict _   -> fail "NeedDict is impossible!"
-        _                   -> fail msg
-
-  -- Set the custom dictionary, if we were provided with one
-  -- and if the format supports it (zlib and raw, not gzip).
-  setDictionary :: Maybe S.ByteString -> Stream ()
-  setDictionary (Just dict)
-    | Stream.formatSupportsDictionary format = do
-        status <- Stream.deflateSetDictionary dict
-        case status of
-          Stream.Ok          -> return ()
-          Stream.Error _ msg -> fail msg
-          _                  -> fail "error when setting deflate dictionary"
-  setDictionary _ = return ()
-
-
--- | Decompress a data stream provided as a lazy 'L.ByteString'.
---
--- It will throw an exception if any error is encountered in the input data.
--- If you need more control over error handling then use one the incremental
--- versions, 'decompressST' or 'decompressIO'.
---
-decompress   :: Stream.Format -> DecompressParams -> L.ByteString -> L.ByteString
-
--- | Incremental decompression in the 'ST' monad. Using 'ST' makes it possible
--- to write pure /lazy/ functions while making use of incremental decompression.
---
-decompressST :: Stream.Format -> DecompressParams -> DecompressStream (ST s)
-
--- | Incremental decompression in the 'IO' monad.
---
-decompressIO :: Stream.Format -> DecompressParams -> DecompressStream IO
-
-decompress   format params = foldDecompressStreamWithInput
-                               L.Chunk (const L.Empty) throw
-                               (decompressStreamST format params)
-decompressST format params = decompressStreamST  format params
-decompressIO format params = decompressStreamIO  format params
-
-
-decompressStream :: Stream.Format -> DecompressParams
-                 -> Bool -> S.ByteString
-                 -> Stream (DecompressStream Stream)
-decompressStream format (DecompressParams bits initChunkSize mdict allMembers)
-                 resume =
-
-    \chunk -> do
-      inputBufferEmpty <- Stream.inputBufferEmpty
-      outputBufferFull <- Stream.outputBufferFull
-      assert inputBufferEmpty $
-        if resume then assert (format == Stream.gzipFormat && allMembers) $
-                       Stream.inflateReset
-                  else assert outputBufferFull $
-                       Stream.inflateInit format bits
-      case chunk of
-        _ | S.null chunk -> do
-          -- special case to avoid demanding more input again
-          -- always an error anyway
-          when outputBufferFull $ do
-            let outChunkSize = 1
-            outFPtr <- Stream.unsafeLiftIO (S.mallocByteString outChunkSize)
-            Stream.pushOutputBuffer outFPtr 0 outChunkSize
-          drainBuffers True
-
-        S.PS inFPtr offset length -> do
-          Stream.pushInputBuffer inFPtr offset length
-          -- Normally we start with no output buffer (so counts as full) but
-          -- if we're resuming then we'll usually still have output buffer
-          -- space available
-          assert (if not resume then outputBufferFull else True) $ return ()
-          if outputBufferFull
-            then fillBuffers initChunkSize
-            else drainBuffers False
-
-  where
-    -- we flick between two states:
-    --   * where one or other buffer is empty
-    --       - in which case we refill one or both
-    --   * where both buffers are non-empty
-    --       - in which case we compress until a buffer is empty
-
-  fillBuffers :: Int
-              -> Stream (DecompressStream Stream)
-  fillBuffers outChunkSize = do
-#ifdef DEBUG
-    Stream.consistencyCheck
-#endif
-
-    -- in this state there are two possabilities:
-    --   * no outbut buffer space is available
-    --       - in which case we must make more available
-    --   * no input buffer is available
-    --       - in which case we must supply more
-    inputBufferEmpty <- Stream.inputBufferEmpty
-    outputBufferFull <- Stream.outputBufferFull
-
-    assert (inputBufferEmpty || outputBufferFull) $ return ()
-
-    when outputBufferFull $ do
-      outFPtr <- Stream.unsafeLiftIO (S.mallocByteString outChunkSize)
-      Stream.pushOutputBuffer outFPtr 0 outChunkSize
-
-    if inputBufferEmpty
-      then return $ DecompressInputRequired $ \chunk ->
-           case chunk of
-             _ | S.null chunk          -> drainBuffers True
-             S.PS inFPtr offset length -> do
-                Stream.pushInputBuffer inFPtr offset length
-                drainBuffers False
-      else drainBuffers False
-
-
-  drainBuffers :: Bool -> Stream (DecompressStream Stream)
-  drainBuffers lastChunk = do
-
-    inputBufferEmpty' <- Stream.inputBufferEmpty
-    outputBufferFull' <- Stream.outputBufferFull
-    assert(not outputBufferFull'
-       && (lastChunk || not inputBufferEmpty')) $ return ()
-    -- this invariant guarantees we can always make forward progress or at
-    -- least if a BufferError does occur that it must be due to a premature EOF
-
-    status <- Stream.inflate Stream.NoFlush
-
-    case status of
-      Stream.Ok -> do
-        outputBufferFull <- Stream.outputBufferFull
-        if outputBufferFull
-          then do (outFPtr, offset, length) <- Stream.popOutputBuffer
-                  let chunk = S.PS outFPtr offset length
-                  return $ DecompressOutputAvailable chunk $ do
-                    fillBuffers defaultDecompressBufferSize
-          else do fillBuffers defaultDecompressBufferSize
-
-      Stream.StreamEnd      -> do
-        -- The decompressor tells us we're done.
-        -- Note that there may be input bytes still available if the stream is
-        -- embeded in some other data stream, so we return any trailing data.
-        inputBufferEmpty <- Stream.inputBufferEmpty
-        if inputBufferEmpty
-          then do finish (DecompressStreamEnd S.empty)
-          else do (inFPtr, offset, length) <- Stream.popRemainingInputBuffer
-                  let inchunk = S.PS inFPtr offset length
-                  finish (DecompressStreamEnd inchunk)
-
-      Stream.Error code msg -> case code of
-        Stream.BufferError  -> finish (DecompressStreamError TruncatedInput)
-        Stream.NeedDict adler -> do
-          err <- setDictionary adler mdict
-          case err of
-            Just streamErr  -> finish streamErr
-            Nothing         -> drainBuffers lastChunk
-        Stream.DataError    -> finish (DecompressStreamError (DataFormatError msg))
-        _                   -> fail msg
-
-  -- Note even if we end with an error we still try to flush the last chunk if
-  -- there is one. The user just has to decide what they want to trust.
-  finish end = do
-    outputBufferBytesAvailable <- Stream.outputBufferBytesAvailable
-    if outputBufferBytesAvailable > 0
-      then do (outFPtr, offset, length) <- Stream.popOutputBuffer
-              return (DecompressOutputAvailable (S.PS outFPtr offset length) (return end))
-      else return end
-
-  setDictionary :: Stream.DictionaryHash -> Maybe S.ByteString
-                -> Stream (Maybe (DecompressStream Stream))
-  setDictionary _adler Nothing =
-    return $ Just (DecompressStreamError DictionaryRequired)
-  setDictionary _adler (Just dict) = do
-    status <- Stream.inflateSetDictionary dict
-    case status of
-      Stream.Ok -> return Nothing
-      Stream.Error Stream.DataError _   ->
-        return $ Just (DecompressStreamError DictionaryMismatch)
-      _ -> fail "error when setting inflate dictionary"
-
-
-------------------------------------------------------------------------------
-
-mkStateST :: ST s (Stream.State s)
-mkStateIO :: IO (Stream.State RealWorld)
-mkStateST = strictToLazyST Stream.mkState
-mkStateIO = stToIO Stream.mkState
-
-runStreamST :: Stream a -> Stream.State s -> ST s (a, Stream.State s)
-runStreamIO :: Stream a -> Stream.State RealWorld -> IO (a, Stream.State RealWorld)
-runStreamST strm zstate = strictToLazyST (Unsafe.unsafeIOToST noDuplicate >> Stream.runStream strm zstate)
-runStreamIO strm zstate = stToIO (Stream.runStream strm zstate)
-
-compressStreamIO :: Stream.Format -> CompressParams -> CompressStream IO
-compressStreamIO format params =
-    CompressInputRequired {
-      compressSupplyInput = \chunk -> do
-        zstate <- mkStateIO
-        let next = compressStream format params
-        (strm', zstate') <- runStreamIO (next chunk) zstate
-        return (go strm' zstate')
-    }
-  where
-    go :: CompressStream Stream -> Stream.State RealWorld -> CompressStream IO
-    go (CompressInputRequired next) zstate =
-      CompressInputRequired {
-        compressSupplyInput = \chunk -> do
-          (strm', zstate') <- runStreamIO (next chunk) zstate
-          return (go strm' zstate')
-      }
-
-    go (CompressOutputAvailable chunk next) zstate =
-      CompressOutputAvailable chunk $ do
-        (strm', zstate') <- runStreamIO next zstate
-        return (go strm' zstate')
-
-    go CompressStreamEnd _ = CompressStreamEnd
-
-compressStreamST :: Stream.Format -> CompressParams -> CompressStream (ST s)
-compressStreamST format params =
-    CompressInputRequired {
-      compressSupplyInput = \chunk -> do
-        zstate <- mkStateST
-        let next = compressStream format params
-        (strm', zstate') <- runStreamST (next chunk) zstate
-        return (go strm' zstate')
-    }
-  where
-    go :: CompressStream Stream -> Stream.State s -> CompressStream (ST s)
-    go (CompressInputRequired next) zstate =
-      CompressInputRequired {
-        compressSupplyInput = \chunk -> do
-          (strm', zstate') <- runStreamST (next chunk) zstate
-          return (go strm' zstate')
-      }
-
-    go (CompressOutputAvailable chunk next) zstate =
-      CompressOutputAvailable chunk $ do
-        (strm', zstate') <- runStreamST next zstate
-        return (go strm' zstate')
-
-    go CompressStreamEnd _ = CompressStreamEnd
-
-
-decompressStreamIO :: Stream.Format -> DecompressParams -> DecompressStream IO
-decompressStreamIO format params =
-      DecompressInputRequired $ \chunk -> do
-        zstate <- mkStateIO
-        let next = decompressStream format params False
-        (strm', zstate') <- runStreamIO (next chunk) zstate
-        go strm' zstate' (S.null chunk)
-  where
-    go :: DecompressStream Stream -> Stream.State RealWorld -> Bool
-       -> IO (DecompressStream IO)
-    go (DecompressInputRequired next) zstate !_ =
-      return $ DecompressInputRequired $ \chunk -> do
-        (strm', zstate') <- runStreamIO (next chunk) zstate
-        go strm' zstate' (S.null chunk)
-
-    go (DecompressOutputAvailable chunk next) zstate !eof =
-      return $ DecompressOutputAvailable chunk $ do
-        (strm', zstate') <- runStreamIO next zstate
-        go strm' zstate' eof
-
-    go (DecompressStreamEnd unconsumed) zstate !eof
-      | format == Stream.gzipFormat
-      , decompressAllMembers params
-      , not eof    = tryFollowingStream unconsumed zstate
-      | otherwise  = finaliseStreamEnd unconsumed zstate
-
-    go (DecompressStreamError err) zstate !_ = finaliseStreamError err zstate
-
-    tryFollowingStream :: S.ByteString -> Stream.State RealWorld -> IO (DecompressStream IO)
-    tryFollowingStream chunk zstate = case S.length chunk of
-      0 -> return $ DecompressInputRequired $ \chunk' -> case S.length chunk' of
-         0 -> finaliseStreamEnd S.empty zstate
-         1 | S.head chunk' /= 0x1f
-           -> finaliseStreamEnd chunk' zstate
-         1 -> return $ DecompressInputRequired $ \chunk'' -> case S.length chunk'' of
-            0 -> finaliseStreamEnd chunk' zstate
-            _ -> checkHeaderSplit (S.head chunk') chunk'' zstate
-         _    -> checkHeader chunk' zstate
-      1 -> return $ DecompressInputRequired $ \chunk' -> case S.length chunk' of
-         0    -> finaliseStreamEnd chunk zstate
-         _    -> checkHeaderSplit (S.head chunk) chunk' zstate
-      _       -> checkHeader chunk zstate
-
-    checkHeaderSplit :: Word8 -> S.ByteString -> Stream.State RealWorld -> IO (DecompressStream IO)
-    checkHeaderSplit 0x1f chunk zstate
-      | S.head chunk == 0x8b = do
-        let resume = decompressStream format params True (S.pack [0x1f, 0x8b])
-        if S.length chunk > 1
-          then do
-            -- have to handle the remaining data in this chunk
-            (DecompressInputRequired next, zstate') <- runStreamIO resume zstate
-            (strm', zstate'') <- runStreamIO (next (S.tail chunk)) zstate'
-            go strm' zstate'' False
-          else do
-            -- subtle special case when the chunk tail is empty
-            -- yay for QC tests
-            (strm, zstate') <- runStreamIO resume zstate
-            go strm zstate' False
-    checkHeaderSplit byte chunk zstate =
-        finaliseStreamEnd (S.cons byte chunk) zstate
-
-    checkHeader :: S.ByteString -> Stream.State RealWorld -> IO (DecompressStream IO)
-    checkHeader chunk zstate
-      | S.index chunk 0 == 0x1f
-      , S.index chunk 1 == 0x8b = do
-        let resume = decompressStream format params True chunk
-        (strm', zstate') <- runStreamIO resume zstate
-        go strm' zstate' False
-    checkHeader chunk zstate = finaliseStreamEnd chunk zstate
-
-    finaliseStreamEnd unconsumed zstate = do
-        _ <- runStreamIO Stream.finalise zstate
-        return (DecompressStreamEnd unconsumed)
-
-    finaliseStreamError err zstate = do
-        _ <- runStreamIO Stream.finalise zstate
-        return (DecompressStreamError err)
-
-
-decompressStreamST :: Stream.Format -> DecompressParams -> DecompressStream (ST s)
-decompressStreamST format params =
-      DecompressInputRequired $ \chunk -> do
-        zstate <- mkStateST
-        let next = decompressStream format params False
-        (strm', zstate') <- runStreamST (next chunk) zstate
-        go strm' zstate' (S.null chunk)
-  where
-    go :: DecompressStream Stream -> Stream.State s -> Bool
-       -> ST s (DecompressStream (ST s))
-    go (DecompressInputRequired next) zstate !_ =
-      return $ DecompressInputRequired $ \chunk -> do
-        (strm', zstate') <- runStreamST (next chunk) zstate
-        go strm' zstate' (S.null chunk)
-
-    go (DecompressOutputAvailable chunk next) zstate !eof =
-      return $ DecompressOutputAvailable chunk $ do
-        (strm', zstate') <- runStreamST next zstate
-        go strm' zstate' eof
-
-    go (DecompressStreamEnd unconsumed) zstate !eof
-      | format == Stream.gzipFormat
-      , decompressAllMembers params
-      , not eof    = tryFollowingStream unconsumed zstate
-      | otherwise  = finaliseStreamEnd unconsumed zstate
-
-    go (DecompressStreamError err) zstate !_ = finaliseStreamError err zstate
-
-
-    tryFollowingStream :: S.ByteString -> Stream.State s -> ST s (DecompressStream (ST s))
-    tryFollowingStream chunk zstate = 
-      case S.length chunk of
-      0 -> return $ DecompressInputRequired $ \chunk' -> case S.length chunk' of
-         0 -> finaliseStreamEnd S.empty zstate
-         1 | S.head chunk' /= 0x1f
-           -> finaliseStreamEnd chunk' zstate
-         1 -> return $ DecompressInputRequired $ \chunk'' -> case S.length chunk'' of
-            0 -> finaliseStreamEnd chunk' zstate
-            _ -> checkHeaderSplit (S.head chunk') chunk'' zstate
-         _    -> checkHeader chunk' zstate
-      1 -> return $ DecompressInputRequired $ \chunk' -> case S.length chunk' of
-         0    -> finaliseStreamEnd chunk zstate
-         _    -> checkHeaderSplit (S.head chunk) chunk' zstate
-      _       -> checkHeader chunk zstate
-
-    checkHeaderSplit :: Word8 -> S.ByteString -> Stream.State s -> ST s (DecompressStream (ST s))
-    checkHeaderSplit 0x1f chunk zstate
-      | S.head chunk == 0x8b = do
-        let resume = decompressStream format params True (S.pack [0x1f, 0x8b])
-        if S.length chunk > 1
-          then do
-            -- have to handle the remaining data in this chunk
-            (DecompressInputRequired next, zstate') <- runStreamST resume zstate
-            (strm', zstate'') <- runStreamST (next (S.tail chunk)) zstate'
-            go strm' zstate'' False
-          else do
-            -- subtle special case when the chunk tail is empty
-            -- yay for QC tests
-            (strm, zstate') <- runStreamST resume zstate
-            go strm zstate' False
-    checkHeaderSplit byte chunk zstate =
-        finaliseStreamEnd (S.cons byte chunk) zstate
-
-    checkHeader :: S.ByteString -> Stream.State s -> ST s (DecompressStream (ST s))
-    checkHeader chunk zstate
-      | S.index chunk 0 == 0x1f
-      , S.index chunk 1 == 0x8b = do
-        let resume = decompressStream format params True chunk
-        (strm', zstate') <- runStreamST resume zstate
-        go strm' zstate' False
-    checkHeader chunk zstate = finaliseStreamEnd chunk zstate
-
-    finaliseStreamEnd unconsumed zstate = do
-        _ <- runStreamST Stream.finalise zstate
-        return (DecompressStreamEnd unconsumed)
-
-    finaliseStreamError err zstate = do
-        _ <- runStreamST Stream.finalise zstate
-        return (DecompressStreamError err)

3rdparty/zlib/Codec/Compression/Zlib/Raw.hs

@@ -1,68 +0,0 @@
------------------------------------------------------------------------------
--- |
--- Copyright   :  (c) 2006-2014 Duncan Coutts
--- License     :  BSD-style
---
--- Maintainer  :  duncan@community.haskell.org
---
--- Compression and decompression of data streams in the raw deflate format.
---
--- The format is described in detail in RFC #1951:
--- <http://www.ietf.org/rfc/rfc1951.txt>
---
--- See also the zlib home page: <http://zlib.net/>
---
------------------------------------------------------------------------------
-module Codec.Compression.Zlib.Raw (
-  
-  -- * Simple compression and decompression
-  compress,
-  decompress,
-
-  -- * Extended api with control over compression parameters
-  compressWith,
-  decompressWith,
-
-  CompressParams(..), defaultCompressParams,
-  DecompressParams(..), defaultDecompressParams,
-
-  -- ** The compression parameter types
-  CompressionLevel(..),
-    defaultCompression,
-    noCompression,
-    bestSpeed,
-    bestCompression,
-    compressionLevel,
-  Method(..),
-    deflateMethod,
-  WindowBits(..),
-    defaultWindowBits,
-    windowBits,
-  MemoryLevel(..),
-    defaultMemoryLevel,
-    minMemoryLevel,
-    maxMemoryLevel,
-    memoryLevel,
-  CompressionStrategy(..),
-    defaultStrategy,
-    filteredStrategy,
-    huffmanOnlyStrategy,
-
-  ) where
-
-import Data.ByteString.Lazy (ByteString)
-
-import qualified Codec.Compression.Zlib.Internal as Internal
-import Codec.Compression.Zlib.Internal hiding (compress, decompress)
-
-decompress :: ByteString -> ByteString
-decompress = decompressWith defaultDecompressParams
-
-decompressWith :: DecompressParams -> ByteString -> ByteString
-decompressWith = Internal.decompress rawFormat
-
-compress :: ByteString -> ByteString
-compress = compressWith defaultCompressParams
-
-compressWith :: CompressParams -> ByteString -> ByteString
-compressWith = Internal.compress rawFormat

3rdparty/zlib/LICENSE

@@ -1,24 +0,0 @@
-Copyright (c) 2006-2016, Duncan Coutts
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice,
-   this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-3. This clause is intentionally left blank.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE.

3rdparty/zlib/Setup.hs

@@ -1,2 +0,0 @@
-import Distribution.Simple
-main = defaultMain

3rdparty/zlib/TODO

@@ -1,3 +0,0 @@
-* Currently will not support bytestring chunks bigger than 4Gb
-  because the in_avail is only a C int. So chunks bigger than that
-  need to be broken up into smaller ones.

3rdparty/zlib/cbits/adler32.c

@@ -1,179 +0,0 @@
-/* adler32.c -- compute the Adler-32 checksum of a data stream
- * Copyright (C) 1995-2011 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* @(#) $Id$ */
-
-#include "zutil.h"
-
-#define local static
-
-local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
-
-#define BASE 65521      /* largest prime smaller than 65536 */
-#define NMAX 5552
-/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
-
-#define DO1(buf,i)  {adler += (buf)[i]; sum2 += adler;}
-#define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
-#define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
-#define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
-#define DO16(buf)   DO8(buf,0); DO8(buf,8);
-
-/* use NO_DIVIDE if your processor does not do division in hardware --
-   try it both ways to see which is faster */
-#ifdef NO_DIVIDE
-/* note that this assumes BASE is 65521, where 65536 % 65521 == 15
-   (thank you to John Reiser for pointing this out) */
-#  define CHOP(a) \
-    do { \
-        unsigned long tmp = a >> 16; \
-        a &= 0xffffUL; \
-        a += (tmp << 4) - tmp; \
-    } while (0)
-#  define MOD28(a) \
-    do { \
-        CHOP(a); \
-        if (a >= BASE) a -= BASE; \
-    } while (0)
-#  define MOD(a) \
-    do { \
-        CHOP(a); \
-        MOD28(a); \
-    } while (0)
-#  define MOD63(a) \
-    do { /* this assumes a is not negative */ \
-        z_off64_t tmp = a >> 32; \
-        a &= 0xffffffffL; \
-        a += (tmp << 8) - (tmp << 5) + tmp; \
-        tmp = a >> 16; \
-        a &= 0xffffL; \
-        a += (tmp << 4) - tmp; \
-        tmp = a >> 16; \
-        a &= 0xffffL; \
-        a += (tmp << 4) - tmp; \
-        if (a >= BASE) a -= BASE; \
-    } while (0)
-#else
-#  define MOD(a) a %= BASE
-#  define MOD28(a) a %= BASE
-#  define MOD63(a) a %= BASE
-#endif
-
-/* ========================================================================= */
-uLong ZEXPORT adler32(adler, buf, len)
-    uLong adler;
-    const Bytef *buf;
-    uInt len;
-{
-    unsigned long sum2;
-    unsigned n;
-
-    /* split Adler-32 into component sums */
-    sum2 = (adler >> 16) & 0xffff;
-    adler &= 0xffff;
-
-    /* in case user likes doing a byte at a time, keep it fast */
-    if (len == 1) {
-        adler += buf[0];
-        if (adler >= BASE)
-            adler -= BASE;
-        sum2 += adler;
-        if (sum2 >= BASE)
-            sum2 -= BASE;
-        return adler | (sum2 << 16);
-    }
-
-    /* initial Adler-32 value (deferred check for len == 1 speed) */
-    if (buf == Z_NULL)
-        return 1L;
-
-    /* in case short lengths are provided, keep it somewhat fast */
-    if (len < 16) {
-        while (len--) {
-            adler += *buf++;
-            sum2 += adler;
-        }
-        if (adler >= BASE)
-            adler -= BASE;
-        MOD28(sum2);            /* only added so many BASE's */
-        return adler | (sum2 << 16);
-    }
-
-    /* do length NMAX blocks -- requires just one modulo operation */
-    while (len >= NMAX) {
-        len -= NMAX;
-        n = NMAX / 16;          /* NMAX is divisible by 16 */
-        do {
-            DO16(buf);          /* 16 sums unrolled */
-            buf += 16;
-        } while (--n);
-        MOD(adler);
-        MOD(sum2);
-    }
-
-    /* do remaining bytes (less than NMAX, still just one modulo) */
-    if (len) {                  /* avoid modulos if none remaining */
-        while (len >= 16) {
-            len -= 16;
-            DO16(buf);
-            buf += 16;
-        }
-        while (len--) {
-            adler += *buf++;
-            sum2 += adler;
-        }
-        MOD(adler);
-        MOD(sum2);
-    }
-
-    /* return recombined sums */
-    return adler | (sum2 << 16);
-}
-
-/* ========================================================================= */
-local uLong adler32_combine_(adler1, adler2, len2)
-    uLong adler1;
-    uLong adler2;
-    z_off64_t len2;
-{
-    unsigned long sum1;
-    unsigned long sum2;
-    unsigned rem;
-
-    /* for negative len, return invalid adler32 as a clue for debugging */
-    if (len2 < 0)
-        return 0xffffffffUL;
-
-    /* the derivation of this formula is left as an exercise for the reader */
-    MOD63(len2);                /* assumes len2 >= 0 */
-    rem = (unsigned)len2;
-    sum1 = adler1 & 0xffff;
-    sum2 = rem * sum1;
-    MOD(sum2);
-    sum1 += (adler2 & 0xffff) + BASE - 1;
-    sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
-    if (sum1 >= BASE) sum1 -= BASE;
-    if (sum1 >= BASE) sum1 -= BASE;
-    if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1);
-    if (sum2 >= BASE) sum2 -= BASE;
-    return sum1 | (sum2 << 16);
-}
-
-/* ========================================================================= */
-uLong ZEXPORT adler32_combine(adler1, adler2, len2)
-    uLong adler1;
-    uLong adler2;
-    z_off_t len2;
-{
-    return adler32_combine_(adler1, adler2, len2);
-}
-
-uLong ZEXPORT adler32_combine64(adler1, adler2, len2)
-    uLong adler1;
-    uLong adler2;
-    z_off64_t len2;
-{
-    return adler32_combine_(adler1, adler2, len2);
-}

3rdparty/zlib/cbits/compress.c

@@ -1,80 +0,0 @@
-/* compress.c -- compress a memory buffer
- * Copyright (C) 1995-2005 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* @(#) $Id$ */
-
-#define ZLIB_INTERNAL
-#include "zlib.h"
-
-/* ===========================================================================
-     Compresses the source buffer into the destination buffer. The level
-   parameter has the same meaning as in deflateInit.  sourceLen is the byte
-   length of the source buffer. Upon entry, destLen is the total size of the
-   destination buffer, which must be at least 0.1% larger than sourceLen plus
-   12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
-
-     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
-   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
-   Z_STREAM_ERROR if the level parameter is invalid.
-*/
-int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
-    Bytef *dest;
-    uLongf *destLen;
-    const Bytef *source;
-    uLong sourceLen;
-    int level;
-{
-    z_stream stream;
-    int err;
-
-    stream.next_in = (z_const Bytef *)source;
-    stream.avail_in = (uInt)sourceLen;
-#ifdef MAXSEG_64K
-    /* Check for source > 64K on 16-bit machine: */
-    if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
-#endif
-    stream.next_out = dest;
-    stream.avail_out = (uInt)*destLen;
-    if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
-
-    stream.zalloc = (alloc_func)0;
-    stream.zfree = (free_func)0;
-    stream.opaque = (voidpf)0;
-
-    err = deflateInit(&stream, level);
-    if (err != Z_OK) return err;
-
-    err = deflate(&stream, Z_FINISH);
-    if (err != Z_STREAM_END) {
-        deflateEnd(&stream);
-        return err == Z_OK ? Z_BUF_ERROR : err;
-    }
-    *destLen = stream.total_out;
-
-    err = deflateEnd(&stream);
-    return err;
-}
-
-/* ===========================================================================
- */
-int ZEXPORT compress (dest, destLen, source, sourceLen)
-    Bytef *dest;
-    uLongf *destLen;
-    const Bytef *source;
-    uLong sourceLen;
-{
-    return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
-}
-
-/* ===========================================================================
-     If the default memLevel or windowBits for deflateInit() is changed, then
-   this function needs to be updated.
- */
-uLong ZEXPORT compressBound (sourceLen)
-    uLong sourceLen;
-{
-    return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
-           (sourceLen >> 25) + 13;
-}

3rdparty/zlib/cbits/crc32.c

@@ -1,425 +0,0 @@
-/* crc32.c -- compute the CRC-32 of a data stream
- * Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- *
- * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
- * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing
- * tables for updating the shift register in one step with three exclusive-ors
- * instead of four steps with four exclusive-ors.  This results in about a
- * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.
- */
-
-/* @(#) $Id$ */
-
-/*
-  Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore
-  protection on the static variables used to control the first-use generation
-  of the crc tables.  Therefore, if you #define DYNAMIC_CRC_TABLE, you should
-  first call get_crc_table() to initialize the tables before allowing more than
-  one thread to use crc32().
-
-  DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h.
- */
-
-#ifdef MAKECRCH
-#  include <stdio.h>
-#  ifndef DYNAMIC_CRC_TABLE
-#    define DYNAMIC_CRC_TABLE
-#  endif /* !DYNAMIC_CRC_TABLE */
-#endif /* MAKECRCH */
-
-#include "zutil.h"      /* for STDC and FAR definitions */
-
-#define local static
-
-/* Definitions for doing the crc four data bytes at a time. */
-#if !defined(NOBYFOUR) && defined(Z_U4)
-#  define BYFOUR
-#endif
-#ifdef BYFOUR
-   local unsigned long crc32_little OF((unsigned long,
-                        const unsigned char FAR *, unsigned));
-   local unsigned long crc32_big OF((unsigned long,
-                        const unsigned char FAR *, unsigned));
-#  define TBLS 8
-#else
-#  define TBLS 1
-#endif /* BYFOUR */
-
-/* Local functions for crc concatenation */
-local unsigned long gf2_matrix_times OF((unsigned long *mat,
-                                         unsigned long vec));
-local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
-local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2));
-
-
-#ifdef DYNAMIC_CRC_TABLE
-
-local volatile int crc_table_empty = 1;
-local z_crc_t FAR crc_table[TBLS][256];
-local void make_crc_table OF((void));
-#ifdef MAKECRCH
-   local void write_table OF((FILE *, const z_crc_t FAR *));
-#endif /* MAKECRCH */
-/*
-  Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
-  x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
-
-  Polynomials over GF(2) are represented in binary, one bit per coefficient,
-  with the lowest powers in the most significant bit.  Then adding polynomials
-  is just exclusive-or, and multiplying a polynomial by x is a right shift by
-  one.  If we call the above polynomial p, and represent a byte as the
-  polynomial q, also with the lowest power in the most significant bit (so the
-  byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
-  where a mod b means the remainder after dividing a by b.
-
-  This calculation is done using the shift-register method of multiplying and
-  taking the remainder.  The register is initialized to zero, and for each
-  incoming bit, x^32 is added mod p to the register if the bit is a one (where
-  x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
-  x (which is shifting right by one and adding x^32 mod p if the bit shifted
-  out is a one).  We start with the highest power (least significant bit) of
-  q and repeat for all eight bits of q.
-
-  The first table is simply the CRC of all possible eight bit values.  This is
-  all the information needed to generate CRCs on data a byte at a time for all
-  combinations of CRC register values and incoming bytes.  The remaining tables
-  allow for word-at-a-time CRC calculation for both big-endian and little-
-  endian machines, where a word is four bytes.
-*/
-local void make_crc_table()
-{
-    z_crc_t c;
-    int n, k;
-    z_crc_t poly;                       /* polynomial exclusive-or pattern */
-    /* terms of polynomial defining this crc (except x^32): */
-    static volatile int first = 1;      /* flag to limit concurrent making */
-    static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
-
-    /* See if another task is already doing this (not thread-safe, but better
-       than nothing -- significantly reduces duration of vulnerability in
-       case the advice about DYNAMIC_CRC_TABLE is ignored) */
-    if (first) {
-        first = 0;
-
-        /* make exclusive-or pattern from polynomial (0xedb88320UL) */
-        poly = 0;
-        for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++)
-            poly |= (z_crc_t)1 << (31 - p[n]);
-
-        /* generate a crc for every 8-bit value */
-        for (n = 0; n < 256; n++) {
-            c = (z_crc_t)n;
-            for (k = 0; k < 8; k++)
-                c = c & 1 ? poly ^ (c >> 1) : c >> 1;
-            crc_table[0][n] = c;
-        }
-
-#ifdef BYFOUR
-        /* generate crc for each value followed by one, two, and three zeros,
-           and then the byte reversal of those as well as the first table */
-        for (n = 0; n < 256; n++) {
-            c = crc_table[0][n];
-            crc_table[4][n] = ZSWAP32(c);
-            for (k = 1; k < 4; k++) {
-                c = crc_table[0][c & 0xff] ^ (c >> 8);
-                crc_table[k][n] = c;
-                crc_table[k + 4][n] = ZSWAP32(c);
-            }
-        }
-#endif /* BYFOUR */
-
-        crc_table_empty = 0;
-    }
-    else {      /* not first */
-        /* wait for the other guy to finish (not efficient, but rare) */
-        while (crc_table_empty)
-            ;
-    }
-
-#ifdef MAKECRCH
-    /* write out CRC tables to crc32.h */
-    {
-        FILE *out;
-
-        out = fopen("crc32.h", "w");
-        if (out == NULL) return;
-        fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");
-        fprintf(out, " * Generated automatically by crc32.c\n */\n\n");
-        fprintf(out, "local const z_crc_t FAR ");
-        fprintf(out, "crc_table[TBLS][256] =\n{\n  {\n");
-        write_table(out, crc_table[0]);
-#  ifdef BYFOUR
-        fprintf(out, "#ifdef BYFOUR\n");
-        for (k = 1; k < 8; k++) {
-            fprintf(out, "  },\n  {\n");
-            write_table(out, crc_table[k]);
-        }
-        fprintf(out, "#endif\n");
-#  endif /* BYFOUR */
-        fprintf(out, "  }\n};\n");
-        fclose(out);
-    }
-#endif /* MAKECRCH */
-}
-
-#ifdef MAKECRCH
-local void write_table(out, table)
-    FILE *out;
-    const z_crc_t FAR *table;
-{
-    int n;
-
-    for (n = 0; n < 256; n++)
-        fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : "    ",
-                (unsigned long)(table[n]),
-                n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));
-}
-#endif /* MAKECRCH */
-
-#else /* !DYNAMIC_CRC_TABLE */
-/* ========================================================================
- * Tables of CRC-32s of all single-byte values, made by make_crc_table().
- */
-#include "crc32.h"
-#endif /* DYNAMIC_CRC_TABLE */
-
-/* =========================================================================
- * This function can be used by asm versions of crc32()
- */
-const z_crc_t FAR * ZEXPORT get_crc_table()
-{
-#ifdef DYNAMIC_CRC_TABLE
-    if (crc_table_empty)
-        make_crc_table();
-#endif /* DYNAMIC_CRC_TABLE */
-    return (const z_crc_t FAR *)crc_table;
-}
-
-/* ========================================================================= */
-#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8)
-#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
-
-/* ========================================================================= */
-unsigned long ZEXPORT crc32(crc, buf, len)
-    unsigned long crc;
-    const unsigned char FAR *buf;
-    uInt len;
-{
-    if (buf == Z_NULL) return 0UL;
-
-#ifdef DYNAMIC_CRC_TABLE
-    if (crc_table_empty)
-        make_crc_table();
-#endif /* DYNAMIC_CRC_TABLE */
-
-#ifdef BYFOUR
-    if (sizeof(void *) == sizeof(ptrdiff_t)) {
-        z_crc_t endian;
-
-        endian = 1;
-        if (*((unsigned char *)(&endian)))
-            return crc32_little(crc, buf, len);
-        else
-            return crc32_big(crc, buf, len);
-    }
-#endif /* BYFOUR */
-    crc = crc ^ 0xffffffffUL;
-    while (len >= 8) {
-        DO8;
-        len -= 8;
-    }
-    if (len) do {
-        DO1;
-    } while (--len);
-    return crc ^ 0xffffffffUL;
-}
-
-#ifdef BYFOUR
-
-/* ========================================================================= */
-#define DOLIT4 c ^= *buf4++; \
-        c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
-            crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24]
-#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4
-
-/* ========================================================================= */
-local unsigned long crc32_little(crc, buf, len)
-    unsigned long crc;
-    const unsigned char FAR *buf;
-    unsigned len;
-{
-    register z_crc_t c;
-    register const z_crc_t FAR *buf4;
-
-    c = (z_crc_t)crc;
-    c = ~c;
-    while (len && ((ptrdiff_t)buf & 3)) {
-        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
-        len--;
-    }
-
-    buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
-    while (len >= 32) {
-        DOLIT32;
-        len -= 32;
-    }
-    while (len >= 4) {
-        DOLIT4;
-        len -= 4;
-    }
-    buf = (const unsigned char FAR *)buf4;
-
-    if (len) do {
-        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
-    } while (--len);
-    c = ~c;
-    return (unsigned long)c;
-}
-
-/* ========================================================================= */
-#define DOBIG4 c ^= *++buf4; \
-        c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
-            crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
-#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
-
-/* ========================================================================= */
-local unsigned long crc32_big(crc, buf, len)
-    unsigned long crc;
-    const unsigned char FAR *buf;
-    unsigned len;
-{
-    register z_crc_t c;
-    register const z_crc_t FAR *buf4;
-
-    c = ZSWAP32((z_crc_t)crc);
-    c = ~c;
-    while (len && ((ptrdiff_t)buf & 3)) {
-        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
-        len--;
-    }
-
-    buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
-    buf4--;
-    while (len >= 32) {
-        DOBIG32;
-        len -= 32;
-    }
-    while (len >= 4) {
-        DOBIG4;
-        len -= 4;
-    }
-    buf4++;
-    buf = (const unsigned char FAR *)buf4;
-
-    if (len) do {
-        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
-    } while (--len);
-    c = ~c;
-    return (unsigned long)(ZSWAP32(c));
-}
-
-#endif /* BYFOUR */
-
-#define GF2_DIM 32      /* dimension of GF(2) vectors (length of CRC) */
-
-/* ========================================================================= */
-local unsigned long gf2_matrix_times(mat, vec)
-    unsigned long *mat;
-    unsigned long vec;
-{
-    unsigned long sum;
-
-    sum = 0;
-    while (vec) {
-        if (vec & 1)
-            sum ^= *mat;
-        vec >>= 1;
-        mat++;
-    }
-    return sum;
-}
-
-/* ========================================================================= */
-local void gf2_matrix_square(square, mat)
-    unsigned long *square;
-    unsigned long *mat;
-{
-    int n;
-
-    for (n = 0; n < GF2_DIM; n++)
-        square[n] = gf2_matrix_times(mat, mat[n]);
-}
-
-/* ========================================================================= */
-local uLong crc32_combine_(crc1, crc2, len2)
-    uLong crc1;
-    uLong crc2;
-    z_off64_t len2;
-{
-    int n;
-    unsigned long row;
-    unsigned long even[GF2_DIM];    /* even-power-of-two zeros operator */
-    unsigned long odd[GF2_DIM];     /* odd-power-of-two zeros operator */
-
-    /* degenerate case (also disallow negative lengths) */
-    if (len2 <= 0)
-        return crc1;
-
-    /* put operator for one zero bit in odd */
-    odd[0] = 0xedb88320UL;          /* CRC-32 polynomial */
-    row = 1;
-    for (n = 1; n < GF2_DIM; n++) {
-        odd[n] = row;
-        row <<= 1;
-    }
-
-    /* put operator for two zero bits in even */
-    gf2_matrix_square(even, odd);
-
-    /* put operator for four zero bits in odd */
-    gf2_matrix_square(odd, even);
-
-    /* apply len2 zeros to crc1 (first square will put the operator for one
-       zero byte, eight zero bits, in even) */
-    do {
-        /* apply zeros operator for this bit of len2 */
-        gf2_matrix_square(even, odd);
-        if (len2 & 1)
-            crc1 = gf2_matrix_times(even, crc1);
-        len2 >>= 1;
-
-        /* if no more bits set, then done */
-        if (len2 == 0)
-            break;
-
-        /* another iteration of the loop with odd and even swapped */
-        gf2_matrix_square(odd, even);
-        if (len2 & 1)
-            crc1 = gf2_matrix_times(odd, crc1);
-        len2 >>= 1;
-
-        /* if no more bits set, then done */
-    } while (len2 != 0);
-
-    /* return combined crc */
-    crc1 ^= crc2;
-    return crc1;
-}
-
-/* ========================================================================= */
-uLong ZEXPORT crc32_combine(crc1, crc2, len2)
-    uLong crc1;
-    uLong crc2;
-    z_off_t len2;
-{
-    return crc32_combine_(crc1, crc2, len2);
-}
-
-uLong ZEXPORT crc32_combine64(crc1, crc2, len2)
-    uLong crc1;
-    uLong crc2;
-    z_off64_t len2;
-{
-    return crc32_combine_(crc1, crc2, len2);
-}

3rdparty/zlib/cbits/crc32.h

@@ -1,441 +0,0 @@
-/* crc32.h -- tables for rapid CRC calculation
- * Generated automatically by crc32.c
- */
-
-local const z_crc_t FAR crc_table[TBLS][256] =
-{
-  {
-    0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
-    0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
-    0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
-    0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
-    0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
-    0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
-    0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
-    0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
-    0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
-    0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
-    0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
-    0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
-    0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
-    0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
-    0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
-    0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
-    0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
-    0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
-    0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
-    0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
-    0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
-    0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
-    0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
-    0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
-    0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
-    0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
-    0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
-    0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
-    0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
-    0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
-    0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
-    0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
-    0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
-    0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
-    0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
-    0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
-    0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
-    0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
-    0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
-    0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
-    0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
-    0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
-    0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
-    0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
-    0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
-    0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
-    0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
-    0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
-    0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
-    0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
-    0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
-    0x2d02ef8dUL
-#ifdef BYFOUR
-  },
-  {
-    0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL,
-    0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL,
-    0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL,
-    0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL,
-    0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL,
-    0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL,
-    0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL,
-    0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL,
-    0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL,
-    0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL,
-    0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL,
-    0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL,
-    0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL,
-    0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL,
-    0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL,
-    0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL,
-    0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL,
-    0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL,
-    0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL,
-    0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL,
-    0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL,
-    0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL,
-    0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL,
-    0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL,
-    0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL,
-    0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL,
-    0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL,
-    0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL,
-    0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL,
-    0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL,
-    0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL,
-    0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL,
-    0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL,
-    0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL,
-    0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL,
-    0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL,
-    0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL,
-    0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL,
-    0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL,
-    0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL,
-    0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL,
-    0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL,
-    0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL,
-    0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL,
-    0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL,
-    0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL,
-    0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL,
-    0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL,
-    0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL,
-    0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL,
-    0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL,
-    0x9324fd72UL
-  },
-  {
-    0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL,
-    0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL,
-    0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL,
-    0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL,
-    0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL,
-    0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL,
-    0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL,
-    0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL,
-    0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL,
-    0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL,
-    0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL,
-    0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL,
-    0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL,
-    0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL,
-    0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL,
-    0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL,
-    0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL,
-    0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL,
-    0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL,
-    0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL,
-    0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL,
-    0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL,
-    0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL,
-    0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL,
-    0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL,
-    0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL,
-    0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL,
-    0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL,
-    0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL,
-    0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL,
-    0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL,
-    0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL,
-    0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL,
-    0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL,
-    0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL,
-    0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL,
-    0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL,
-    0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL,
-    0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL,
-    0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL,
-    0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL,
-    0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL,
-    0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL,
-    0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL,
-    0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL,
-    0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL,
-    0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL,
-    0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL,
-    0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL,
-    0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL,
-    0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL,
-    0xbe9834edUL
-  },
-  {
-    0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL,
-    0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL,
-    0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL,
-    0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL,
-    0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL,
-    0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL,
-    0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL,
-    0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL,
-    0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL,
-    0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL,
-    0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL,
-    0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL,
-    0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL,
-    0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL,
-    0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL,
-    0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL,
-    0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL,
-    0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL,
-    0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL,
-    0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL,
-    0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL,
-    0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL,
-    0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL,
-    0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL,
-    0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL,
-    0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL,
-    0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL,
-    0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL,
-    0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL,
-    0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL,
-    0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL,
-    0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL,
-    0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL,
-    0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL,
-    0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL,
-    0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL,
-    0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL,
-    0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL,
-    0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL,
-    0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL,
-    0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL,
-    0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL,
-    0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL,
-    0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL,
-    0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL,
-    0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL,
-    0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL,
-    0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL,
-    0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL,
-    0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL,
-    0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL,
-    0xde0506f1UL
-  },
-  {
-    0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL,
-    0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL,
-    0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL,
-    0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL,
-    0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL,
-    0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL,
-    0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL,
-    0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL,
-    0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL,
-    0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL,
-    0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL,
-    0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL,
-    0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL,
-    0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL,
-    0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL,
-    0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL,
-    0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL,
-    0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL,
-    0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL,
-    0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL,
-    0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL,
-    0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL,
-    0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL,
-    0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL,
-    0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL,
-    0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL,
-    0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL,
-    0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL,
-    0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL,
-    0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL,
-    0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL,
-    0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL,
-    0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL,
-    0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL,
-    0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL,
-    0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL,
-    0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL,
-    0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL,
-    0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL,
-    0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL,
-    0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL,
-    0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL,
-    0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL,
-    0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL,
-    0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL,
-    0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL,
-    0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL,
-    0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL,
-    0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL,
-    0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL,
-    0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL,
-    0x8def022dUL
-  },
-  {
-    0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL,
-    0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL,
-    0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL,
-    0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL,
-    0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL,
-    0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL,
-    0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL,
-    0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL,
-    0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL,
-    0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL,
-    0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL,
-    0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL,
-    0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL,
-    0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL,
-    0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL,
-    0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL,
-    0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL,
-    0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL,
-    0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL,
-    0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL,
-    0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL,
-    0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL,
-    0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL,
-    0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL,
-    0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL,
-    0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL,
-    0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL,
-    0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL,
-    0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL,
-    0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL,
-    0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL,
-    0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL,
-    0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL,
-    0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL,
-    0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL,
-    0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL,
-    0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL,
-    0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL,
-    0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL,
-    0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL,
-    0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL,
-    0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL,
-    0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL,
-    0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL,
-    0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL,
-    0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL,
-    0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL,
-    0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL,
-    0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL,
-    0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL,
-    0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL,
-    0x72fd2493UL
-  },
-  {
-    0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL,
-    0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL,
-    0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL,
-    0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL,
-    0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL,
-    0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL,
-    0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL,
-    0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL,
-    0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL,
-    0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL,
-    0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL,
-    0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL,
-    0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL,
-    0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL,
-    0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL,
-    0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL,
-    0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL,
-    0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL,
-    0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL,
-    0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL,
-    0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL,
-    0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL,
-    0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL,
-    0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL,
-    0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL,
-    0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL,
-    0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL,
-    0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL,
-    0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL,
-    0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL,
-    0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL,
-    0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL,
-    0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL,
-    0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL,
-    0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL,
-    0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL,
-    0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL,
-    0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL,
-    0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL,
-    0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL,
-    0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL,
-    0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL,
-    0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL,
-    0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL,
-    0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL,
-    0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL,
-    0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL,
-    0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL,
-    0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL,
-    0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL,
-    0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL,
-    0xed3498beUL
-  },
-  {
-    0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL,
-    0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL,
-    0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL,
-    0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL,
-    0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL,
-    0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL,
-    0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL,
-    0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL,
-    0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL,
-    0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL,
-    0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL,
-    0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL,
-    0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL,
-    0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL,
-    0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL,
-    0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL,
-    0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL,
-    0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL,
-    0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL,
-    0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL,
-    0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL,
-    0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL,
-    0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL,
-    0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL,
-    0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL,
-    0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL,
-    0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL,
-    0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL,
-    0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL,
-    0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL,
-    0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL,
-    0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL,
-    0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL,
-    0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL,
-    0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL,
-    0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL,
-    0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL,
-    0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL,
-    0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL,
-    0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL,
-    0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL,
-    0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL,
-    0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL,
-    0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL,
-    0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL,
-    0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL,
-    0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL,
-    0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL,
-    0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL,
-    0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL,
-    0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL,
-    0xf10605deUL
-#endif
-  }
-};

3rdparty/zlib/cbits/deflate.h

@@ -1,346 +0,0 @@
-/* deflate.h -- internal compression state
- * Copyright (C) 1995-2012 Jean-loup Gailly
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* WARNING: this file should *not* be used by applications. It is
-   part of the implementation of the compression library and is
-   subject to change. Applications should only use zlib.h.
- */
-
-/* @(#) $Id$ */
-
-#ifndef DEFLATE_H
-#define DEFLATE_H
-
-#include "zutil.h"
-
-/* define NO_GZIP when compiling if you want to disable gzip header and
-   trailer creation by deflate().  NO_GZIP would be used to avoid linking in
-   the crc code when it is not needed.  For shared libraries, gzip encoding
-   should be left enabled. */
-#ifndef NO_GZIP
-#  define GZIP
-#endif
-
-/* ===========================================================================
- * Internal compression state.
- */
-
-#define LENGTH_CODES 29
-/* number of length codes, not counting the special END_BLOCK code */
-
-#define LITERALS  256
-/* number of literal bytes 0..255 */
-
-#define L_CODES (LITERALS+1+LENGTH_CODES)
-/* number of Literal or Length codes, including the END_BLOCK code */
-
-#define D_CODES   30
-/* number of distance codes */
-
-#define BL_CODES  19
-/* number of codes used to transfer the bit lengths */
-
-#define HEAP_SIZE (2*L_CODES+1)
-/* maximum heap size */
-
-#define MAX_BITS 15
-/* All codes must not exceed MAX_BITS bits */
-
-#define Buf_size 16
-/* size of bit buffer in bi_buf */
-
-#define INIT_STATE    42
-#define EXTRA_STATE   69
-#define NAME_STATE    73
-#define COMMENT_STATE 91
-#define HCRC_STATE   103
-#define BUSY_STATE   113
-#define FINISH_STATE 666
-/* Stream status */
-
-
-/* Data structure describing a single value and its code string. */
-typedef struct ct_data_s {
-    union {
-        ush  freq;       /* frequency count */
-        ush  code;       /* bit string */
-    } fc;
-    union {
-        ush  dad;        /* father node in Huffman tree */
-        ush  len;        /* length of bit string */
-    } dl;
-} FAR ct_data;
-
-#define Freq fc.freq
-#define Code fc.code
-#define Dad  dl.dad
-#define Len  dl.len
-
-typedef struct static_tree_desc_s  static_tree_desc;
-
-typedef struct tree_desc_s {
-    ct_data *dyn_tree;           /* the dynamic tree */
-    int     max_code;            /* largest code with non zero frequency */
-    static_tree_desc *stat_desc; /* the corresponding static tree */
-} FAR tree_desc;
-
-typedef ush Pos;
-typedef Pos FAR Posf;
-typedef unsigned IPos;
-
-/* A Pos is an index in the character window. We use short instead of int to
- * save space in the various tables. IPos is used only for parameter passing.
- */
-
-typedef struct internal_state {
-    z_streamp strm;      /* pointer back to this zlib stream */
-    int   status;        /* as the name implies */
-    Bytef *pending_buf;  /* output still pending */
-    ulg   pending_buf_size; /* size of pending_buf */
-    Bytef *pending_out;  /* next pending byte to output to the stream */
-    uInt   pending;      /* nb of bytes in the pending buffer */
-    int   wrap;          /* bit 0 true for zlib, bit 1 true for gzip */
-    gz_headerp  gzhead;  /* gzip header information to write */
-    uInt   gzindex;      /* where in extra, name, or comment */
-    Byte  method;        /* can only be DEFLATED */
-    int   last_flush;    /* value of flush param for previous deflate call */
-
-                /* used by deflate.c: */
-
-    uInt  w_size;        /* LZ77 window size (32K by default) */
-    uInt  w_bits;        /* log2(w_size)  (8..16) */
-    uInt  w_mask;        /* w_size - 1 */
-
-    Bytef *window;
-    /* Sliding window. Input bytes are read into the second half of the window,
-     * and move to the first half later to keep a dictionary of at least wSize
-     * bytes. With this organization, matches are limited to a distance of
-     * wSize-MAX_MATCH bytes, but this ensures that IO is always
-     * performed with a length multiple of the block size. Also, it limits
-     * the window size to 64K, which is quite useful on MSDOS.
-     * To do: use the user input buffer as sliding window.
-     */
-
-    ulg window_size;
-    /* Actual size of window: 2*wSize, except when the user input buffer
-     * is directly used as sliding window.
-     */
-
-    Posf *prev;
-    /* Link to older string with same hash index. To limit the size of this
-     * array to 64K, this link is maintained only for the last 32K strings.
-     * An index in this array is thus a window index modulo 32K.
-     */
-
-    Posf *head; /* Heads of the hash chains or NIL. */
-
-    uInt  ins_h;          /* hash index of string to be inserted */
-    uInt  hash_size;      /* number of elements in hash table */
-    uInt  hash_bits;      /* log2(hash_size) */
-    uInt  hash_mask;      /* hash_size-1 */
-
-    uInt  hash_shift;
-    /* Number of bits by which ins_h must be shifted at each input
-     * step. It must be such that after MIN_MATCH steps, the oldest
-     * byte no longer takes part in the hash key, that is:
-     *   hash_shift * MIN_MATCH >= hash_bits
-     */
-
-    long block_start;
-    /* Window position at the beginning of the current output block. Gets
-     * negative when the window is moved backwards.
-     */
-
-    uInt match_length;           /* length of best match */
-    IPos prev_match;             /* previous match */
-    int match_available;         /* set if previous match exists */
-    uInt strstart;               /* start of string to insert */
-    uInt match_start;            /* start of matching string */
-    uInt lookahead;              /* number of valid bytes ahead in window */
-
-    uInt prev_length;
-    /* Length of the best match at previous step. Matches not greater than this
-     * are discarded. This is used in the lazy match evaluation.
-     */
-
-    uInt max_chain_length;
-    /* To speed up deflation, hash chains are never searched beyond this
-     * length.  A higher limit improves compression ratio but degrades the
-     * speed.
-     */
-
-    uInt max_lazy_match;
-    /* Attempt to find a better match only when the current match is strictly
-     * smaller than this value. This mechanism is used only for compression
-     * levels >= 4.
-     */
-#   define max_insert_length  max_lazy_match
-    /* Insert new strings in the hash table only if the match length is not
-     * greater than this length. This saves time but degrades compression.
-     * max_insert_length is used only for compression levels <= 3.
-     */
-
-    int level;    /* compression level (1..9) */
-    int strategy; /* favor or force Huffman coding*/
-
-    uInt good_match;
-    /* Use a faster search when the previous match is longer than this */
-
-    int nice_match; /* Stop searching when current match exceeds this */
-
-                /* used by trees.c: */
-    /* Didn't use ct_data typedef below to suppress compiler warning */
-    struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */
-    struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
-    struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */
-
-    struct tree_desc_s l_desc;               /* desc. for literal tree */
-    struct tree_desc_s d_desc;               /* desc. for distance tree */
-    struct tree_desc_s bl_desc;              /* desc. for bit length tree */
-
-    ush bl_count[MAX_BITS+1];
-    /* number of codes at each bit length for an optimal tree */
-
-    int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */
-    int heap_len;               /* number of elements in the heap */
-    int heap_max;               /* element of largest frequency */
-    /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
-     * The same heap array is used to build all trees.
-     */
-
-    uch depth[2*L_CODES+1];
-    /* Depth of each subtree used as tie breaker for trees of equal frequency
-     */
-
-    uchf *l_buf;          /* buffer for literals or lengths */
-
-    uInt  lit_bufsize;
-    /* Size of match buffer for literals/lengths.  There are 4 reasons for
-     * limiting lit_bufsize to 64K:
-     *   - frequencies can be kept in 16 bit counters
-     *   - if compression is not successful for the first block, all input
-     *     data is still in the window so we can still emit a stored block even
-     *     when input comes from standard input.  (This can also be done for
-     *     all blocks if lit_bufsize is not greater than 32K.)
-     *   - if compression is not successful for a file smaller than 64K, we can
-     *     even emit a stored file instead of a stored block (saving 5 bytes).
-     *     This is applicable only for zip (not gzip or zlib).
-     *   - creating new Huffman trees less frequently may not provide fast
-     *     adaptation to changes in the input data statistics. (Take for
-     *     example a binary file with poorly compressible code followed by
-     *     a highly compressible string table.) Smaller buffer sizes give
-     *     fast adaptation but have of course the overhead of transmitting
-     *     trees more frequently.
-     *   - I can't count above 4
-     */
-
-    uInt last_lit;      /* running index in l_buf */
-
-    ushf *d_buf;
-    /* Buffer for distances. To simplify the code, d_buf and l_buf have
-     * the same number of elements. To use different lengths, an extra flag
-     * array would be necessary.
-     */
-
-    ulg opt_len;        /* bit length of current block with optimal trees */
-    ulg static_len;     /* bit length of current block with static trees */
-    uInt matches;       /* number of string matches in current block */
-    uInt insert;        /* bytes at end of window left to insert */
-
-#ifdef DEBUG
-    ulg compressed_len; /* total bit length of compressed file mod 2^32 */
-    ulg bits_sent;      /* bit length of compressed data sent mod 2^32 */
-#endif
-
-    ush bi_buf;
-    /* Output buffer. bits are inserted starting at the bottom (least
-     * significant bits).
-     */
-    int bi_valid;
-    /* Number of valid bits in bi_buf.  All bits above the last valid bit
-     * are always zero.
-     */
-
-    ulg high_water;
-    /* High water mark offset in window for initialized bytes -- bytes above
-     * this are set to zero in order to avoid memory check warnings when
-     * longest match routines access bytes past the input.  This is then
-     * updated to the new high water mark.
-     */
-
-} FAR deflate_state;
-
-/* Output a byte on the stream.
- * IN assertion: there is enough room in pending_buf.
- */
-#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);}
-
-
-#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
-/* Minimum amount of lookahead, except at the end of the input file.
- * See deflate.c for comments about the MIN_MATCH+1.
- */
-
-#define MAX_DIST(s)  ((s)->w_size-MIN_LOOKAHEAD)
-/* In order to simplify the code, particularly on 16 bit machines, match
- * distances are limited to MAX_DIST instead of WSIZE.
- */
-
-#define WIN_INIT MAX_MATCH
-/* Number of bytes after end of data in window to initialize in order to avoid
-   memory checker errors from longest match routines */
-
-        /* in trees.c */
-void ZLIB_INTERNAL _tr_init OF((deflate_state *s));
-int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
-void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf,
-                        ulg stored_len, int last));
-void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s));
-void ZLIB_INTERNAL _tr_align OF((deflate_state *s));
-void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
-                        ulg stored_len, int last));
-
-#define d_code(dist) \
-   ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
-/* Mapping from a distance to a distance code. dist is the distance - 1 and
- * must not have side effects. _dist_code[256] and _dist_code[257] are never
- * used.
- */
-
-#ifndef DEBUG
-/* Inline versions of _tr_tally for speed: */
-
-#if defined(GEN_TREES_H) || !defined(STDC)
-  extern uch ZLIB_INTERNAL _length_code[];
-  extern uch ZLIB_INTERNAL _dist_code[];
-#else
-  extern const uch ZLIB_INTERNAL _length_code[];
-  extern const uch ZLIB_INTERNAL _dist_code[];
-#endif
-
-# define _tr_tally_lit(s, c, flush) \
-  { uch cc = (c); \
-    s->d_buf[s->last_lit] = 0; \
-    s->l_buf[s->last_lit++] = cc; \
-    s->dyn_ltree[cc].Freq++; \
-    flush = (s->last_lit == s->lit_bufsize-1); \
-   }
-# define _tr_tally_dist(s, distance, length, flush) \
-  { uch len = (length); \
-    ush dist = (distance); \
-    s->d_buf[s->last_lit] = dist; \
-    s->l_buf[s->last_lit++] = len; \
-    dist--; \
-    s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
-    s->dyn_dtree[d_code(dist)].Freq++; \
-    flush = (s->last_lit == s->lit_bufsize-1); \
-  }
-#else
-# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
-# define _tr_tally_dist(s, distance, length, flush) \
-              flush = _tr_tally(s, distance, length)
-#endif
-
-#endif /* DEFLATE_H */

3rdparty/zlib/cbits/gzguts.h

@@ -1,209 +0,0 @@
-/* gzguts.h -- zlib internal header definitions for gz* operations
- * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#ifdef _LARGEFILE64_SOURCE
-#  ifndef _LARGEFILE_SOURCE
-#    define _LARGEFILE_SOURCE 1
-#  endif
-#  ifdef _FILE_OFFSET_BITS
-#    undef _FILE_OFFSET_BITS
-#  endif
-#endif
-
-#ifdef HAVE_HIDDEN
-#  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
-#else
-#  define ZLIB_INTERNAL
-#endif
-
-#include <stdio.h>
-#include "zlib.h"
-#ifdef STDC
-#  include <string.h>
-#  include <stdlib.h>
-#  include <limits.h>
-#endif
-#include <fcntl.h>
-
-#ifdef _WIN32
-#  include <stddef.h>
-#endif
-
-#if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32)
-#  include <io.h>
-#endif
-
-#ifdef WINAPI_FAMILY
-#  define open _open
-#  define read _read
-#  define write _write
-#  define close _close
-#endif
-
-#ifdef NO_DEFLATE       /* for compatibility with old definition */
-#  define NO_GZCOMPRESS
-#endif
-
-#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550)
-#  ifndef HAVE_VSNPRINTF
-#    define HAVE_VSNPRINTF
-#  endif
-#endif
-
-#if defined(__CYGWIN__)
-#  ifndef HAVE_VSNPRINTF
-#    define HAVE_VSNPRINTF
-#  endif
-#endif
-
-#if defined(MSDOS) && defined(__BORLANDC__) && (BORLANDC > 0x410)
-#  ifndef HAVE_VSNPRINTF
-#    define HAVE_VSNPRINTF
-#  endif
-#endif
-
-#ifndef HAVE_VSNPRINTF
-#  ifdef MSDOS
-/* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
-   but for now we just assume it doesn't. */
-#    define NO_vsnprintf
-#  endif
-#  ifdef __TURBOC__
-#    define NO_vsnprintf
-#  endif
-#  ifdef WIN32
-/* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
-#    if !defined(vsnprintf) && !defined(NO_vsnprintf)
-#      if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 )
-#         define vsnprintf _vsnprintf
-#      endif
-#    endif
-#  endif
-#  ifdef __SASC
-#    define NO_vsnprintf
-#  endif
-#  ifdef VMS
-#    define NO_vsnprintf
-#  endif
-#  ifdef __OS400__
-#    define NO_vsnprintf
-#  endif
-#  ifdef __MVS__
-#    define NO_vsnprintf
-#  endif
-#endif
-
-/* unlike snprintf (which is required in C99, yet still not supported by
-   Microsoft more than a decade later!), _snprintf does not guarantee null
-   termination of the result -- however this is only used in gzlib.c where
-   the result is assured to fit in the space provided */
-#ifdef _MSC_VER
-#  define snprintf _snprintf
-#endif
-
-#ifndef local
-#  define local static
-#endif
-/* compile with -Dlocal if your debugger can't find static symbols */
-
-/* gz* functions always use library allocation functions */
-#ifndef STDC
-  extern voidp  malloc OF((uInt size));
-  extern void   free   OF((voidpf ptr));
-#endif
-
-/* get errno and strerror definition */
-#if defined UNDER_CE
-#  include <windows.h>
-#  define zstrerror() gz_strwinerror((DWORD)GetLastError())
-#else
-#  ifndef NO_STRERROR
-#    include <errno.h>
-#    define zstrerror() strerror(errno)
-#  else
-#    define zstrerror() "stdio error (consult errno)"
-#  endif
-#endif
-
-/* provide prototypes for these when building zlib without LFS */
-#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0
-    ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
-    ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
-    ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
-    ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
-#endif
-
-/* default memLevel */
-#if MAX_MEM_LEVEL >= 8
-#  define DEF_MEM_LEVEL 8
-#else
-#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
-#endif
-
-/* default i/o buffer size -- double this for output when reading (this and
-   twice this must be able to fit in an unsigned type) */
-#define GZBUFSIZE 8192
-
-/* gzip modes, also provide a little integrity check on the passed structure */
-#define GZ_NONE 0
-#define GZ_READ 7247
-#define GZ_WRITE 31153
-#define GZ_APPEND 1     /* mode set to GZ_WRITE after the file is opened */
-
-/* values for gz_state how */
-#define LOOK 0      /* look for a gzip header */
-#define COPY 1      /* copy input directly */
-#define GZIP 2      /* decompress a gzip stream */
-
-/* internal gzip file state data structure */
-typedef struct {
-        /* exposed contents for gzgetc() macro */
-    struct gzFile_s x;      /* "x" for exposed */
-                            /* x.have: number of bytes available at x.next */
-                            /* x.next: next output data to deliver or write */
-                            /* x.pos: current position in uncompressed data */
-        /* used for both reading and writing */
-    int mode;               /* see gzip modes above */
-    int fd;                 /* file descriptor */
-    char *path;             /* path or fd for error messages */
-    unsigned size;          /* buffer size, zero if not allocated yet */
-    unsigned want;          /* requested buffer size, default is GZBUFSIZE */
-    unsigned char *in;      /* input buffer */
-    unsigned char *out;     /* output buffer (double-sized when reading) */
-    int direct;             /* 0 if processing gzip, 1 if transparent */
-        /* just for reading */
-    int how;                /* 0: get header, 1: copy, 2: decompress */
-    z_off64_t start;        /* where the gzip data started, for rewinding */
-    int eof;                /* true if end of input file reached */
-    int past;               /* true if read requested past end */
-        /* just for writing */
-    int level;              /* compression level */
-    int strategy;           /* compression strategy */
-        /* seek request */
-    z_off64_t skip;         /* amount to skip (already rewound if backwards) */
-    int seek;               /* true if seek request pending */
-        /* error information */
-    int err;                /* error code */
-    char *msg;              /* error message */
-        /* zlib inflate or deflate stream */
-    z_stream strm;          /* stream structure in-place (not a pointer) */
-} gz_state;
-typedef gz_state FAR *gz_statep;
-
-/* shared functions */
-void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *));
-#if defined UNDER_CE
-char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error));
-#endif
-
-/* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t
-   value -- needed when comparing unsigned to z_off64_t, which is signed
-   (possible z_off64_t types off_t, off64_t, and long are all signed) */
-#ifdef INT_MAX
-#  define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX)
-#else
-unsigned ZLIB_INTERNAL gz_intmax OF((void));
-#  define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax())
-#endif

3rdparty/zlib/cbits/infback.c

@@ -1,640 +0,0 @@
-/* infback.c -- inflate using a call-back interface
- * Copyright (C) 1995-2011 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/*
-   This code is largely copied from inflate.c.  Normally either infback.o or
-   inflate.o would be linked into an application--not both.  The interface
-   with inffast.c is retained so that optimized assembler-coded versions of
-   inflate_fast() can be used with either inflate.c or infback.c.
- */
-
-#include "zutil.h"
-#include "inftrees.h"
-#include "inflate.h"
-#include "inffast.h"
-
-/* function prototypes */
-local void fixedtables OF((struct inflate_state FAR *state));
-
-/*
-   strm provides memory allocation functions in zalloc and zfree, or
-   Z_NULL to use the library memory allocation functions.
-
-   windowBits is in the range 8..15, and window is a user-supplied
-   window and output buffer that is 2**windowBits bytes.
- */
-int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
-z_streamp strm;
-int windowBits;
-unsigned char FAR *window;
-const char *version;
-int stream_size;
-{
-    struct inflate_state FAR *state;
-
-    if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
-        stream_size != (int)(sizeof(z_stream)))
-        return Z_VERSION_ERROR;
-    if (strm == Z_NULL || window == Z_NULL ||
-        windowBits < 8 || windowBits > 15)
-        return Z_STREAM_ERROR;
-    strm->msg = Z_NULL;                 /* in case we return an error */
-    if (strm->zalloc == (alloc_func)0) {
-#ifdef Z_SOLO
-        return Z_STREAM_ERROR;
-#else
-        strm->zalloc = zcalloc;
-        strm->opaque = (voidpf)0;
-#endif
-    }
-    if (strm->zfree == (free_func)0)
-#ifdef Z_SOLO
-        return Z_STREAM_ERROR;
-#else
-    strm->zfree = zcfree;
-#endif
-    state = (struct inflate_state FAR *)ZALLOC(strm, 1,
-                                               sizeof(struct inflate_state));
-    if (state == Z_NULL) return Z_MEM_ERROR;
-    Tracev((stderr, "inflate: allocated\n"));
-    strm->state = (struct internal_state FAR *)state;
-    state->dmax = 32768U;
-    state->wbits = windowBits;
-    state->wsize = 1U << windowBits;
-    state->window = window;
-    state->wnext = 0;
-    state->whave = 0;
-    return Z_OK;
-}
-
-/*
-   Return state with length and distance decoding tables and index sizes set to
-   fixed code decoding.  Normally this returns fixed tables from inffixed.h.
-   If BUILDFIXED is defined, then instead this routine builds the tables the
-   first time it's called, and returns those tables the first time and
-   thereafter.  This reduces the size of the code by about 2K bytes, in
-   exchange for a little execution time.  However, BUILDFIXED should not be
-   used for threaded applications, since the rewriting of the tables and virgin
-   may not be thread-safe.
- */
-local void fixedtables(state)
-struct inflate_state FAR *state;
-{
-#ifdef BUILDFIXED
-    static int virgin = 1;
-    static code *lenfix, *distfix;
-    static code fixed[544];
-
-    /* build fixed huffman tables if first call (may not be thread safe) */
-    if (virgin) {
-        unsigned sym, bits;
-        static code *next;
-
-        /* literal/length table */
-        sym = 0;
-        while (sym < 144) state->lens[sym++] = 8;
-        while (sym < 256) state->lens[sym++] = 9;
-        while (sym < 280) state->lens[sym++] = 7;
-        while (sym < 288) state->lens[sym++] = 8;
-        next = fixed;
-        lenfix = next;
-        bits = 9;
-        inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
-
-        /* distance table */
-        sym = 0;
-        while (sym < 32) state->lens[sym++] = 5;
-        distfix = next;
-        bits = 5;
-        inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
-
-        /* do this just once */
-        virgin = 0;
-    }
-#else /* !BUILDFIXED */
-#   include "inffixed.h"
-#endif /* BUILDFIXED */
-    state->lencode = lenfix;
-    state->lenbits = 9;
-    state->distcode = distfix;
-    state->distbits = 5;
-}
-
-/* Macros for inflateBack(): */
-
-/* Load returned state from inflate_fast() */
-#define LOAD() \
-    do { \
-        put = strm->next_out; \
-        left = strm->avail_out; \
-        next = strm->next_in; \
-        have = strm->avail_in; \
-        hold = state->hold; \
-        bits = state->bits; \
-    } while (0)
-
-/* Set state from registers for inflate_fast() */
-#define RESTORE() \
-    do { \
-        strm->next_out = put; \
-        strm->avail_out = left; \
-        strm->next_in = next; \
-        strm->avail_in = have; \
-        state->hold = hold; \
-        state->bits = bits; \
-    } while (0)
-
-/* Clear the input bit accumulator */
-#define INITBITS() \
-    do { \
-        hold = 0; \
-        bits = 0; \
-    } while (0)
-
-/* Assure that some input is available.  If input is requested, but denied,
-   then return a Z_BUF_ERROR from inflateBack(). */
-#define PULL() \
-    do { \
-        if (have == 0) { \
-            have = in(in_desc, &next); \
-            if (have == 0) { \
-                next = Z_NULL; \
-                ret = Z_BUF_ERROR; \
-                goto inf_leave; \
-            } \
-        } \
-    } while (0)
-
-/* Get a byte of input into the bit accumulator, or return from inflateBack()
-   with an error if there is no input available. */
-#define PULLBYTE() \
-    do { \
-        PULL(); \
-        have--; \
-        hold += (unsigned long)(*next++) << bits; \
-        bits += 8; \
-    } while (0)
-
-/* Assure that there are at least n bits in the bit accumulator.  If there is
-   not enough available input to do that, then return from inflateBack() with
-   an error. */
-#define NEEDBITS(n) \
-    do { \
-        while (bits < (unsigned)(n)) \
-            PULLBYTE(); \
-    } while (0)
-
-/* Return the low n bits of the bit accumulator (n < 16) */
-#define BITS(n) \
-    ((unsigned)hold & ((1U << (n)) - 1))
-
-/* Remove n bits from the bit accumulator */
-#define DROPBITS(n) \
-    do { \
-        hold >>= (n); \
-        bits -= (unsigned)(n); \
-    } while (0)
-
-/* Remove zero to seven bits as needed to go to a byte boundary */
-#define BYTEBITS() \
-    do { \
-        hold >>= bits & 7; \
-        bits -= bits & 7; \
-    } while (0)
-
-/* Assure that some output space is available, by writing out the window
-   if it's full.  If the write fails, return from inflateBack() with a
-   Z_BUF_ERROR. */
-#define ROOM() \
-    do { \
-        if (left == 0) { \
-            put = state->window; \
-            left = state->wsize; \
-            state->whave = left; \
-            if (out(out_desc, put, left)) { \
-                ret = Z_BUF_ERROR; \
-                goto inf_leave; \
-            } \
-        } \
-    } while (0)
-
-/*
-   strm provides the memory allocation functions and window buffer on input,
-   and provides information on the unused input on return.  For Z_DATA_ERROR
-   returns, strm will also provide an error message.
-
-   in() and out() are the call-back input and output functions.  When
-   inflateBack() needs more input, it calls in().  When inflateBack() has
-   filled the window with output, or when it completes with data in the
-   window, it calls out() to write out the data.  The application must not
-   change the provided input until in() is called again or inflateBack()
-   returns.  The application must not change the window/output buffer until
-   inflateBack() returns.
-
-   in() and out() are called with a descriptor parameter provided in the
-   inflateBack() call.  This parameter can be a structure that provides the
-   information required to do the read or write, as well as accumulated
-   information on the input and output such as totals and check values.
-
-   in() should return zero on failure.  out() should return non-zero on
-   failure.  If either in() or out() fails, than inflateBack() returns a
-   Z_BUF_ERROR.  strm->next_in can be checked for Z_NULL to see whether it
-   was in() or out() that caused in the error.  Otherwise,  inflateBack()
-   returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
-   error, or Z_MEM_ERROR if it could not allocate memory for the state.
-   inflateBack() can also return Z_STREAM_ERROR if the input parameters
-   are not correct, i.e. strm is Z_NULL or the state was not initialized.
- */
-int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
-z_streamp strm;
-in_func in;
-void FAR *in_desc;
-out_func out;
-void FAR *out_desc;
-{
-    struct inflate_state FAR *state;
-    z_const unsigned char FAR *next;    /* next input */
-    unsigned char FAR *put;     /* next output */
-    unsigned have, left;        /* available input and output */
-    unsigned long hold;         /* bit buffer */
-    unsigned bits;              /* bits in bit buffer */
-    unsigned copy;              /* number of stored or match bytes to copy */
-    unsigned char FAR *from;    /* where to copy match bytes from */
-    code here;                  /* current decoding table entry */
-    code last;                  /* parent table entry */
-    unsigned len;               /* length to copy for repeats, bits to drop */
-    int ret;                    /* return code */
-    static const unsigned short order[19] = /* permutation of code lengths */
-        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
-
-    /* Check that the strm exists and that the state was initialized */
-    if (strm == Z_NULL || strm->state == Z_NULL)
-        return Z_STREAM_ERROR;
-    state = (struct inflate_state FAR *)strm->state;
-
-    /* Reset the state */
-    strm->msg = Z_NULL;
-    state->mode = TYPE;
-    state->last = 0;
-    state->whave = 0;
-    next = strm->next_in;
-    have = next != Z_NULL ? strm->avail_in : 0;
-    hold = 0;
-    bits = 0;
-    put = state->window;
-    left = state->wsize;
-
-    /* Inflate until end of block marked as last */
-    for (;;)
-        switch (state->mode) {
-        case TYPE:
-            /* determine and dispatch block type */
-            if (state->last) {
-                BYTEBITS();
-                state->mode = DONE;
-                break;
-            }
-            NEEDBITS(3);
-            state->last = BITS(1);
-            DROPBITS(1);
-            switch (BITS(2)) {
-            case 0:                             /* stored block */
-                Tracev((stderr, "inflate:     stored block%s\n",
-                        state->last ? " (last)" : ""));
-                state->mode = STORED;
-                break;
-            case 1:                             /* fixed block */
-                fixedtables(state);
-                Tracev((stderr, "inflate:     fixed codes block%s\n",
-                        state->last ? " (last)" : ""));
-                state->mode = LEN;              /* decode codes */
-                break;
-            case 2:                             /* dynamic block */
-                Tracev((stderr, "inflate:     dynamic codes block%s\n",
-                        state->last ? " (last)" : ""));
-                state->mode = TABLE;
-                break;
-            case 3:
-                strm->msg = (char *)"invalid block type";
-                state->mode = BAD;
-            }
-            DROPBITS(2);
-            break;
-
-        case STORED:
-            /* get and verify stored block length */
-            BYTEBITS();                         /* go to byte boundary */
-            NEEDBITS(32);
-            if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
-                strm->msg = (char *)"invalid stored block lengths";
-                state->mode = BAD;
-                break;
-            }
-            state->length = (unsigned)hold & 0xffff;
-            Tracev((stderr, "inflate:       stored length %u\n",
-                    state->length));
-            INITBITS();
-
-            /* copy stored block from input to output */
-            while (state->length != 0) {
-                copy = state->length;
-                PULL();
-                ROOM();
-                if (copy > have) copy = have;
-                if (copy > left) copy = left;
-                zmemcpy(put, next, copy);
-                have -= copy;
-                next += copy;
-                left -= copy;
-                put += copy;
-                state->length -= copy;
-            }
-            Tracev((stderr, "inflate:       stored end\n"));
-            state->mode = TYPE;
-            break;
-
-        case TABLE:
-            /* get dynamic table entries descriptor */
-            NEEDBITS(14);
-            state->nlen = BITS(5) + 257;
-            DROPBITS(5);
-            state->ndist = BITS(5) + 1;
-            DROPBITS(5);
-            state->ncode = BITS(4) + 4;
-            DROPBITS(4);
-#ifndef PKZIP_BUG_WORKAROUND
-            if (state->nlen > 286 || state->ndist > 30) {
-                strm->msg = (char *)"too many length or distance symbols";
-                state->mode = BAD;
-                break;
-            }
-#endif
-            Tracev((stderr, "inflate:       table sizes ok\n"));
-
-            /* get code length code lengths (not a typo) */
-            state->have = 0;
-            while (state->have < state->ncode) {
-                NEEDBITS(3);
-                state->lens[order[state->have++]] = (unsigned short)BITS(3);
-                DROPBITS(3);
-            }
-            while (state->have < 19)
-                state->lens[order[state->have++]] = 0;
-            state->next = state->codes;
-            state->lencode = (code const FAR *)(state->next);
-            state->lenbits = 7;
-            ret = inflate_table(CODES, state->lens, 19, &(state->next),
-                                &(state->lenbits), state->work);
-            if (ret) {
-                strm->msg = (char *)"invalid code lengths set";
-                state->mode = BAD;
-                break;
-            }
-            Tracev((stderr, "inflate:       code lengths ok\n"));
-
-            /* get length and distance code code lengths */
-            state->have = 0;
-            while (state->have < state->nlen + state->ndist) {
-                for (;;) {
-                    here = state->lencode[BITS(state->lenbits)];
-                    if ((unsigned)(here.bits) <= bits) break;
-                    PULLBYTE();
-                }
-                if (here.val < 16) {
-                    DROPBITS(here.bits);
-                    state->lens[state->have++] = here.val;
-                }
-                else {
-                    if (here.val == 16) {
-                        NEEDBITS(here.bits + 2);
-                        DROPBITS(here.bits);
-                        if (state->have == 0) {
-                            strm->msg = (char *)"invalid bit length repeat";
-                            state->mode = BAD;
-                            break;
-                        }
-                        len = (unsigned)(state->lens[state->have - 1]);
-                        copy = 3 + BITS(2);
-                        DROPBITS(2);
-                    }
-                    else if (here.val == 17) {
-                        NEEDBITS(here.bits + 3);
-                        DROPBITS(here.bits);
-                        len = 0;
-                        copy = 3 + BITS(3);
-                        DROPBITS(3);
-                    }
-                    else {
-                        NEEDBITS(here.bits + 7);
-                        DROPBITS(here.bits);
-                        len = 0;
-                        copy = 11 + BITS(7);
-                        DROPBITS(7);
-                    }
-                    if (state->have + copy > state->nlen + state->ndist) {
-                        strm->msg = (char *)"invalid bit length repeat";
-                        state->mode = BAD;
-                        break;
-                    }
-                    while (copy--)
-                        state->lens[state->have++] = (unsigned short)len;
-                }
-            }
-
-            /* handle error breaks in while */
-            if (state->mode == BAD) break;
-
-            /* check for end-of-block code (better have one) */
-            if (state->lens[256] == 0) {
-                strm->msg = (char *)"invalid code -- missing end-of-block";
-                state->mode = BAD;
-                break;
-            }
-
-            /* build code tables -- note: do not change the lenbits or distbits
-               values here (9 and 6) without reading the comments in inftrees.h
-               concerning the ENOUGH constants, which depend on those values */
-            state->next = state->codes;
-            state->lencode = (code const FAR *)(state->next);
-            state->lenbits = 9;
-            ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
-                                &(state->lenbits), state->work);
-            if (ret) {
-                strm->msg = (char *)"invalid literal/lengths set";
-                state->mode = BAD;
-                break;
-            }
-            state->distcode = (code const FAR *)(state->next);
-            state->distbits = 6;
-            ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
-                            &(state->next), &(state->distbits), state->work);
-            if (ret) {
-                strm->msg = (char *)"invalid distances set";
-                state->mode = BAD;
-                break;
-            }
-            Tracev((stderr, "inflate:       codes ok\n"));
-            state->mode = LEN;
-
-        case LEN:
-            /* use inflate_fast() if we have enough input and output */
-            if (have >= 6 && left >= 258) {
-                RESTORE();
-                if (state->whave < state->wsize)
-                    state->whave = state->wsize - left;
-                inflate_fast(strm, state->wsize);
-                LOAD();
-                break;
-            }
-
-            /* get a literal, length, or end-of-block code */
-            for (;;) {
-                here = state->lencode[BITS(state->lenbits)];
-                if ((unsigned)(here.bits) <= bits) break;
-                PULLBYTE();
-            }
-            if (here.op && (here.op & 0xf0) == 0) {
-                last = here;
-                for (;;) {
-                    here = state->lencode[last.val +
-                            (BITS(last.bits + last.op) >> last.bits)];
-                    if ((unsigned)(last.bits + here.bits) <= bits) break;
-                    PULLBYTE();
-                }
-                DROPBITS(last.bits);
-            }
-            DROPBITS(here.bits);
-            state->length = (unsigned)here.val;
-
-            /* process literal */
-            if (here.op == 0) {
-                Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
-                        "inflate:         literal '%c'\n" :
-                        "inflate:         literal 0x%02x\n", here.val));
-                ROOM();
-                *put++ = (unsigned char)(state->length);
-                left--;
-                state->mode = LEN;
-                break;
-            }
-
-            /* process end of block */
-            if (here.op & 32) {
-                Tracevv((stderr, "inflate:         end of block\n"));
-                state->mode = TYPE;
-                break;
-            }
-
-            /* invalid code */
-            if (here.op & 64) {
-                strm->msg = (char *)"invalid literal/length code";
-                state->mode = BAD;
-                break;
-            }
-
-            /* length code -- get extra bits, if any */
-            state->extra = (unsigned)(here.op) & 15;
-            if (state->extra != 0) {
-                NEEDBITS(state->extra);
-                state->length += BITS(state->extra);
-                DROPBITS(state->extra);
-            }
-            Tracevv((stderr, "inflate:         length %u\n", state->length));
-
-            /* get distance code */
-            for (;;) {
-                here = state->distcode[BITS(state->distbits)];
-                if ((unsigned)(here.bits) <= bits) break;
-                PULLBYTE();
-            }
-            if ((here.op & 0xf0) == 0) {
-                last = here;
-                for (;;) {
-                    here = state->distcode[last.val +
-                            (BITS(last.bits + last.op) >> last.bits)];
-                    if ((unsigned)(last.bits + here.bits) <= bits) break;
-                    PULLBYTE();
-                }
-                DROPBITS(last.bits);
-            }
-            DROPBITS(here.bits);
-            if (here.op & 64) {
-                strm->msg = (char *)"invalid distance code";
-                state->mode = BAD;
-                break;
-            }
-            state->offset = (unsigned)here.val;
-
-            /* get distance extra bits, if any */
-            state->extra = (unsigned)(here.op) & 15;
-            if (state->extra != 0) {
-                NEEDBITS(state->extra);
-                state->offset += BITS(state->extra);
-                DROPBITS(state->extra);
-            }
-            if (state->offset > state->wsize - (state->whave < state->wsize ?
-                                                left : 0)) {
-                strm->msg = (char *)"invalid distance too far back";
-                state->mode = BAD;
-                break;
-            }
-            Tracevv((stderr, "inflate:         distance %u\n", state->offset));
-
-            /* copy match from window to output */
-            do {
-                ROOM();
-                copy = state->wsize - state->offset;
-                if (copy < left) {
-                    from = put + copy;
-                    copy = left - copy;
-                }
-                else {
-                    from = put - state->offset;
-                    copy = left;
-                }
-                if (copy > state->length) copy = state->length;
-                state->length -= copy;
-                left -= copy;
-                do {
-                    *put++ = *from++;
-                } while (--copy);
-            } while (state->length != 0);
-            break;
-
-        case DONE:
-            /* inflate stream terminated properly -- write leftover output */
-            ret = Z_STREAM_END;
-            if (left < state->wsize) {
-                if (out(out_desc, state->window, state->wsize - left))
-                    ret = Z_BUF_ERROR;
-            }
-            goto inf_leave;
-
-        case BAD:
-            ret = Z_DATA_ERROR;
-            goto inf_leave;
-
-        default:                /* can't happen, but makes compilers happy */
-            ret = Z_STREAM_ERROR;
-            goto inf_leave;
-        }
-
-    /* Return unused input */
-  inf_leave:
-    strm->next_in = next;
-    strm->avail_in = have;
-    return ret;
-}
-
-int ZEXPORT inflateBackEnd(strm)
-z_streamp strm;
-{
-    if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
-        return Z_STREAM_ERROR;
-    ZFREE(strm, strm->state);
-    strm->state = Z_NULL;
-    Tracev((stderr, "inflate: end\n"));
-    return Z_OK;
-}

3rdparty/zlib/cbits/inffast.c

@@ -1,340 +0,0 @@
-/* inffast.c -- fast decoding
- * Copyright (C) 1995-2008, 2010, 2013 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include "zutil.h"
-#include "inftrees.h"
-#include "inflate.h"
-#include "inffast.h"
-
-#ifndef ASMINF
-
-/* Allow machine dependent optimization for post-increment or pre-increment.
-   Based on testing to date,
-   Pre-increment preferred for:
-   - PowerPC G3 (Adler)
-   - MIPS R5000 (Randers-Pehrson)
-   Post-increment preferred for:
-   - none
-   No measurable difference:
-   - Pentium III (Anderson)
-   - M68060 (Nikl)
- */
-#ifdef POSTINC
-#  define OFF 0
-#  define PUP(a) *(a)++
-#else
-#  define OFF 1
-#  define PUP(a) *++(a)
-#endif
-
-/*
-   Decode literal, length, and distance codes and write out the resulting
-   literal and match bytes until either not enough input or output is
-   available, an end-of-block is encountered, or a data error is encountered.
-   When large enough input and output buffers are supplied to inflate(), for
-   example, a 16K input buffer and a 64K output buffer, more than 95% of the
-   inflate execution time is spent in this routine.
-
-   Entry assumptions:
-
-        state->mode == LEN
-        strm->avail_in >= 6
-        strm->avail_out >= 258
-        start >= strm->avail_out
-        state->bits < 8
-
-   On return, state->mode is one of:
-
-        LEN -- ran out of enough output space or enough available input
-        TYPE -- reached end of block code, inflate() to interpret next block
-        BAD -- error in block data
-
-   Notes:
-
-    - The maximum input bits used by a length/distance pair is 15 bits for the
-      length code, 5 bits for the length extra, 15 bits for the distance code,
-      and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
-      Therefore if strm->avail_in >= 6, then there is enough input to avoid
-      checking for available input while decoding.
-
-    - The maximum bytes that a single length/distance pair can output is 258
-      bytes, which is the maximum length that can be coded.  inflate_fast()
-      requires strm->avail_out >= 258 for each loop to avoid checking for
-      output space.
- */
-void ZLIB_INTERNAL inflate_fast(strm, start)
-z_streamp strm;
-unsigned start;         /* inflate()'s starting value for strm->avail_out */
-{
-    struct inflate_state FAR *state;
-    z_const unsigned char FAR *in;      /* local strm->next_in */
-    z_const unsigned char FAR *last;    /* have enough input while in < last */
-    unsigned char FAR *out;     /* local strm->next_out */
-    unsigned char FAR *beg;     /* inflate()'s initial strm->next_out */
-    unsigned char FAR *end;     /* while out < end, enough space available */
-#ifdef INFLATE_STRICT
-    unsigned dmax;              /* maximum distance from zlib header */
-#endif
-    unsigned wsize;             /* window size or zero if not using window */
-    unsigned whave;             /* valid bytes in the window */
-    unsigned wnext;             /* window write index */
-    unsigned char FAR *window;  /* allocated sliding window, if wsize != 0 */
-    unsigned long hold;         /* local strm->hold */
-    unsigned bits;              /* local strm->bits */
-    code const FAR *lcode;      /* local strm->lencode */
-    code const FAR *dcode;      /* local strm->distcode */
-    unsigned lmask;             /* mask for first level of length codes */
-    unsigned dmask;             /* mask for first level of distance codes */
-    code here;                  /* retrieved table entry */
-    unsigned op;                /* code bits, operation, extra bits, or */
-                                /*  window position, window bytes to copy */
-    unsigned len;               /* match length, unused bytes */
-    unsigned dist;              /* match distance */
-    unsigned char FAR *from;    /* where to copy match from */
-
-    /* copy state to local variables */
-    state = (struct inflate_state FAR *)strm->state;
-    in = strm->next_in - OFF;
-    last = in + (strm->avail_in - 5);
-    out = strm->next_out - OFF;
-    beg = out - (start - strm->avail_out);
-    end = out + (strm->avail_out - 257);
-#ifdef INFLATE_STRICT
-    dmax = state->dmax;
-#endif
-    wsize = state->wsize;
-    whave = state->whave;
-    wnext = state->wnext;
-    window = state->window;
-    hold = state->hold;
-    bits = state->bits;
-    lcode = state->lencode;
-    dcode = state->distcode;
-    lmask = (1U << state->lenbits) - 1;
-    dmask = (1U << state->distbits) - 1;
-
-    /* decode literals and length/distances until end-of-block or not enough
-       input data or output space */
-    do {
-        if (bits < 15) {
-            hold += (unsigned long)(PUP(in)) << bits;
-            bits += 8;
-            hold += (unsigned long)(PUP(in)) << bits;
-            bits += 8;
-        }
-        here = lcode[hold & lmask];
-      dolen:
-        op = (unsigned)(here.bits);
-        hold >>= op;
-        bits -= op;
-        op = (unsigned)(here.op);
-        if (op == 0) {                          /* literal */
-            Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
-                    "inflate:         literal '%c'\n" :
-                    "inflate:         literal 0x%02x\n", here.val));
-            PUP(out) = (unsigned char)(here.val);
-        }
-        else if (op & 16) {                     /* length base */
-            len = (unsigned)(here.val);
-            op &= 15;                           /* number of extra bits */
-            if (op) {
-                if (bits < op) {
-                    hold += (unsigned long)(PUP(in)) << bits;
-                    bits += 8;
-                }
-                len += (unsigned)hold & ((1U << op) - 1);
-                hold >>= op;
-                bits -= op;
-            }
-            Tracevv((stderr, "inflate:         length %u\n", len));
-            if (bits < 15) {
-                hold += (unsigned long)(PUP(in)) << bits;
-                bits += 8;
-                hold += (unsigned long)(PUP(in)) << bits;
-                bits += 8;
-            }
-            here = dcode[hold & dmask];
-          dodist:
-            op = (unsigned)(here.bits);
-            hold >>= op;
-            bits -= op;
-            op = (unsigned)(here.op);
-            if (op & 16) {                      /* distance base */
-                dist = (unsigned)(here.val);
-                op &= 15;                       /* number of extra bits */
-                if (bits < op) {
-                    hold += (unsigned long)(PUP(in)) << bits;
-                    bits += 8;
-                    if (bits < op) {
-                        hold += (unsigned long)(PUP(in)) << bits;
-                        bits += 8;
-                    }
-                }
-                dist += (unsigned)hold & ((1U << op) - 1);
-#ifdef INFLATE_STRICT
-                if (dist > dmax) {
-                    strm->msg = (char *)"invalid distance too far back";
-                    state->mode = BAD;
-                    break;
-                }
-#endif
-                hold >>= op;
-                bits -= op;
-                Tracevv((stderr, "inflate:         distance %u\n", dist));
-                op = (unsigned)(out - beg);     /* max distance in output */
-                if (dist > op) {                /* see if copy from window */
-                    op = dist - op;             /* distance back in window */
-                    if (op > whave) {
-                        if (state->sane) {
-                            strm->msg =
-                                (char *)"invalid distance too far back";
-                            state->mode = BAD;
-                            break;
-                        }
-#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
-                        if (len <= op - whave) {
-                            do {
-                                PUP(out) = 0;
-                            } while (--len);
-                            continue;
-                        }
-                        len -= op - whave;
-                        do {
-                            PUP(out) = 0;
-                        } while (--op > whave);
-                        if (op == 0) {
-                            from = out - dist;
-                            do {
-                                PUP(out) = PUP(from);
-                            } while (--len);
-                            continue;
-                        }
-#endif
-                    }
-                    from = window - OFF;
-                    if (wnext == 0) {           /* very common case */
-                        from += wsize - op;
-                        if (op < len) {         /* some from window */
-                            len -= op;
-                            do {
-                                PUP(out) = PUP(from);
-                            } while (--op);
-                            from = out - dist;  /* rest from output */
-                        }
-                    }
-                    else if (wnext < op) {      /* wrap around window */
-                        from += wsize + wnext - op;
-                        op -= wnext;
-                        if (op < len) {         /* some from end of window */
-                            len -= op;
-                            do {
-                                PUP(out) = PUP(from);
-                            } while (--op);
-                            from = window - OFF;
-                            if (wnext < len) {  /* some from start of window */
-                                op = wnext;
-                                len -= op;
-                                do {
-                                    PUP(out) = PUP(from);
-                                } while (--op);
-                                from = out - dist;      /* rest from output */
-                            }
-                        }
-                    }
-                    else {                      /* contiguous in window */
-                        from += wnext - op;
-                        if (op < len) {         /* some from window */
-                            len -= op;
-                            do {
-                                PUP(out) = PUP(from);
-                            } while (--op);
-                            from = out - dist;  /* rest from output */
-                        }
-                    }
-                    while (len > 2) {
-                        PUP(out) = PUP(from);
-                        PUP(out) = PUP(from);
-                        PUP(out) = PUP(from);
-                        len -= 3;
-                    }
-                    if (len) {
-                        PUP(out) = PUP(from);
-                        if (len > 1)
-                            PUP(out) = PUP(from);
-                    }
-                }
-                else {
-                    from = out - dist;          /* copy direct from output */
-                    do {                        /* minimum length is three */
-                        PUP(out) = PUP(from);
-                        PUP(out) = PUP(from);
-                        PUP(out) = PUP(from);
-                        len -= 3;
-                    } while (len > 2);
-                    if (len) {
-                        PUP(out) = PUP(from);
-                        if (len > 1)
-                            PUP(out) = PUP(from);
-                    }
-                }
-            }
-            else if ((op & 64) == 0) {          /* 2nd level distance code */
-                here = dcode[here.val + (hold & ((1U << op) - 1))];
-                goto dodist;
-            }
-            else {
-                strm->msg = (char *)"invalid distance code";
-                state->mode = BAD;
-                break;
-            }
-        }
-        else if ((op & 64) == 0) {              /* 2nd level length code */
-            here = lcode[here.val + (hold & ((1U << op) - 1))];
-            goto dolen;
-        }
-        else if (op & 32) {                     /* end-of-block */
-            Tracevv((stderr, "inflate:         end of block\n"));
-            state->mode = TYPE;
-            break;
-        }
-        else {
-            strm->msg = (char *)"invalid literal/length code";
-            state->mode = BAD;
-            break;
-        }
-    } while (in < last && out < end);
-
-    /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
-    len = bits >> 3;
-    in -= len;
-    bits -= len << 3;
-    hold &= (1U << bits) - 1;
-
-    /* update state and return */
-    strm->next_in = in + OFF;
-    strm->next_out = out + OFF;
-    strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
-    strm->avail_out = (unsigned)(out < end ?
-                                 257 + (end - out) : 257 - (out - end));
-    state->hold = hold;
-    state->bits = bits;
-    return;
-}
-
-/*
-   inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe):
-   - Using bit fields for code structure
-   - Different op definition to avoid & for extra bits (do & for table bits)
-   - Three separate decoding do-loops for direct, window, and wnext == 0
-   - Special case for distance > 1 copies to do overlapped load and store copy
-   - Explicit branch predictions (based on measured branch probabilities)
-   - Deferring match copy and interspersed it with decoding subsequent codes
-   - Swapping literal/length else
-   - Swapping window/direct else
-   - Larger unrolled copy loops (three is about right)
-   - Moving len -= 3 statement into middle of loop
- */
-
-#endif /* !ASMINF */

3rdparty/zlib/cbits/inffast.h

@@ -1,11 +0,0 @@
-/* inffast.h -- header to use inffast.c
- * Copyright (C) 1995-2003, 2010 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* WARNING: this file should *not* be used by applications. It is
-   part of the implementation of the compression library and is
-   subject to change. Applications should only use zlib.h.
- */
-
-void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start));

3rdparty/zlib/cbits/inffixed.h

@@ -1,94 +0,0 @@
-    /* inffixed.h -- table for decoding fixed codes
-     * Generated automatically by makefixed().
-     */
-
-    /* WARNING: this file should *not* be used by applications.
-       It is part of the implementation of this library and is
-       subject to change. Applications should only use zlib.h.
-     */
-
-    static const code lenfix[512] = {
-        {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48},
-        {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128},
-        {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59},
-        {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176},
-        {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20},
-        {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100},
-        {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8},
-        {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216},
-        {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76},
-        {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114},
-        {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},
-        {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148},
-        {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42},
-        {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86},
-        {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15},
-        {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236},
-        {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62},
-        {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
-        {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31},
-        {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162},
-        {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25},
-        {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105},
-        {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4},
-        {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202},
-        {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69},
-        {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125},
-        {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13},
-        {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195},
-        {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35},
-        {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91},
-        {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19},
-        {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246},
-        {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55},
-        {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135},
-        {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99},
-        {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190},
-        {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16},
-        {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96},
-        {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6},
-        {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209},
-        {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},
-        {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116},
-        {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4},
-        {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153},
-        {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44},
-        {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82},
-        {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11},
-        {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
-        {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58},
-        {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138},
-        {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51},
-        {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173},
-        {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30},
-        {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110},
-        {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0},
-        {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195},
-        {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65},
-        {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121},
-        {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},
-        {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258},
-        {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37},
-        {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93},
-        {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23},
-        {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251},
-        {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51},
-        {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
-        {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67},
-        {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183},
-        {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23},
-        {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103},
-        {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9},
-        {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223},
-        {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79},
-        {0,9,255}
-    };
-
-    static const code distfix[32] = {
-        {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025},
-        {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193},
-        {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385},
-        {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577},
-        {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073},
-        {22,5,193},{64,5,0}
-    };

3rdparty/zlib/cbits/inflate.h

@@ -1,122 +0,0 @@
-/* inflate.h -- internal inflate state definition
- * Copyright (C) 1995-2009 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* WARNING: this file should *not* be used by applications. It is
-   part of the implementation of the compression library and is
-   subject to change. Applications should only use zlib.h.
- */
-
-/* define NO_GZIP when compiling if you want to disable gzip header and
-   trailer decoding by inflate().  NO_GZIP would be used to avoid linking in
-   the crc code when it is not needed.  For shared libraries, gzip decoding
-   should be left enabled. */
-#ifndef NO_GZIP
-#  define GUNZIP
-#endif
-
-/* Possible inflate modes between inflate() calls */
-typedef enum {
-    HEAD,       /* i: waiting for magic header */
-    FLAGS,      /* i: waiting for method and flags (gzip) */
-    TIME,       /* i: waiting for modification time (gzip) */
-    OS,         /* i: waiting for extra flags and operating system (gzip) */
-    EXLEN,      /* i: waiting for extra length (gzip) */
-    EXTRA,      /* i: waiting for extra bytes (gzip) */
-    NAME,       /* i: waiting for end of file name (gzip) */
-    COMMENT,    /* i: waiting for end of comment (gzip) */
-    HCRC,       /* i: waiting for header crc (gzip) */
-    DICTID,     /* i: waiting for dictionary check value */
-    DICT,       /* waiting for inflateSetDictionary() call */
-        TYPE,       /* i: waiting for type bits, including last-flag bit */
-        TYPEDO,     /* i: same, but skip check to exit inflate on new block */
-        STORED,     /* i: waiting for stored size (length and complement) */
-        COPY_,      /* i/o: same as COPY below, but only first time in */
-        COPY,       /* i/o: waiting for input or output to copy stored block */
-        TABLE,      /* i: waiting for dynamic block table lengths */
-        LENLENS,    /* i: waiting for code length code lengths */
-        CODELENS,   /* i: waiting for length/lit and distance code lengths */
-            LEN_,       /* i: same as LEN below, but only first time in */
-            LEN,        /* i: waiting for length/lit/eob code */
-            LENEXT,     /* i: waiting for length extra bits */
-            DIST,       /* i: waiting for distance code */
-            DISTEXT,    /* i: waiting for distance extra bits */
-            MATCH,      /* o: waiting for output space to copy string */
-            LIT,        /* o: waiting for output space to write literal */
-    CHECK,      /* i: waiting for 32-bit check value */
-    LENGTH,     /* i: waiting for 32-bit length (gzip) */
-    DONE,       /* finished check, done -- remain here until reset */
-    BAD,        /* got a data error -- remain here until reset */
-    MEM,        /* got an inflate() memory error -- remain here until reset */
-    SYNC        /* looking for synchronization bytes to restart inflate() */
-} inflate_mode;
-
-/*
-    State transitions between above modes -
-
-    (most modes can go to BAD or MEM on error -- not shown for clarity)
-
-    Process header:
-        HEAD -> (gzip) or (zlib) or (raw)
-        (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT ->
-                  HCRC -> TYPE
-        (zlib) -> DICTID or TYPE
-        DICTID -> DICT -> TYPE
-        (raw) -> TYPEDO
-    Read deflate blocks:
-            TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK
-            STORED -> COPY_ -> COPY -> TYPE
-            TABLE -> LENLENS -> CODELENS -> LEN_
-            LEN_ -> LEN
-    Read deflate codes in fixed or dynamic block:
-                LEN -> LENEXT or LIT or TYPE
-                LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
-                LIT -> LEN
-    Process trailer:
-        CHECK -> LENGTH -> DONE
- */
-
-/* state maintained between inflate() calls.  Approximately 10K bytes. */
-struct inflate_state {
-    inflate_mode mode;          /* current inflate mode */
-    int last;                   /* true if processing last block */
-    int wrap;                   /* bit 0 true for zlib, bit 1 true for gzip */
-    int havedict;               /* true if dictionary provided */
-    int flags;                  /* gzip header method and flags (0 if zlib) */
-    unsigned dmax;              /* zlib header max distance (INFLATE_STRICT) */
-    unsigned long check;        /* protected copy of check value */
-    unsigned long total;        /* protected copy of output count */
-    gz_headerp head;            /* where to save gzip header information */
-        /* sliding window */
-    unsigned wbits;             /* log base 2 of requested window size */
-    unsigned wsize;             /* window size or zero if not using window */
-    unsigned whave;             /* valid bytes in the window */
-    unsigned wnext;             /* window write index */
-    unsigned char FAR *window;  /* allocated sliding window, if needed */
-        /* bit accumulator */
-    unsigned long hold;         /* input bit accumulator */
-    unsigned bits;              /* number of bits in "in" */
-        /* for string and stored block copying */
-    unsigned length;            /* literal or length of data to copy */
-    unsigned offset;            /* distance back to copy string from */
-        /* for table and code decoding */
-    unsigned extra;             /* extra bits needed */
-        /* fixed and dynamic code tables */
-    code const FAR *lencode;    /* starting table for length/literal codes */
-    code const FAR *distcode;   /* starting table for distance codes */
-    unsigned lenbits;           /* index bits for lencode */
-    unsigned distbits;          /* index bits for distcode */
-        /* dynamic table building */
-    unsigned ncode;             /* number of code length code lengths */
-    unsigned nlen;              /* number of length code lengths */
-    unsigned ndist;             /* number of distance code lengths */
-    unsigned have;              /* number of code lengths in lens[] */
-    code FAR *next;             /* next available space in codes[] */
-    unsigned short lens[320];   /* temporary storage for code lengths */
-    unsigned short work[288];   /* work area for code table building */
-    code codes[ENOUGH];         /* space for code tables */
-    int sane;                   /* if false, allow invalid distance too far */
-    int back;                   /* bits back of last unprocessed length/lit */
-    unsigned was;               /* initial length of match */
-};

3rdparty/zlib/cbits/inftrees.c

@@ -1,306 +0,0 @@
-/* inftrees.c -- generate Huffman trees for efficient decoding
- * Copyright (C) 1995-2013 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include "zutil.h"
-#include "inftrees.h"
-
-#define MAXBITS 15
-
-const char inflate_copyright[] =
-   " inflate 1.2.8 Copyright 1995-2013 Mark Adler ";
-/*
-  If you use the zlib library in a product, an acknowledgment is welcome
-  in the documentation of your product. If for some reason you cannot
-  include such an acknowledgment, I would appreciate that you keep this
-  copyright string in the executable of your product.
- */
-
-/*
-   Build a set of tables to decode the provided canonical Huffman code.
-   The code lengths are lens[0..codes-1].  The result starts at *table,
-   whose indices are 0..2^bits-1.  work is a writable array of at least
-   lens shorts, which is used as a work area.  type is the type of code
-   to be generated, CODES, LENS, or DISTS.  On return, zero is success,
-   -1 is an invalid code, and +1 means that ENOUGH isn't enough.  table
-   on return points to the next available entry's address.  bits is the
-   requested root table index bits, and on return it is the actual root
-   table index bits.  It will differ if the request is greater than the
-   longest code or if it is less than the shortest code.
- */
-int ZLIB_INTERNAL inflate_table(type, lens, codes, table, bits, work)
-codetype type;
-unsigned short FAR *lens;
-unsigned codes;
-code FAR * FAR *table;
-unsigned FAR *bits;
-unsigned short FAR *work;
-{
-    unsigned len;               /* a code's length in bits */
-    unsigned sym;               /* index of code symbols */
-    unsigned min, max;          /* minimum and maximum code lengths */
-    unsigned root;              /* number of index bits for root table */
-    unsigned curr;              /* number of index bits for current table */
-    unsigned drop;              /* code bits to drop for sub-table */
-    int left;                   /* number of prefix codes available */
-    unsigned used;              /* code entries in table used */
-    unsigned huff;              /* Huffman code */
-    unsigned incr;              /* for incrementing code, index */
-    unsigned fill;              /* index for replicating entries */
-    unsigned low;               /* low bits for current root entry */
-    unsigned mask;              /* mask for low root bits */
-    code here;                  /* table entry for duplication */
-    code FAR *next;             /* next available space in table */
-    const unsigned short FAR *base;     /* base value table to use */
-    const unsigned short FAR *extra;    /* extra bits table to use */
-    int end;                    /* use base and extra for symbol > end */
-    unsigned short count[MAXBITS+1];    /* number of codes of each length */
-    unsigned short offs[MAXBITS+1];     /* offsets in table for each length */
-    static const unsigned short lbase[31] = { /* Length codes 257..285 base */
-        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
-        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
-    static const unsigned short lext[31] = { /* Length codes 257..285 extra */
-        16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
-        19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78};
-    static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
-        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
-        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
-        8193, 12289, 16385, 24577, 0, 0};
-    static const unsigned short dext[32] = { /* Distance codes 0..29 extra */
-        16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
-        23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
-        28, 28, 29, 29, 64, 64};
-
-    /*
-       Process a set of code lengths to create a canonical Huffman code.  The
-       code lengths are lens[0..codes-1].  Each length corresponds to the
-       symbols 0..codes-1.  The Huffman code is generated by first sorting the
-       symbols by length from short to long, and retaining the symbol order
-       for codes with equal lengths.  Then the code starts with all zero bits
-       for the first code of the shortest length, and the codes are integer
-       increments for the same length, and zeros are appended as the length
-       increases.  For the deflate format, these bits are stored backwards
-       from their more natural integer increment ordering, and so when the
-       decoding tables are built in the large loop below, the integer codes
-       are incremented backwards.
-
-       This routine assumes, but does not check, that all of the entries in
-       lens[] are in the range 0..MAXBITS.  The caller must assure this.
-       1..MAXBITS is interpreted as that code length.  zero means that that
-       symbol does not occur in this code.
-
-       The codes are sorted by computing a count of codes for each length,
-       creating from that a table of starting indices for each length in the
-       sorted table, and then entering the symbols in order in the sorted
-       table.  The sorted table is work[], with that space being provided by
-       the caller.
-
-       The length counts are used for other purposes as well, i.e. finding
-       the minimum and maximum length codes, determining if there are any
-       codes at all, checking for a valid set of lengths, and looking ahead
-       at length counts to determine sub-table sizes when building the
-       decoding tables.
-     */
-
-    /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
-    for (len = 0; len <= MAXBITS; len++)
-        count[len] = 0;
-    for (sym = 0; sym < codes; sym++)
-        count[lens[sym]]++;
-
-    /* bound code lengths, force root to be within code lengths */
-    root = *bits;
-    for (max = MAXBITS; max >= 1; max--)
-        if (count[max] != 0) break;
-    if (root > max) root = max;
-    if (max == 0) {                     /* no symbols to code at all */
-        here.op = (unsigned char)64;    /* invalid code marker */
-        here.bits = (unsigned char)1;
-        here.val = (unsigned short)0;
-        *(*table)++ = here;             /* make a table to force an error */
-        *(*table)++ = here;
-        *bits = 1;
-        return 0;     /* no symbols, but wait for decoding to report error */
-    }
-    for (min = 1; min < max; min++)
-        if (count[min] != 0) break;
-    if (root < min) root = min;
-
-    /* check for an over-subscribed or incomplete set of lengths */
-    left = 1;
-    for (len = 1; len <= MAXBITS; len++) {
-        left <<= 1;
-        left -= count[len];
-        if (left < 0) return -1;        /* over-subscribed */
-    }
-    if (left > 0 && (type == CODES || max != 1))
-        return -1;                      /* incomplete set */
-
-    /* generate offsets into symbol table for each length for sorting */
-    offs[1] = 0;
-    for (len = 1; len < MAXBITS; len++)
-        offs[len + 1] = offs[len] + count[len];
-
-    /* sort symbols by length, by symbol order within each length */
-    for (sym = 0; sym < codes; sym++)
-        if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
-
-    /*
-       Create and fill in decoding tables.  In this loop, the table being
-       filled is at next and has curr index bits.  The code being used is huff
-       with length len.  That code is converted to an index by dropping drop
-       bits off of the bottom.  For codes where len is less than drop + curr,
-       those top drop + curr - len bits are incremented through all values to
-       fill the table with replicated entries.
-
-       root is the number of index bits for the root table.  When len exceeds
-       root, sub-tables are created pointed to by the root entry with an index
-       of the low root bits of huff.  This is saved in low to check for when a
-       new sub-table should be started.  drop is zero when the root table is
-       being filled, and drop is root when sub-tables are being filled.
-
-       When a new sub-table is needed, it is necessary to look ahead in the
-       code lengths to determine what size sub-table is needed.  The length
-       counts are used for this, and so count[] is decremented as codes are
-       entered in the tables.
-
-       used keeps track of how many table entries have been allocated from the
-       provided *table space.  It is checked for LENS and DIST tables against
-       the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
-       the initial root table size constants.  See the comments in inftrees.h
-       for more information.
-
-       sym increments through all symbols, and the loop terminates when
-       all codes of length max, i.e. all codes, have been processed.  This
-       routine permits incomplete codes, so another loop after this one fills
-       in the rest of the decoding tables with invalid code markers.
-     */
-
-    /* set up for code type */
-    switch (type) {
-    case CODES:
-        base = extra = work;    /* dummy value--not used */
-        end = 19;
-        break;
-    case LENS:
-        base = lbase;
-        base -= 257;
-        extra = lext;
-        extra -= 257;
-        end = 256;
-        break;
-    default:            /* DISTS */
-        base = dbase;
-        extra = dext;
-        end = -1;
-    }
-
-    /* initialize state for loop */
-    huff = 0;                   /* starting code */
-    sym = 0;                    /* starting code symbol */
-    len = min;                  /* starting code length */
-    next = *table;              /* current table to fill in */
-    curr = root;                /* current table index bits */
-    drop = 0;                   /* current bits to drop from code for index */
-    low = (unsigned)(-1);       /* trigger new sub-table when len > root */
-    used = 1U << root;          /* use root table entries */
-    mask = used - 1;            /* mask for comparing low */
-
-    /* check available table space */
-    if ((type == LENS && used > ENOUGH_LENS) ||
-        (type == DISTS && used > ENOUGH_DISTS))
-        return 1;
-
-    /* process all codes and make table entries */
-    for (;;) {
-        /* create table entry */
-        here.bits = (unsigned char)(len - drop);
-        if ((int)(work[sym]) < end) {
-            here.op = (unsigned char)0;
-            here.val = work[sym];
-        }
-        else if ((int)(work[sym]) > end) {
-            here.op = (unsigned char)(extra[work[sym]]);
-            here.val = base[work[sym]];
-        }
-        else {
-            here.op = (unsigned char)(32 + 64);         /* end of block */
-            here.val = 0;
-        }
-
-        /* replicate for those indices with low len bits equal to huff */
-        incr = 1U << (len - drop);
-        fill = 1U << curr;
-        min = fill;                 /* save offset to next table */
-        do {
-            fill -= incr;
-            next[(huff >> drop) + fill] = here;
-        } while (fill != 0);
-
-        /* backwards increment the len-bit code huff */
-        incr = 1U << (len - 1);
-        while (huff & incr)
-            incr >>= 1;
-        if (incr != 0) {
-            huff &= incr - 1;
-            huff += incr;
-        }
-        else
-            huff = 0;
-
-        /* go to next symbol, update count, len */
-        sym++;
-        if (--(count[len]) == 0) {
-            if (len == max) break;
-            len = lens[work[sym]];
-        }
-
-        /* create new sub-table if needed */
-        if (len > root && (huff & mask) != low) {
-            /* if first time, transition to sub-tables */
-            if (drop == 0)
-                drop = root;
-
-            /* increment past last table */
-            next += min;            /* here min is 1 << curr */
-
-            /* determine length of next table */
-            curr = len - drop;
-            left = (int)(1 << curr);
-            while (curr + drop < max) {
-                left -= count[curr + drop];
-                if (left <= 0) break;
-                curr++;
-                left <<= 1;
-            }
-
-            /* check for enough space */
-            used += 1U << curr;
-            if ((type == LENS && used > ENOUGH_LENS) ||
-                (type == DISTS && used > ENOUGH_DISTS))
-                return 1;
-
-            /* point entry in root table to sub-table */
-            low = huff & mask;
-            (*table)[low].op = (unsigned char)curr;
-            (*table)[low].bits = (unsigned char)root;
-            (*table)[low].val = (unsigned short)(next - *table);
-        }
-    }
-
-    /* fill in remaining table entry if code is incomplete (guaranteed to have
-       at most one remaining entry, since if the code is incomplete, the
-       maximum code length that was allowed to get this far is one bit) */
-    if (huff != 0) {
-        here.op = (unsigned char)64;            /* invalid code marker */
-        here.bits = (unsigned char)(len - drop);
-        here.val = (unsigned short)0;
-        next[huff] = here;
-    }
-
-    /* set return parameters */
-    *table += used;
-    *bits = root;
-    return 0;
-}

3rdparty/zlib/cbits/inftrees.h

@@ -1,62 +0,0 @@
-/* inftrees.h -- header to use inftrees.c
- * Copyright (C) 1995-2005, 2010 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* WARNING: this file should *not* be used by applications. It is
-   part of the implementation of the compression library and is
-   subject to change. Applications should only use zlib.h.
- */
-
-/* Structure for decoding tables.  Each entry provides either the
-   information needed to do the operation requested by the code that
-   indexed that table entry, or it provides a pointer to another
-   table that indexes more bits of the code.  op indicates whether
-   the entry is a pointer to another table, a literal, a length or
-   distance, an end-of-block, or an invalid code.  For a table
-   pointer, the low four bits of op is the number of index bits of
-   that table.  For a length or distance, the low four bits of op
-   is the number of extra bits to get after the code.  bits is
-   the number of bits in this code or part of the code to drop off
-   of the bit buffer.  val is the actual byte to output in the case
-   of a literal, the base length or distance, or the offset from
-   the current table to the next table.  Each entry is four bytes. */
-typedef struct {
-    unsigned char op;           /* operation, extra bits, table bits */
-    unsigned char bits;         /* bits in this part of the code */
-    unsigned short val;         /* offset in table or code value */
-} code;
-
-/* op values as set by inflate_table():
-    00000000 - literal
-    0000tttt - table link, tttt != 0 is the number of table index bits
-    0001eeee - length or distance, eeee is the number of extra bits
-    01100000 - end of block
-    01000000 - invalid code
- */
-
-/* Maximum size of the dynamic table.  The maximum number of code structures is
-   1444, which is the sum of 852 for literal/length codes and 592 for distance
-   codes.  These values were found by exhaustive searches using the program
-   examples/enough.c found in the zlib distribtution.  The arguments to that
-   program are the number of symbols, the initial root table size, and the
-   maximum bit length of a code.  "enough 286 9 15" for literal/length codes
-   returns returns 852, and "enough 30 6 15" for distance codes returns 592.
-   The initial root table size (9 or 6) is found in the fifth argument of the
-   inflate_table() calls in inflate.c and infback.c.  If the root table size is
-   changed, then these maximum sizes would be need to be recalculated and
-   updated. */
-#define ENOUGH_LENS 852
-#define ENOUGH_DISTS 592
-#define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS)
-
-/* Type of code to build for inflate_table() */
-typedef enum {
-    CODES,
-    LENS,
-    DISTS
-} codetype;
-
-int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens,
-                             unsigned codes, code FAR * FAR *table,
-                             unsigned FAR *bits, unsigned short FAR *work));

3rdparty/zlib/cbits/trees.h

@@ -1,128 +0,0 @@
-/* header created automatically with -DGEN_TREES_H */
-
-local const ct_data static_ltree[L_CODES+2] = {
-{{ 12},{  8}}, {{140},{  8}}, {{ 76},{  8}}, {{204},{  8}}, {{ 44},{  8}},
-{{172},{  8}}, {{108},{  8}}, {{236},{  8}}, {{ 28},{  8}}, {{156},{  8}},
-{{ 92},{  8}}, {{220},{  8}}, {{ 60},{  8}}, {{188},{  8}}, {{124},{  8}},
-{{252},{  8}}, {{  2},{  8}}, {{130},{  8}}, {{ 66},{  8}}, {{194},{  8}},
-{{ 34},{  8}}, {{162},{  8}}, {{ 98},{  8}}, {{226},{  8}}, {{ 18},{  8}},
-{{146},{  8}}, {{ 82},{  8}}, {{210},{  8}}, {{ 50},{  8}}, {{178},{  8}},
-{{114},{  8}}, {{242},{  8}}, {{ 10},{  8}}, {{138},{  8}}, {{ 74},{  8}},
-{{202},{  8}}, {{ 42},{  8}}, {{170},{  8}}, {{106},{  8}}, {{234},{  8}},
-{{ 26},{  8}}, {{154},{  8}}, {{ 90},{  8}}, {{218},{  8}}, {{ 58},{  8}},
-{{186},{  8}}, {{122},{  8}}, {{250},{  8}}, {{  6},{  8}}, {{134},{  8}},
-{{ 70},{  8}}, {{198},{  8}}, {{ 38},{  8}}, {{166},{  8}}, {{102},{  8}},
-{{230},{  8}}, {{ 22},{  8}}, {{150},{  8}}, {{ 86},{  8}}, {{214},{  8}},
-{{ 54},{  8}}, {{182},{  8}}, {{118},{  8}}, {{246},{  8}}, {{ 14},{  8}},
-{{142},{  8}}, {{ 78},{  8}}, {{206},{  8}}, {{ 46},{  8}}, {{174},{  8}},
-{{110},{  8}}, {{238},{  8}}, {{ 30},{  8}}, {{158},{  8}}, {{ 94},{  8}},
-{{222},{  8}}, {{ 62},{  8}}, {{190},{  8}}, {{126},{  8}}, {{254},{  8}},
-{{  1},{  8}}, {{129},{  8}}, {{ 65},{  8}}, {{193},{  8}}, {{ 33},{  8}},
-{{161},{  8}}, {{ 97},{  8}}, {{225},{  8}}, {{ 17},{  8}}, {{145},{  8}},
-{{ 81},{  8}}, {{209},{  8}}, {{ 49},{  8}}, {{177},{  8}}, {{113},{  8}},
-{{241},{  8}}, {{  9},{  8}}, {{137},{  8}}, {{ 73},{  8}}, {{201},{  8}},
-{{ 41},{  8}}, {{169},{  8}}, {{105},{  8}}, {{233},{  8}}, {{ 25},{  8}},
-{{153},{  8}}, {{ 89},{  8}}, {{217},{  8}}, {{ 57},{  8}}, {{185},{  8}},
-{{121},{  8}}, {{249},{  8}}, {{  5},{  8}}, {{133},{  8}}, {{ 69},{  8}},
-{{197},{  8}}, {{ 37},{  8}}, {{165},{  8}}, {{101},{  8}}, {{229},{  8}},
-{{ 21},{  8}}, {{149},{  8}}, {{ 85},{  8}}, {{213},{  8}}, {{ 53},{  8}},
-{{181},{  8}}, {{117},{  8}}, {{245},{  8}}, {{ 13},{  8}}, {{141},{  8}},
-{{ 77},{  8}}, {{205},{  8}}, {{ 45},{  8}}, {{173},{  8}}, {{109},{  8}},
-{{237},{  8}}, {{ 29},{  8}}, {{157},{  8}}, {{ 93},{  8}}, {{221},{  8}},
-{{ 61},{  8}}, {{189},{  8}}, {{125},{  8}}, {{253},{  8}}, {{ 19},{  9}},
-{{275},{  9}}, {{147},{  9}}, {{403},{  9}}, {{ 83},{  9}}, {{339},{  9}},
-{{211},{  9}}, {{467},{  9}}, {{ 51},{  9}}, {{307},{  9}}, {{179},{  9}},
-{{435},{  9}}, {{115},{  9}}, {{371},{  9}}, {{243},{  9}}, {{499},{  9}},
-{{ 11},{  9}}, {{267},{  9}}, {{139},{  9}}, {{395},{  9}}, {{ 75},{  9}},
-{{331},{  9}}, {{203},{  9}}, {{459},{  9}}, {{ 43},{  9}}, {{299},{  9}},
-{{171},{  9}}, {{427},{  9}}, {{107},{  9}}, {{363},{  9}}, {{235},{  9}},
-{{491},{  9}}, {{ 27},{  9}}, {{283},{  9}}, {{155},{  9}}, {{411},{  9}},
-{{ 91},{  9}}, {{347},{  9}}, {{219},{  9}}, {{475},{  9}}, {{ 59},{  9}},
-{{315},{  9}}, {{187},{  9}}, {{443},{  9}}, {{123},{  9}}, {{379},{  9}},
-{{251},{  9}}, {{507},{  9}}, {{  7},{  9}}, {{263},{  9}}, {{135},{  9}},
-{{391},{  9}}, {{ 71},{  9}}, {{327},{  9}}, {{199},{  9}}, {{455},{  9}},
-{{ 39},{  9}}, {{295},{  9}}, {{167},{  9}}, {{423},{  9}}, {{103},{  9}},
-{{359},{  9}}, {{231},{  9}}, {{487},{  9}}, {{ 23},{  9}}, {{279},{  9}},
-{{151},{  9}}, {{407},{  9}}, {{ 87},{  9}}, {{343},{  9}}, {{215},{  9}},
-{{471},{  9}}, {{ 55},{  9}}, {{311},{  9}}, {{183},{  9}}, {{439},{  9}},
-{{119},{  9}}, {{375},{  9}}, {{247},{  9}}, {{503},{  9}}, {{ 15},{  9}},
-{{271},{  9}}, {{143},{  9}}, {{399},{  9}}, {{ 79},{  9}}, {{335},{  9}},
-{{207},{  9}}, {{463},{  9}}, {{ 47},{  9}}, {{303},{  9}}, {{175},{  9}},
-{{431},{  9}}, {{111},{  9}}, {{367},{  9}}, {{239},{  9}}, {{495},{  9}},
-{{ 31},{  9}}, {{287},{  9}}, {{159},{  9}}, {{415},{  9}}, {{ 95},{  9}},
-{{351},{  9}}, {{223},{  9}}, {{479},{  9}}, {{ 63},{  9}}, {{319},{  9}},
-{{191},{  9}}, {{447},{  9}}, {{127},{  9}}, {{383},{  9}}, {{255},{  9}},
-{{511},{  9}}, {{  0},{  7}}, {{ 64},{  7}}, {{ 32},{  7}}, {{ 96},{  7}},
-{{ 16},{  7}}, {{ 80},{  7}}, {{ 48},{  7}}, {{112},{  7}}, {{  8},{  7}},
-{{ 72},{  7}}, {{ 40},{  7}}, {{104},{  7}}, {{ 24},{  7}}, {{ 88},{  7}},
-{{ 56},{  7}}, {{120},{  7}}, {{  4},{  7}}, {{ 68},{  7}}, {{ 36},{  7}},
-{{100},{  7}}, {{ 20},{  7}}, {{ 84},{  7}}, {{ 52},{  7}}, {{116},{  7}},
-{{  3},{  8}}, {{131},{  8}}, {{ 67},{  8}}, {{195},{  8}}, {{ 35},{  8}},
-{{163},{  8}}, {{ 99},{  8}}, {{227},{  8}}
-};
-
-local const ct_data static_dtree[D_CODES] = {
-{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}},
-{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}},
-{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}},
-{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}},
-{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}},
-{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}}
-};
-
-const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {
- 0,  1,  2,  3,  4,  4,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  8,
- 8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9, 10, 10, 10, 10, 10, 10, 10, 10,
-10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
-11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
-12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
-13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
-13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
-14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
-15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
-15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
-15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,  0,  0, 16, 17,
-18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
-23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
-26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
-26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
-27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
-28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
-29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
-29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
-29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
-};
-
-const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {
- 0,  1,  2,  3,  4,  5,  6,  7,  8,  8,  9,  9, 10, 10, 11, 11, 12, 12, 12, 12,
-13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
-17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
-19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
-21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
-22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
-23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
-25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
-26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
-26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
-27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
-};
-
-local const int base_length[LENGTH_CODES] = {
-0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
-64, 80, 96, 112, 128, 160, 192, 224, 0
-};
-
-local const int base_dist[D_CODES] = {
-    0,     1,     2,     3,     4,     6,     8,    12,    16,    24,
-   32,    48,    64,    96,   128,   192,   256,   384,   512,   768,
- 1024,  1536,  2048,  3072,  4096,  6144,  8192, 12288, 16384, 24576
-};
-

3rdparty/zlib/cbits/uncompr.c

@@ -1,59 +0,0 @@
-/* uncompr.c -- decompress a memory buffer
- * Copyright (C) 1995-2003, 2010 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* @(#) $Id$ */
-
-#define ZLIB_INTERNAL
-#include "zlib.h"
-
-/* ===========================================================================
-     Decompresses the source buffer into the destination buffer.  sourceLen is
-   the byte length of the source buffer. Upon entry, destLen is the total
-   size of the destination buffer, which must be large enough to hold the
-   entire uncompressed data. (The size of the uncompressed data must have
-   been saved previously by the compressor and transmitted to the decompressor
-   by some mechanism outside the scope of this compression library.)
-   Upon exit, destLen is the actual size of the compressed buffer.
-
-     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
-   enough memory, Z_BUF_ERROR if there was not enough room in the output
-   buffer, or Z_DATA_ERROR if the input data was corrupted.
-*/
-int ZEXPORT uncompress (dest, destLen, source, sourceLen)
-    Bytef *dest;
-    uLongf *destLen;
-    const Bytef *source;
-    uLong sourceLen;
-{
-    z_stream stream;
-    int err;
-
-    stream.next_in = (z_const Bytef *)source;
-    stream.avail_in = (uInt)sourceLen;
-    /* Check for source > 64K on 16-bit machine: */
-    if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
-
-    stream.next_out = dest;
-    stream.avail_out = (uInt)*destLen;
-    if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
-
-    stream.zalloc = (alloc_func)0;
-    stream.zfree = (free_func)0;
-
-    err = inflateInit(&stream);
-    if (err != Z_OK) return err;
-
-    err = inflate(&stream, Z_FINISH);
-    if (err != Z_STREAM_END) {
-        inflateEnd(&stream);
-        if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0))
-            return Z_DATA_ERROR;
-        return err;
-    }
-    *destLen = stream.total_out;
-
-    err = inflateEnd(&stream);
-    return err;
-}

3rdparty/zlib/cbits/zconf.h

@@ -1,511 +0,0 @@
-/* zconf.h -- configuration of the zlib compression library
- * Copyright (C) 1995-2013 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* @(#) $Id$ */
-
-#ifndef ZCONF_H
-#define ZCONF_H
-
-/*
- * If you *really* need a unique prefix for all types and library functions,
- * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
- * Even better than compiling with -DZ_PREFIX would be to use configure to set
- * this permanently in zconf.h using "./configure --zprefix".
- */
-#ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
-#  define Z_PREFIX_SET
-
-/* all linked symbols */
-#  define _dist_code            z__dist_code
-#  define _length_code          z__length_code
-#  define _tr_align             z__tr_align
-#  define _tr_flush_bits        z__tr_flush_bits
-#  define _tr_flush_block       z__tr_flush_block
-#  define _tr_init              z__tr_init
-#  define _tr_stored_block      z__tr_stored_block
-#  define _tr_tally             z__tr_tally
-#  define adler32               z_adler32
-#  define adler32_combine       z_adler32_combine
-#  define adler32_combine64     z_adler32_combine64
-#  ifndef Z_SOLO
-#    define compress              z_compress
-#    define compress2             z_compress2
-#    define compressBound         z_compressBound
-#  endif
-#  define crc32                 z_crc32
-#  define crc32_combine         z_crc32_combine
-#  define crc32_combine64       z_crc32_combine64
-#  define deflate               z_deflate
-#  define deflateBound          z_deflateBound
-#  define deflateCopy           z_deflateCopy
-#  define deflateEnd            z_deflateEnd
-#  define deflateInit2_         z_deflateInit2_
-#  define deflateInit_          z_deflateInit_
-#  define deflateParams         z_deflateParams
-#  define deflatePending        z_deflatePending
-#  define deflatePrime          z_deflatePrime
-#  define deflateReset          z_deflateReset
-#  define deflateResetKeep      z_deflateResetKeep
-#  define deflateSetDictionary  z_deflateSetDictionary
-#  define deflateSetHeader      z_deflateSetHeader
-#  define deflateTune           z_deflateTune
-#  define deflate_copyright     z_deflate_copyright
-#  define get_crc_table         z_get_crc_table
-#  ifndef Z_SOLO
-#    define gz_error              z_gz_error
-#    define gz_intmax             z_gz_intmax
-#    define gz_strwinerror        z_gz_strwinerror
-#    define gzbuffer              z_gzbuffer
-#    define gzclearerr            z_gzclearerr
-#    define gzclose               z_gzclose
-#    define gzclose_r             z_gzclose_r
-#    define gzclose_w             z_gzclose_w
-#    define gzdirect              z_gzdirect
-#    define gzdopen               z_gzdopen
-#    define gzeof                 z_gzeof
-#    define gzerror               z_gzerror
-#    define gzflush               z_gzflush
-#    define gzgetc                z_gzgetc
-#    define gzgetc_               z_gzgetc_
-#    define gzgets                z_gzgets
-#    define gzoffset              z_gzoffset
-#    define gzoffset64            z_gzoffset64
-#    define gzopen                z_gzopen
-#    define gzopen64              z_gzopen64
-#    ifdef _WIN32
-#      define gzopen_w              z_gzopen_w
-#    endif
-#    define gzprintf              z_gzprintf
-#    define gzvprintf             z_gzvprintf
-#    define gzputc                z_gzputc
-#    define gzputs                z_gzputs
-#    define gzread                z_gzread
-#    define gzrewind              z_gzrewind
-#    define gzseek                z_gzseek
-#    define gzseek64              z_gzseek64
-#    define gzsetparams           z_gzsetparams
-#    define gztell                z_gztell
-#    define gztell64              z_gztell64
-#    define gzungetc              z_gzungetc
-#    define gzwrite               z_gzwrite
-#  endif
-#  define inflate               z_inflate
-#  define inflateBack           z_inflateBack
-#  define inflateBackEnd        z_inflateBackEnd
-#  define inflateBackInit_      z_inflateBackInit_
-#  define inflateCopy           z_inflateCopy
-#  define inflateEnd            z_inflateEnd
-#  define inflateGetHeader      z_inflateGetHeader
-#  define inflateInit2_         z_inflateInit2_
-#  define inflateInit_          z_inflateInit_
-#  define inflateMark           z_inflateMark
-#  define inflatePrime          z_inflatePrime
-#  define inflateReset          z_inflateReset
-#  define inflateReset2         z_inflateReset2
-#  define inflateSetDictionary  z_inflateSetDictionary
-#  define inflateGetDictionary  z_inflateGetDictionary
-#  define inflateSync           z_inflateSync
-#  define inflateSyncPoint      z_inflateSyncPoint
-#  define inflateUndermine      z_inflateUndermine
-#  define inflateResetKeep      z_inflateResetKeep
-#  define inflate_copyright     z_inflate_copyright
-#  define inflate_fast          z_inflate_fast
-#  define inflate_table         z_inflate_table
-#  ifndef Z_SOLO
-#    define uncompress            z_uncompress
-#  endif
-#  define zError                z_zError
-#  ifndef Z_SOLO
-#    define zcalloc               z_zcalloc
-#    define zcfree                z_zcfree
-#  endif
-#  define zlibCompileFlags      z_zlibCompileFlags
-#  define zlibVersion           z_zlibVersion
-
-/* all zlib typedefs in zlib.h and zconf.h */
-#  define Byte                  z_Byte
-#  define Bytef                 z_Bytef
-#  define alloc_func            z_alloc_func
-#  define charf                 z_charf
-#  define free_func             z_free_func
-#  ifndef Z_SOLO
-#    define gzFile                z_gzFile
-#  endif
-#  define gz_header             z_gz_header
-#  define gz_headerp            z_gz_headerp
-#  define in_func               z_in_func
-#  define intf                  z_intf
-#  define out_func              z_out_func
-#  define uInt                  z_uInt
-#  define uIntf                 z_uIntf
-#  define uLong                 z_uLong
-#  define uLongf                z_uLongf
-#  define voidp                 z_voidp
-#  define voidpc                z_voidpc
-#  define voidpf                z_voidpf
-
-/* all zlib structs in zlib.h and zconf.h */
-#  define gz_header_s           z_gz_header_s
-#  define internal_state        z_internal_state
-
-#endif
-
-#if defined(__MSDOS__) && !defined(MSDOS)
-#  define MSDOS
-#endif
-#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
-#  define OS2
-#endif
-#if defined(_WINDOWS) && !defined(WINDOWS)
-#  define WINDOWS
-#endif
-#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
-#  ifndef WIN32
-#    define WIN32
-#  endif
-#endif
-#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
-#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
-#    ifndef SYS16BIT
-#      define SYS16BIT
-#    endif
-#  endif
-#endif
-
-/*
- * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
- * than 64k bytes at a time (needed on systems with 16-bit int).
- */
-#ifdef SYS16BIT
-#  define MAXSEG_64K
-#endif
-#ifdef MSDOS
-#  define UNALIGNED_OK
-#endif
-
-#ifdef __STDC_VERSION__
-#  ifndef STDC
-#    define STDC
-#  endif
-#  if __STDC_VERSION__ >= 199901L
-#    ifndef STDC99
-#      define STDC99
-#    endif
-#  endif
-#endif
-#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
-#  define STDC
-#endif
-#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
-#  define STDC
-#endif
-#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
-#  define STDC
-#endif
-#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
-#  define STDC
-#endif
-
-#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
-#  define STDC
-#endif
-
-#ifndef STDC
-#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
-#    define const       /* note: need a more gentle solution here */
-#  endif
-#endif
-
-#if defined(ZLIB_CONST) && !defined(z_const)
-#  define z_const const
-#else
-#  define z_const
-#endif
-
-/* Some Mac compilers merge all .h files incorrectly: */
-#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
-#  define NO_DUMMY_DECL
-#endif
-
-/* Maximum value for memLevel in deflateInit2 */
-#ifndef MAX_MEM_LEVEL
-#  ifdef MAXSEG_64K
-#    define MAX_MEM_LEVEL 8
-#  else
-#    define MAX_MEM_LEVEL 9
-#  endif
-#endif
-
-/* Maximum value for windowBits in deflateInit2 and inflateInit2.
- * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
- * created by gzip. (Files created by minigzip can still be extracted by
- * gzip.)
- */
-#ifndef MAX_WBITS
-#  define MAX_WBITS   15 /* 32K LZ77 window */
-#endif
-
-/* The memory requirements for deflate are (in bytes):
-            (1 << (windowBits+2)) +  (1 << (memLevel+9))
- that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
- plus a few kilobytes for small objects. For example, if you want to reduce
- the default memory requirements from 256K to 128K, compile with
-     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
- Of course this will generally degrade compression (there's no free lunch).
-
-   The memory requirements for inflate are (in bytes) 1 << windowBits
- that is, 32K for windowBits=15 (default value) plus a few kilobytes
- for small objects.
-*/
-
-                        /* Type declarations */
-
-#ifndef OF /* function prototypes */
-#  ifdef STDC
-#    define OF(args)  args
-#  else
-#    define OF(args)  ()
-#  endif
-#endif
-
-#ifndef Z_ARG /* function prototypes for stdarg */
-#  if defined(STDC) || defined(Z_HAVE_STDARG_H)
-#    define Z_ARG(args)  args
-#  else
-#    define Z_ARG(args)  ()
-#  endif
-#endif
-
-/* The following definitions for FAR are needed only for MSDOS mixed
- * model programming (small or medium model with some far allocations).
- * This was tested only with MSC; for other MSDOS compilers you may have
- * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
- * just define FAR to be empty.
- */
-#ifdef SYS16BIT
-#  if defined(M_I86SM) || defined(M_I86MM)
-     /* MSC small or medium model */
-#    define SMALL_MEDIUM
-#    ifdef _MSC_VER
-#      define FAR _far
-#    else
-#      define FAR far
-#    endif
-#  endif
-#  if (defined(__SMALL__) || defined(__MEDIUM__))
-     /* Turbo C small or medium model */
-#    define SMALL_MEDIUM
-#    ifdef __BORLANDC__
-#      define FAR _far
-#    else
-#      define FAR far
-#    endif
-#  endif
-#endif
-
-#if defined(WINDOWS) || defined(WIN32)
-   /* If building or using zlib as a DLL, define ZLIB_DLL.
-    * This is not mandatory, but it offers a little performance increase.
-    */
-#  ifdef ZLIB_DLL
-#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
-#      ifdef ZLIB_INTERNAL
-#        define ZEXTERN extern __declspec(dllexport)
-#      else
-#        define ZEXTERN extern __declspec(dllimport)
-#      endif
-#    endif
-#  endif  /* ZLIB_DLL */
-   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
-    * define ZLIB_WINAPI.
-    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
-    */
-#  ifdef ZLIB_WINAPI
-#    ifdef FAR
-#      undef FAR
-#    endif
-#    include <windows.h>
-     /* No need for _export, use ZLIB.DEF instead. */
-     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
-#    define ZEXPORT WINAPI
-#    ifdef WIN32
-#      define ZEXPORTVA WINAPIV
-#    else
-#      define ZEXPORTVA FAR CDECL
-#    endif
-#  endif
-#endif
-
-#if defined (__BEOS__)
-#  ifdef ZLIB_DLL
-#    ifdef ZLIB_INTERNAL
-#      define ZEXPORT   __declspec(dllexport)
-#      define ZEXPORTVA __declspec(dllexport)
-#    else
-#      define ZEXPORT   __declspec(dllimport)
-#      define ZEXPORTVA __declspec(dllimport)
-#    endif
-#  endif
-#endif
-
-#ifndef ZEXTERN
-#  define ZEXTERN extern
-#endif
-#ifndef ZEXPORT
-#  define ZEXPORT
-#endif
-#ifndef ZEXPORTVA
-#  define ZEXPORTVA
-#endif
-
-#ifndef FAR
-#  define FAR
-#endif
-
-#if !defined(__MACTYPES__)
-typedef unsigned char  Byte;  /* 8 bits */
-#endif
-typedef unsigned int   uInt;  /* 16 bits or more */
-typedef unsigned long  uLong; /* 32 bits or more */
-
-#ifdef SMALL_MEDIUM
-   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
-#  define Bytef Byte FAR
-#else
-   typedef Byte  FAR Bytef;
-#endif
-typedef char  FAR charf;
-typedef int   FAR intf;
-typedef uInt  FAR uIntf;
-typedef uLong FAR uLongf;
-
-#ifdef STDC
-   typedef void const *voidpc;
-   typedef void FAR   *voidpf;
-   typedef void       *voidp;
-#else
-   typedef Byte const *voidpc;
-   typedef Byte FAR   *voidpf;
-   typedef Byte       *voidp;
-#endif
-
-#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
-#  include <limits.h>
-#  if (UINT_MAX == 0xffffffffUL)
-#    define Z_U4 unsigned
-#  elif (ULONG_MAX == 0xffffffffUL)
-#    define Z_U4 unsigned long
-#  elif (USHRT_MAX == 0xffffffffUL)
-#    define Z_U4 unsigned short
-#  endif
-#endif
-
-#ifdef Z_U4
-   typedef Z_U4 z_crc_t;
-#else
-   typedef unsigned long z_crc_t;
-#endif
-
-#ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
-#  define Z_HAVE_UNISTD_H
-#endif
-
-#ifdef HAVE_STDARG_H    /* may be set to #if 1 by ./configure */
-#  define Z_HAVE_STDARG_H
-#endif
-
-#ifdef STDC
-#  ifndef Z_SOLO
-#    include <sys/types.h>      /* for off_t */
-#  endif
-#endif
-
-#if defined(STDC) || defined(Z_HAVE_STDARG_H)
-#  ifndef Z_SOLO
-#    include <stdarg.h>         /* for va_list */
-#  endif
-#endif
-
-#ifdef _WIN32
-#  ifndef Z_SOLO
-#    include <stddef.h>         /* for wchar_t */
-#  endif
-#endif
-
-/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
- * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
- * though the former does not conform to the LFS document), but considering
- * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
- * equivalently requesting no 64-bit operations
- */
-#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
-#  undef _LARGEFILE64_SOURCE
-#endif
-
-#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
-#  define Z_HAVE_UNISTD_H
-#endif
-#ifndef Z_SOLO
-#  if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
-#    include <unistd.h>         /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
-#    ifdef VMS
-#      include <unixio.h>       /* for off_t */
-#    endif
-#    ifndef z_off_t
-#      define z_off_t off_t
-#    endif
-#  endif
-#endif
-
-#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
-#  define Z_LFS64
-#endif
-
-#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
-#  define Z_LARGE64
-#endif
-
-#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
-#  define Z_WANT64
-#endif
-
-#if !defined(SEEK_SET) && !defined(Z_SOLO)
-#  define SEEK_SET        0       /* Seek from beginning of file.  */
-#  define SEEK_CUR        1       /* Seek from current position.  */
-#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
-#endif
-
-#ifndef z_off_t
-#  define z_off_t long
-#endif
-
-#if !defined(_WIN32) && defined(Z_LARGE64)
-#  define z_off64_t off64_t
-#else
-#  if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
-#    define z_off64_t __int64
-#  else
-#    define z_off64_t z_off_t
-#  endif
-#endif
-
-/* MVS linker does not support external names larger than 8 bytes */
-#if defined(__MVS__)
-  #pragma map(deflateInit_,"DEIN")
-  #pragma map(deflateInit2_,"DEIN2")
-  #pragma map(deflateEnd,"DEEND")
-  #pragma map(deflateBound,"DEBND")
-  #pragma map(inflateInit_,"ININ")
-  #pragma map(inflateInit2_,"ININ2")
-  #pragma map(inflateEnd,"INEND")
-  #pragma map(inflateSync,"INSY")
-  #pragma map(inflateSetDictionary,"INSEDI")
-  #pragma map(compressBound,"CMBND")
-  #pragma map(inflate_table,"INTABL")
-  #pragma map(inflate_fast,"INFA")
-  #pragma map(inflate_copyright,"INCOPY")
-#endif
-
-#endif /* ZCONF_H */

3rdparty/zlib/cbits/zutil.c

@@ -1,324 +0,0 @@
-/* zutil.c -- target dependent utility functions for the compression library
- * Copyright (C) 1995-2005, 2010, 2011, 2012 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* @(#) $Id$ */
-
-#include "zutil.h"
-#ifndef Z_SOLO
-#  include "gzguts.h"
-#endif
-
-#ifndef NO_DUMMY_DECL
-struct internal_state      {int dummy;}; /* for buggy compilers */
-#endif
-
-z_const char * const z_errmsg[10] = {
-"need dictionary",     /* Z_NEED_DICT       2  */
-"stream end",          /* Z_STREAM_END      1  */
-"",                    /* Z_OK              0  */
-"file error",          /* Z_ERRNO         (-1) */
-"stream error",        /* Z_STREAM_ERROR  (-2) */
-"data error",          /* Z_DATA_ERROR    (-3) */
-"insufficient memory", /* Z_MEM_ERROR     (-4) */
-"buffer error",        /* Z_BUF_ERROR     (-5) */
-"incompatible version",/* Z_VERSION_ERROR (-6) */
-""};
-
-
-const char * ZEXPORT zlibVersion()
-{
-    return ZLIB_VERSION;
-}
-
-uLong ZEXPORT zlibCompileFlags()
-{
-    uLong flags;
-
-    flags = 0;
-    switch ((int)(sizeof(uInt))) {
-    case 2:     break;
-    case 4:     flags += 1;     break;
-    case 8:     flags += 2;     break;
-    default:    flags += 3;
-    }
-    switch ((int)(sizeof(uLong))) {
-    case 2:     break;
-    case 4:     flags += 1 << 2;        break;
-    case 8:     flags += 2 << 2;        break;
-    default:    flags += 3 << 2;
-    }
-    switch ((int)(sizeof(voidpf))) {
-    case 2:     break;
-    case 4:     flags += 1 << 4;        break;
-    case 8:     flags += 2 << 4;        break;
-    default:    flags += 3 << 4;
-    }
-    switch ((int)(sizeof(z_off_t))) {
-    case 2:     break;
-    case 4:     flags += 1 << 6;        break;
-    case 8:     flags += 2 << 6;        break;
-    default:    flags += 3 << 6;
-    }
-#ifdef DEBUG
-    flags += 1 << 8;
-#endif
-#if defined(ASMV) || defined(ASMINF)
-    flags += 1 << 9;
-#endif
-#ifdef ZLIB_WINAPI
-    flags += 1 << 10;
-#endif
-#ifdef BUILDFIXED
-    flags += 1 << 12;
-#endif
-#ifdef DYNAMIC_CRC_TABLE
-    flags += 1 << 13;
-#endif
-#ifdef NO_GZCOMPRESS
-    flags += 1L << 16;
-#endif
-#ifdef NO_GZIP
-    flags += 1L << 17;
-#endif
-#ifdef PKZIP_BUG_WORKAROUND
-    flags += 1L << 20;
-#endif
-#ifdef FASTEST
-    flags += 1L << 21;
-#endif
-#if defined(STDC) || defined(Z_HAVE_STDARG_H)
-#  ifdef NO_vsnprintf
-    flags += 1L << 25;
-#    ifdef HAS_vsprintf_void
-    flags += 1L << 26;
-#    endif
-#  else
-#    ifdef HAS_vsnprintf_void
-    flags += 1L << 26;
-#    endif
-#  endif
-#else
-    flags += 1L << 24;
-#  ifdef NO_snprintf
-    flags += 1L << 25;
-#    ifdef HAS_sprintf_void
-    flags += 1L << 26;
-#    endif
-#  else
-#    ifdef HAS_snprintf_void
-    flags += 1L << 26;
-#    endif
-#  endif
-#endif
-    return flags;
-}
-
-#ifdef DEBUG
-
-#  ifndef verbose
-#    define verbose 0
-#  endif
-int ZLIB_INTERNAL z_verbose = verbose;
-
-void ZLIB_INTERNAL z_error (m)
-    char *m;
-{
-    fprintf(stderr, "%s\n", m);
-    exit(1);
-}
-#endif
-
-/* exported to allow conversion of error code to string for compress() and
- * uncompress()
- */
-const char * ZEXPORT zError(err)
-    int err;
-{
-    return ERR_MSG(err);
-}
-
-#if defined(_WIN32_WCE)
-    /* The Microsoft C Run-Time Library for Windows CE doesn't have
-     * errno.  We define it as a global variable to simplify porting.
-     * Its value is always 0 and should not be used.
-     */
-    int errno = 0;
-#endif
-
-#ifndef HAVE_MEMCPY
-
-void ZLIB_INTERNAL zmemcpy(dest, source, len)
-    Bytef* dest;
-    const Bytef* source;
-    uInt  len;
-{
-    if (len == 0) return;
-    do {
-        *dest++ = *source++; /* ??? to be unrolled */
-    } while (--len != 0);
-}
-
-int ZLIB_INTERNAL zmemcmp(s1, s2, len)
-    const Bytef* s1;
-    const Bytef* s2;
-    uInt  len;
-{
-    uInt j;
-
-    for (j = 0; j < len; j++) {
-        if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
-    }
-    return 0;
-}
-
-void ZLIB_INTERNAL zmemzero(dest, len)
-    Bytef* dest;
-    uInt  len;
-{
-    if (len == 0) return;
-    do {
-        *dest++ = 0;  /* ??? to be unrolled */
-    } while (--len != 0);
-}
-#endif
-
-#ifndef Z_SOLO
-
-#ifdef SYS16BIT
-
-#ifdef __TURBOC__
-/* Turbo C in 16-bit mode */
-
-#  define MY_ZCALLOC
-
-/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
- * and farmalloc(64K) returns a pointer with an offset of 8, so we
- * must fix the pointer. Warning: the pointer must be put back to its
- * original form in order to free it, use zcfree().
- */
-
-#define MAX_PTR 10
-/* 10*64K = 640K */
-
-local int next_ptr = 0;
-
-typedef struct ptr_table_s {
-    voidpf org_ptr;
-    voidpf new_ptr;
-} ptr_table;
-
-local ptr_table table[MAX_PTR];
-/* This table is used to remember the original form of pointers
- * to large buffers (64K). Such pointers are normalized with a zero offset.
- * Since MSDOS is not a preemptive multitasking OS, this table is not
- * protected from concurrent access. This hack doesn't work anyway on
- * a protected system like OS/2. Use Microsoft C instead.
- */
-
-voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
-{
-    voidpf buf = opaque; /* just to make some compilers happy */
-    ulg bsize = (ulg)items*size;
-
-    /* If we allocate less than 65520 bytes, we assume that farmalloc
-     * will return a usable pointer which doesn't have to be normalized.
-     */
-    if (bsize < 65520L) {
-        buf = farmalloc(bsize);
-        if (*(ush*)&buf != 0) return buf;
-    } else {
-        buf = farmalloc(bsize + 16L);
-    }
-    if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
-    table[next_ptr].org_ptr = buf;
-
-    /* Normalize the pointer to seg:0 */
-    *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
-    *(ush*)&buf = 0;
-    table[next_ptr++].new_ptr = buf;
-    return buf;
-}
-
-void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
-{
-    int n;
-    if (*(ush*)&ptr != 0) { /* object < 64K */
-        farfree(ptr);
-        return;
-    }
-    /* Find the original pointer */
-    for (n = 0; n < next_ptr; n++) {
-        if (ptr != table[n].new_ptr) continue;
-
-        farfree(table[n].org_ptr);
-        while (++n < next_ptr) {
-            table[n-1] = table[n];
-        }
-        next_ptr--;
-        return;
-    }
-    ptr = opaque; /* just to make some compilers happy */
-    Assert(0, "zcfree: ptr not found");
-}
-
-#endif /* __TURBOC__ */
-
-
-#ifdef M_I86
-/* Microsoft C in 16-bit mode */
-
-#  define MY_ZCALLOC
-
-#if (!defined(_MSC_VER) || (_MSC_VER <= 600))
-#  define _halloc  halloc
-#  define _hfree   hfree
-#endif
-
-voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
-{
-    if (opaque) opaque = 0; /* to make compiler happy */
-    return _halloc((long)items, size);
-}
-
-void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
-{
-    if (opaque) opaque = 0; /* to make compiler happy */
-    _hfree(ptr);
-}
-
-#endif /* M_I86 */
-
-#endif /* SYS16BIT */
-
-
-#ifndef MY_ZCALLOC /* Any system without a special alloc function */
-
-#ifndef STDC
-extern voidp  malloc OF((uInt size));
-extern voidp  calloc OF((uInt items, uInt size));
-extern void   free   OF((voidpf ptr));
-#endif
-
-voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
-    voidpf opaque;
-    unsigned items;
-    unsigned size;
-{
-    if (opaque) items += size - size; /* make compiler happy */
-    return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
-                              (voidpf)calloc(items, size);
-}
-
-void ZLIB_INTERNAL zcfree (opaque, ptr)
-    voidpf opaque;
-    voidpf ptr;
-{
-    free(ptr);
-    if (opaque) return; /* make compiler happy */
-}
-
-#endif /* MY_ZCALLOC */
-
-#endif /* !Z_SOLO */

3rdparty/zlib/cbits/zutil.h

@@ -1,253 +0,0 @@
-/* zutil.h -- internal interface and configuration of the compression library
- * Copyright (C) 1995-2013 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* WARNING: this file should *not* be used by applications. It is
-   part of the implementation of the compression library and is
-   subject to change. Applications should only use zlib.h.
- */
-
-/* @(#) $Id$ */
-
-#ifndef ZUTIL_H
-#define ZUTIL_H
-
-#ifdef HAVE_HIDDEN
-#  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
-#else
-#  define ZLIB_INTERNAL
-#endif
-
-#include "zlib.h"
-
-#if defined(STDC) && !defined(Z_SOLO)
-#  if !(defined(_WIN32_WCE) && defined(_MSC_VER))
-#    include <stddef.h>
-#  endif
-#  include <string.h>
-#  include <stdlib.h>
-#endif
-
-#ifdef Z_SOLO
-   typedef long ptrdiff_t;  /* guess -- will be caught if guess is wrong */
-#endif
-
-#ifndef local
-#  define local static
-#endif
-/* compile with -Dlocal if your debugger can't find static symbols */
-
-typedef unsigned char  uch;
-typedef uch FAR uchf;
-typedef unsigned short ush;
-typedef ush FAR ushf;
-typedef unsigned long  ulg;
-
-extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
-/* (size given to avoid silly warnings with Visual C++) */
-
-#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
-
-#define ERR_RETURN(strm,err) \
-  return (strm->msg = ERR_MSG(err), (err))
-/* To be used only when the state is known to be valid */
-
-        /* common constants */
-
-#ifndef DEF_WBITS
-#  define DEF_WBITS MAX_WBITS
-#endif
-/* default windowBits for decompression. MAX_WBITS is for compression only */
-
-#if MAX_MEM_LEVEL >= 8
-#  define DEF_MEM_LEVEL 8
-#else
-#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
-#endif
-/* default memLevel */
-
-#define STORED_BLOCK 0
-#define STATIC_TREES 1
-#define DYN_TREES    2
-/* The three kinds of block type */
-
-#define MIN_MATCH  3
-#define MAX_MATCH  258
-/* The minimum and maximum match lengths */
-
-#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
-
-        /* target dependencies */
-
-#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))
-#  define OS_CODE  0x00
-#  ifndef Z_SOLO
-#    if defined(__TURBOC__) || defined(__BORLANDC__)
-#      if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
-         /* Allow compilation with ANSI keywords only enabled */
-         void _Cdecl farfree( void *block );
-         void *_Cdecl farmalloc( unsigned long nbytes );
-#      else
-#        include <alloc.h>
-#      endif
-#    else /* MSC or DJGPP */
-#      include <malloc.h>
-#    endif
-#  endif
-#endif
-
-#ifdef AMIGA
-#  define OS_CODE  0x01
-#endif
-
-#if defined(VAXC) || defined(VMS)
-#  define OS_CODE  0x02
-#  define F_OPEN(name, mode) \
-     fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
-#endif
-
-#if defined(ATARI) || defined(atarist)
-#  define OS_CODE  0x05
-#endif
-
-#ifdef OS2
-#  define OS_CODE  0x06
-#  if defined(M_I86) && !defined(Z_SOLO)
-#    include <malloc.h>
-#  endif
-#endif
-
-#if defined(MACOS) || defined(TARGET_OS_MAC)
-#  define OS_CODE  0x07
-#  ifndef Z_SOLO
-#    if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
-#      include <unix.h> /* for fdopen */
-#    else
-#      ifndef fdopen
-#        define fdopen(fd,mode) NULL /* No fdopen() */
-#      endif
-#    endif
-#  endif
-#endif
-
-#ifdef TOPS20
-#  define OS_CODE  0x0a
-#endif
-
-#ifdef WIN32
-#  ifndef __CYGWIN__  /* Cygwin is Unix, not Win32 */
-#    define OS_CODE  0x0b
-#  endif
-#endif
-
-#ifdef __50SERIES /* Prime/PRIMOS */
-#  define OS_CODE  0x0f
-#endif
-
-#if defined(_BEOS_) || defined(RISCOS)
-#  define fdopen(fd,mode) NULL /* No fdopen() */
-#endif
-
-#if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX
-#  if defined(_WIN32_WCE)
-#    define fdopen(fd,mode) NULL /* No fdopen() */
-#    ifndef _PTRDIFF_T_DEFINED
-       typedef int ptrdiff_t;
-#      define _PTRDIFF_T_DEFINED
-#    endif
-#  else
-#    define fdopen(fd,type)  _fdopen(fd,type)
-#  endif
-#endif
-
-#if defined(__BORLANDC__) && !defined(MSDOS)
-  #pragma warn -8004
-  #pragma warn -8008
-  #pragma warn -8066
-#endif
-
-/* provide prototypes for these when building zlib without LFS */
-#if !defined(_WIN32) && \
-    (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0)
-    ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
-    ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
-#endif
-
-        /* common defaults */
-
-#ifndef OS_CODE
-#  define OS_CODE  0x03  /* assume Unix */
-#endif
-
-#ifndef F_OPEN
-#  define F_OPEN(name, mode) fopen((name), (mode))
-#endif
-
-         /* functions */
-
-#if defined(pyr) || defined(Z_SOLO)
-#  define NO_MEMCPY
-#endif
-#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
- /* Use our own functions for small and medium model with MSC <= 5.0.
-  * You may have to use the same strategy for Borland C (untested).
-  * The __SC__ check is for Symantec.
-  */
-#  define NO_MEMCPY
-#endif
-#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
-#  define HAVE_MEMCPY
-#endif
-#ifdef HAVE_MEMCPY
-#  ifdef SMALL_MEDIUM /* MSDOS small or medium model */
-#    define zmemcpy _fmemcpy
-#    define zmemcmp _fmemcmp
-#    define zmemzero(dest, len) _fmemset(dest, 0, len)
-#  else
-#    define zmemcpy memcpy
-#    define zmemcmp memcmp
-#    define zmemzero(dest, len) memset(dest, 0, len)
-#  endif
-#else
-   void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len));
-   int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len));
-   void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len));
-#endif
-
-/* Diagnostic functions */
-#ifdef DEBUG
-#  include <stdio.h>
-   extern int ZLIB_INTERNAL z_verbose;
-   extern void ZLIB_INTERNAL z_error OF((char *m));
-#  define Assert(cond,msg) {if(!(cond)) z_error(msg);}
-#  define Trace(x) {if (z_verbose>=0) fprintf x ;}
-#  define Tracev(x) {if (z_verbose>0) fprintf x ;}
-#  define Tracevv(x) {if (z_verbose>1) fprintf x ;}
-#  define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}
-#  define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}
-#else
-#  define Assert(cond,msg)
-#  define Trace(x)
-#  define Tracev(x)
-#  define Tracevv(x)
-#  define Tracec(c,x)
-#  define Tracecv(c,x)
-#endif
-
-#ifndef Z_SOLO
-   voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items,
-                                    unsigned size));
-   void ZLIB_INTERNAL zcfree  OF((voidpf opaque, voidpf ptr));
-#endif
-
-#define ZALLOC(strm, items, size) \
-           (*((strm)->zalloc))((strm)->opaque, (items), (size))
-#define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
-#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
-
-/* Reverse the bytes in a 32-bit value */
-#define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
-                    (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
-
-#endif /* ZUTIL_H */

3rdparty/zlib/changelog

@@ -1,56 +0,0 @@
-See also http://pvp.haskell.org/faq
-
-0.6.2.1 Herbert Valerio Riedel <hvr@gnu.org> August 2019
-
- * Add support for GHC 8.8 / base-4.13
-
-0.6.2 Herbert Valerio Riedel <hvr@gnu.org> March 2018
-
- * New cabal flag 'pkg-config' for discovering 'zlib` via pkg-config(1) (#16)
- * Use CApiFFI where available for cross-compile friendliness (#14)
- * Change the window bits range from 8..15 to 9..15 (#11)
-
-0.6.1.2 Herbert Valerio Riedel <hvr@gnu.org> October 2016
-
- * Fix a segfault when reading the stream multithreaded, #7
- * New experimental cabal flag 'non-blocking-ffi' for 'safe' ffi calls
-
-0.6.1.1 Duncan Coutts <duncan@community.haskell.org> April 2015
-
- * Fixed building with GHC 7.0 and 7.2
-
-0.6.0.2 Duncan Coutts <duncan@community.haskell.org> April 2015
-
- * Fixed building with GHC 7.0 and 7.2
-
-0.6.1.0 Duncan Coutts <duncan@community.haskell.org> April 2015
-
- * Support for concatenated gzip files (multiple back-to-back streams)
-
-0.6.0.1 Duncan Coutts <duncan@community.haskell.org> April 2015
-
- * Fixed building with older GHC
- * Fixed warnings with new GHC
- * Fixed building on Windows
- * Fixed testsuite
-
-0.6.0.0 Duncan Coutts <duncan@community.haskell.org> April 2015
-
- * New incremental interface for compression and decompression
- * Provide access to unconsumed trailing data
- * Simplified structured error type, and instance of Exception
- * Updated bundled zlib C code to 1.2.8 (used on Windows)
- * Fixed memory leak of zlib z_stream C structure
- * More derivied instances (Eq, Show, Typeable, Generic)
-
-0.5.4.2 Duncan Coutts <duncan@community.haskell.org> November 2014
-
- * Builds with GHC 7.10
-
-0.5.4.1 Duncan Coutts <duncan@community.haskell.org> February 2013
-
- * Force tail of input when finished decompressing, to help lazy IO
-
-0.5.4.0 Duncan Coutts <duncan@community.haskell.org> September 2012
-
- * New support for zlib custom dictionaries

3rdparty/zlib/examples/gunzip.hs

@@ -1,6 +0,0 @@
-module Main where
-
-import qualified Data.ByteString.Lazy as B
-import qualified Codec.Compression.GZip as GZip
-
-main = B.interact GZip.decompress

3rdparty/zlib/examples/gzip.hs

@@ -1,8 +0,0 @@
-module Main where
-
-import qualified Data.ByteString.Lazy as B
-import qualified Codec.Compression.GZip as GZip
-
-main = B.interact $ GZip.compressWith GZip.defaultCompressParams {
-                      GZip.compressLevel = GZip.BestCompression
-                    }

3rdparty/zlib/examples/zpipe.hs

@@ -1,13 +0,0 @@
-module Main where
-
-import System.Environment
-
-import qualified Data.ByteString.Lazy as B
-import qualified Codec.Compression.Zlib as Zlib
-
-main = do args <- getArgs
-          case args of
-           [] -> B.interact Zlib.compress
-           ["-d"] -> B.interact Zlib.decompress
-           _ -> do name <- getProgName
-                   error $ "usage: " ++ name ++ " [-d] < source > dest"

3rdparty/zlib/test/Makefile

@@ -1,45 +0,0 @@
-HSC=ghc
-CC=gcc # can also use $(HSC)
-
-UNCOMPRESSED=`find .. -type f`
-GZIPPED=`find .. -type f -name \*.gz`
-
-HSC_OPTS=-hide-package zlib -i
-
-HSBINS=hszpipe hsgzip hsgunzip test-hs
-BINS=$(HSBINS) zpipe
-
-ALL:
-
-clean:
-	rm -f $(BINS) *.o *.hi
-
-bins: hszpipe zpipe hsgzip hsgunzip
-
-%.hs : %.hsc
-	hsc2hs --cc=$(HSC) --ld=$(HSC) --lflag=-lz -o $@ $<
-
-hs%: ../examples/%.hs
-	$(HSC) $(HSC_OPTS) -lz -i.. -o $@ --make $<
-
-$(HSBINS) : ../Codec/Compression/Zlib/Stream.hs
-
-test-hs: Test.hs
-	$(HSC) $(HSC_OPTS) -Wall -lz -i. -i.. -o $@ --make $<
-
-zpipe: zpipe.c
-	$(CC) -lz -o zpipe zpipe.c
-
-test: run-test-hs run-test-sh-zpipe run-test-sh-gzip run-test-sh-gunzip
-
-run-test-hs: test-hs
-	./test-hs
-
-run-test-sh-zpipe: zpipe hszpipe
-	./zpipe-compress.sh $(UNCOMPRESSED)
-
-run-test-sh-gzip: hsgzip hsgunzip
-	./gzip-compress.sh $(UNCOMPRESSED)
-
-run-test-sh-gunzip: hsgunzip
-	./gzip-uncompress.sh $(GZIPPED)

3rdparty/zlib/test/Test.hs

@@ -1,338 +0,0 @@
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE RankNTypes #-}
-module Main where
-
-import Codec.Compression.Zlib.Internal
-import qualified Codec.Compression.Zlib     as Zlib
-import qualified Codec.Compression.GZip     as GZip
-import qualified Codec.Compression.Zlib.Raw as Raw
-
-import Test.Codec.Compression.Zlib.Internal ()
-import Test.Codec.Compression.Zlib.Stream ()
-
-import Test.QuickCheck
-import Test.Tasty
-import Test.Tasty.QuickCheck
-import Test.Tasty.HUnit
-import Utils ()
-
-import Control.Monad
-import Control.Monad.ST.Lazy (ST)
-import Control.Exception
-import qualified Data.ByteString.Char8 as BS.Char8
-import qualified Data.ByteString.Lazy as BL
-import qualified Data.ByteString      as BS
-import System.IO
-#if !(MIN_VERSION_base(4,6,0))
-import Prelude hiding (catch)
-#endif
-
-
-main :: IO ()
-main = defaultMain $
-  testGroup "zlib tests" [
-    testGroup "property tests" [
-      testProperty "decompress . compress = id (standard)"           prop_decompress_after_compress,
-      testProperty "decompress . compress = id (Zlib -> GZipOrZLib)" prop_gziporzlib1,
-      testProperty "decompress . compress = id (GZip -> GZipOrZlib)" prop_gziporzlib2,
-      testProperty "concatenated gzip members"                       prop_gzip_concat,
-      testProperty "multiple gzip members, boundaries (all 2-chunks)" prop_multiple_members_boundary2,
-      testProperty "multiple gzip members, boundaries (all 3-chunks)" prop_multiple_members_boundary3,
-      testProperty "prefixes of valid stream detected as truncated"  prop_truncated
-    ],
-    testGroup "unit tests" [
-      testCase "simple gzip case"          test_simple_gzip,
-      testCase "detect bad crc"            test_bad_crc,
-      testCase "detect non-gzip"           test_non_gzip,
-      testCase "detect custom dictionary"  test_custom_dict,
-      testCase "dectect inflate with wrong dict"   test_wrong_dictionary,
-      testCase "dectect inflate with right dict"   test_right_dictionary,
-      testCase "handle trailing data"      test_trailing_data,
-      testCase "multiple gzip members"     test_multiple_members,
-      testCase "check small input chunks"  test_small_chunks,
-      testCase "check empty input"         test_empty,
-      testCase "check exception raised"    test_exception
-    ]
-  ]
-
-
-prop_decompress_after_compress :: Format
-                               -> CompressParams
-                               -> DecompressParams
-                               -> Property
-prop_decompress_after_compress w cp dp =
-   (w /= zlibFormat || decompressWindowBits dp >= compressWindowBits cp) &&
-   (decompressWindowBits dp > compressWindowBits cp) &&
-   decompressBufferSize dp > 0 && compressBufferSize cp > 0 ==>
-   liftM2 (==) (decompress w dp . compress w cp) id
-
-
-prop_gziporzlib1 :: CompressParams
-                 -> DecompressParams
-                 -> Property
-prop_gziporzlib1 cp dp =
-   decompressWindowBits dp > compressWindowBits cp &&
-   decompressBufferSize dp > 0 && compressBufferSize cp > 0 ==>
-   liftM2 (==) (decompress gzipOrZlibFormat dp . compress zlibFormat cp) id
-
-
-prop_gziporzlib2 :: CompressParams
-                 -> DecompressParams
-                 -> Property
-prop_gziporzlib2 cp dp =
-   decompressWindowBits dp >= compressWindowBits cp &&
-   decompressBufferSize dp > 0 && compressBufferSize cp > 0 ==>
-   liftM2 (==) (decompress gzipOrZlibFormat dp . compress gzipFormat cp) id
-
-prop_gzip_concat :: CompressParams
-                 -> DecompressParams
-                 -> BL.ByteString
-                 -> Property
-prop_gzip_concat cp dp input =
-   decompressWindowBits dp >= compressWindowBits cp &&
-   decompressBufferSize dp > 0 && compressBufferSize cp > 0 ==>
-   let catComp = BL.concat (replicate 5 (compress gzipFormat cp input))
-       compCat = compress gzipFormat cp (BL.concat (replicate 5 input))
-
-    in decompress gzipFormat dp { decompressAllMembers = True } catComp
-    == decompress gzipFormat dp { decompressAllMembers = True } compCat
-
-prop_multiple_members_boundary2 :: Property
-prop_multiple_members_boundary2 =
-    forAll shortStrings $ \bs ->
-      all (\c -> decomp c == BL.append bs bs)
-          (twoChunkSplits (comp bs `BL.append` comp bs))
-  where
-    comp   = compress gzipFormat defaultCompressParams
-    decomp = decompress gzipFormat defaultDecompressParams
-
-    shortStrings = fmap BL.pack $ listOf arbitrary
-
-prop_multiple_members_boundary3 :: Property
-prop_multiple_members_boundary3 =
-    forAll shortStrings $ \bs ->
-      all (\c -> decomp c == BL.append bs bs)
-          (threeChunkSplits (comp bs `BL.append` comp bs))
-  where
-    comp   = compress gzipFormat defaultCompressParams
-    decomp = decompress gzipFormat defaultDecompressParams
-
-    shortStrings = sized $ \sz -> resize (sz `div` 10) $
-                   fmap BL.pack $ listOf arbitrary
-
-prop_truncated :: Format -> Property
-prop_truncated format =
-   forAll shortStrings $ \bs ->
-     all (truncated decomp)
-         (init (BL.inits (comp bs)))
-  -- All the initial prefixes of a valid compressed stream should be detected
-  -- as truncated.
-  where
-    comp   = compress format defaultCompressParams
-    decomp = decompressST format defaultDecompressParams
-    truncated :: (forall s. DecompressStream (ST s)) -> BL.ByteString -> Bool
-    truncated = foldDecompressStreamWithInput (\_ r -> r) (\_ -> False)
-                  (\err -> case err of TruncatedInput -> True; _ -> False)
-
-    shortStrings = sized $ \sz -> resize (sz `div` 6) arbitrary
-
-
-test_simple_gzip :: Assertion
-test_simple_gzip =
-  withSampleData "hello.gz" $ \hnd ->
-    let decomp = decompressIO gzipFormat defaultDecompressParams
-     in assertDecompressOk hnd decomp
-
-test_bad_crc :: Assertion
-test_bad_crc =
-  withSampleData "bad-crc.gz" $ \hnd -> do
-    let decomp = decompressIO gzipFormat defaultDecompressParams
-    err <- assertDecompressError hnd decomp
-    msg <- assertDataFormatError err
-    msg @?= "incorrect data check"
-
-test_non_gzip :: Assertion
-test_non_gzip = do
-  withSampleData "not-gzip" $ \hnd -> do
-    let decomp = decompressIO gzipFormat defaultDecompressParams
-    err <- assertDecompressError hnd decomp
-    msg <- assertDataFormatError err
-    msg @?= "incorrect header check"
-
-  withSampleData "not-gzip" $ \hnd -> do
-    let decomp = decompressIO zlibFormat defaultDecompressParams
-    err <- assertDecompressError hnd decomp
-    msg <- assertDataFormatError err
-    msg @?= "incorrect header check"
-
-  withSampleData "not-gzip" $ \hnd -> do
-    let decomp = decompressIO rawFormat defaultDecompressParams
-    err <- assertDecompressError hnd decomp
-    msg <- assertDataFormatError err
-    msg @?= "invalid code lengths set"
-
-  withSampleData "not-gzip" $ \hnd -> do
-    let decomp = decompressIO gzipOrZlibFormat defaultDecompressParams
-    err <- assertDecompressError hnd decomp
-    msg <- assertDataFormatError err
-    msg @?= "incorrect header check"
-
-test_custom_dict :: Assertion
-test_custom_dict =
-  withSampleData "custom-dict.zlib" $ \hnd -> do
-    let decomp = decompressIO zlibFormat defaultDecompressParams
-    err <- assertDecompressError hnd decomp
-    err @?= DictionaryRequired
-
-test_wrong_dictionary :: Assertion
-test_wrong_dictionary = do
-  withSampleData "custom-dict.zlib" $ \hnd -> do
-    let decomp = decompressIO zlibFormat defaultDecompressParams {
-                                           decompressDictionary = -- wrong dict!
-                                             Just (BS.pack [65,66,67])
-                                         }
-
-    err <- assertDecompressError hnd decomp
-    err @?= DictionaryMismatch
-
-test_right_dictionary :: Assertion
-test_right_dictionary = do
-  withSampleData "custom-dict.zlib" $ \hnd -> do
-    dict <- readSampleData "custom-dict.zlib-dict"
-    let decomp = decompressIO zlibFormat defaultDecompressParams {
-                                           decompressDictionary =
-                                             Just (toStrict dict)
-                                         }
-    assertDecompressOk hnd decomp
-
-test_trailing_data :: Assertion
-test_trailing_data =
-  withSampleData "two-files.gz" $ \hnd -> do
-    let decomp = decompressIO gzipFormat defaultDecompressParams {
-                   decompressAllMembers = False
-                 }
-    chunks <- assertDecompressOkChunks hnd decomp
-    case chunks of
-      [chunk] -> chunk @?= BS.Char8.pack "Test 1"
-      _       -> assertFailure "expected single chunk"
-
-test_multiple_members :: Assertion
-test_multiple_members =
-  withSampleData "two-files.gz" $ \hnd -> do
-    let decomp = decompressIO gzipFormat defaultDecompressParams {
-                   decompressAllMembers = True
-                 }
-    chunks <- assertDecompressOkChunks hnd decomp
-    case chunks of
-      [chunk1,
-       chunk2] -> do chunk1 @?= BS.Char8.pack "Test 1"
-                     chunk2 @?= BS.Char8.pack "Test 2"
-      _       -> assertFailure "expected two chunks"
-
-test_small_chunks :: Assertion
-test_small_chunks = do
-  uncompressedFile <- readSampleData "not-gzip"
-  GZip.compress (smallChunks uncompressedFile) @?= GZip.compress uncompressedFile
-  Zlib.compress (smallChunks uncompressedFile) @?= Zlib.compress uncompressedFile
-  Raw.compress  (smallChunks uncompressedFile) @?= Raw.compress uncompressedFile
-
-  GZip.decompress (smallChunks (GZip.compress uncompressedFile)) @?= uncompressedFile
-  Zlib.decompress (smallChunks (Zlib.compress uncompressedFile)) @?= uncompressedFile
-  Raw.decompress  (smallChunks (Raw.compress  uncompressedFile)) @?= uncompressedFile
-
-  compressedFile   <- readSampleData "hello.gz"
-  (GZip.decompress . smallChunks) compressedFile @?= GZip.decompress compressedFile
-
-test_empty :: Assertion
-test_empty = do
-  -- Regression test to make sure we only ask for input once in the case of
-  -- initially empty input. We previously asked for input twice before
-  -- returning the error.
-  let decomp = decompressIO zlibFormat defaultDecompressParams
-  case decomp of
-    DecompressInputRequired next -> do
-      decomp' <- next BS.empty
-      case decomp' of
-        DecompressStreamError TruncatedInput -> return ()
-        _ -> assertFailure "expected truncated error"
-
-    _ -> assertFailure "expected input"
-
-test_exception :: Assertion
-test_exception =
- (do
-    compressedFile <- readSampleData "bad-crc.gz"
-    _ <- evaluate (BL.length (GZip.decompress compressedFile))
-    assertFailure "expected exception")
-
-  `catch` \err -> do
-      msg <- assertDataFormatError err
-      msg @?= "incorrect data check"
-
-toStrict :: BL.ByteString -> BS.ByteString
-#if MIN_VERSION_bytestring(0,10,0)
-toStrict = BL.toStrict
-#else
-toStrict = BS.concat . BL.toChunks
-#endif
-
------------------------
--- Chunk boundary utils
-
-smallChunks :: BL.ByteString -> BL.ByteString
-smallChunks = BL.fromChunks . map (\c -> BS.pack [c]) . BL.unpack
-
-twoChunkSplits :: BL.ByteString -> [BL.ByteString]
-twoChunkSplits bs = zipWith (\a b -> BL.fromChunks [a,b]) (BS.inits sbs) (BS.tails sbs)
-  where
-    sbs = toStrict bs
-
-threeChunkSplits :: BL.ByteString -> [BL.ByteString]
-threeChunkSplits bs =
-    [ BL.fromChunks [a,b,c]
-    | (a,x) <- zip (BS.inits sbs) (BS.tails sbs)
-    , (b,c) <- zip (BS.inits x) (BS.tails x) ]
-  where
-    sbs = toStrict bs
-
---------------
--- HUnit Utils
-
-readSampleData :: FilePath -> IO BL.ByteString
-readSampleData file = BL.readFile ("test/data/" ++ file)
-
-withSampleData :: FilePath -> (Handle -> IO a) -> IO a
-withSampleData file = withFile ("test/data/" ++ file) ReadMode
-
-expected :: String -> String -> IO a
-expected e g = assertFailure ("expected: " ++ e ++ "\nbut got: " ++ g)
-            >> fail ""
-
-assertDecompressOk :: Handle -> DecompressStream IO -> Assertion
-assertDecompressOk hnd =
-    foldDecompressStream
-      (BS.hGet hnd 4000 >>=)
-      (\_ r -> r)
-      (\_ -> return ())
-      (\err -> expected "decompress ok" (show err))
-
-assertDecompressOkChunks :: Handle -> DecompressStream IO -> IO [BS.ByteString]
-assertDecompressOkChunks hnd =
-    foldDecompressStream
-      (BS.hGet hnd 4000 >>=)
-      (\chunk -> liftM (chunk:))
-      (\_ -> return [])
-      (\err -> expected "decompress ok" (show err))
-
-assertDecompressError :: Handle -> DecompressStream IO -> IO DecompressError
-assertDecompressError hnd =
-    foldDecompressStream
-      (BS.hGet hnd 4000 >>=)
-      (\_ r -> r)
-      (\_ -> expected "StreamError" "StreamEnd")
-      return
-
-assertDataFormatError :: DecompressError -> IO String
-assertDataFormatError (DataFormatError detail) = return detail
-assertDataFormatError _                        = assertFailure "expected DataError"
-                                              >> return ""

3rdparty/zlib/test/Test/Codec/Compression/Zlib/Internal.hs

@@ -1,32 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-
--- | Test code and properties for "Codec.Compression.Zlib.Internal"
---
-module Test.Codec.Compression.Zlib.Internal where
-
-import Codec.Compression.Zlib.Internal
-import Test.Codec.Compression.Zlib.Stream ()
-import Test.QuickCheck
-
-import Control.Monad (ap)
-
-
-instance Arbitrary CompressParams where
-  arbitrary = return CompressParams `ap` arbitrary `ap` arbitrary
-                                    `ap` arbitrary `ap` arbitrary
-                                    `ap` arbitrary `ap` arbitraryBufferSize
-                                    `ap` return Nothing
-
-arbitraryBufferSize :: Gen Int
-arbitraryBufferSize = frequency $ [(10, return n) | n <- [1..1024]] ++
-                                  [(20, return n) | n <- [1025..8192]] ++
-                                  [(40, return n) | n <- [8193..131072]] ++
-                                  [(1, return n) | n <- [131072..1048576]]
-
-
-instance Arbitrary DecompressParams where
-  arbitrary = return DecompressParams `ap` arbitrary
-                                      `ap` arbitraryBufferSize
-                                      `ap` return Nothing
-                                      `ap` arbitrary
-

3rdparty/zlib/test/Test/Codec/Compression/Zlib/Stream.hs

@@ -1,40 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-
--- | Test code and properties for "Codec.Compression.Zlib.Stream"
---
-module Test.Codec.Compression.Zlib.Stream where
-
-import Codec.Compression.Zlib.Internal
-import Test.QuickCheck
-
-
-instance Arbitrary Format where
-  -- GZipOrZlib omitted since it's not symmetric
-  arbitrary = elements [gzipFormat, zlibFormat, rawFormat]
-
-
-instance Arbitrary Method where
-   arbitrary = return deflateMethod
-
-
-instance Arbitrary CompressionLevel where
-  arbitrary = elements $ [defaultCompression, noCompression,
-                          bestCompression, bestSpeed]
-                      ++ map compressionLevel [1..9]
-
-
-instance Arbitrary WindowBits where
-  arbitrary = elements $ defaultWindowBits:map windowBits [9..15]
-
-
-instance Arbitrary MemoryLevel where
-  arbitrary = elements $ [defaultMemoryLevel, minMemoryLevel, maxMemoryLevel]
-                      ++ [memoryLevel n | n <- [1..9]]
-
-
-
-instance Arbitrary CompressionStrategy where
-  arbitrary = elements $ [defaultStrategy, filteredStrategy, huffmanOnlyStrategy]
-                   -- These are disabled by default in the package
-                   -- as they are only available with zlib >=1.2
-                   -- ++ [RLE, Fixed]

3rdparty/zlib/test/Utils.hs

@@ -1,28 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-module Utils where
-
-import qualified Data.ByteString.Lazy as BL
-import qualified Data.ByteString      as BS
-
-import Test.QuickCheck
-
--------------------
--- QuickCheck Utils
-
-maxStrSize :: Double
-maxStrSize = 500
-
--- convert a QC size parameter into one for generating long lists,
--- growing inverse exponentially up to maxStrSize
-strSize :: Int -> Int
-strSize n = floor (maxStrSize * (1 - 2 ** (-fromIntegral n/100)))
-
-instance Arbitrary BL.ByteString where
-  arbitrary = sized $ \sz -> fmap BL.fromChunks $ listOf $ resize (sz `div` 2) arbitrary
-  shrink = map BL.pack . shrink . BL.unpack
-
-instance Arbitrary BS.ByteString where
-  arbitrary = sized $ \sz -> resize (strSize sz) $ fmap BS.pack $ listOf $ arbitrary
-  shrink = map BS.pack . shrink . BS.unpack
-
-

3rdparty/zlib/test/data/custom-dict.zlib-dict

@@ -1 +0,0 @@
-Haskell

3rdparty/zlib/test/data/not-gzip

@@ -1 +0,0 @@
-This is not a gzip file!

3rdparty/zlib/test/gzip-compress.sh

@@ -1,14 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-for d in $*; do
-   # they don't actually produce the same output
-   # cmp <(./hsgzip < $d) <(gzip -c < $d)
-   cmp $d <(gzip -c < $d | gunzip -c) # just in case..
-   cmp $d <(gzip -c < $d | ./hsgunzip )
-   cmp $d <(./hsgzip < $d | gunzip -c)
-   cmp $d <(./hsgzip < $d | ./hsgunzip)
-   echo -n '.'
-done
-echo

3rdparty/zlib/test/gzip-uncompress.sh

@@ -1,16 +0,0 @@
-#!/usr/bin/env bash
-
-for d in $*; do
-   if gunzip -c < $d &> /dev/null; then
-     if cmp <(./hsgunzip < $d) <(gunzip -c < $d) > /dev/null; then
-       echo -n '.'
-     else
-       echo '#'
-       echo "FAILED: $d"
-       exit 1
-     fi
-   else
-     echo -n '_'
-  fi
-done
-echo

3rdparty/zlib/test/zpipe-compress.sh

@@ -1,11 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-for d in $*; do
-   cmp <(./hszpipe < $d) <(./zpipe < $d)
-   cmp $d <(./zpipe < $d | ./zpipe -d) # just in case..
-   cmp $d <(./zpipe < $d | ./hszpipe -d)
-   echo -n .
-done
-echo

3rdparty/zlib/test/zpipe.c

@@ -1,205 +0,0 @@
-/* zpipe.c: example of proper use of zlib's inflate() and deflate()
-   Not copyrighted -- provided to the public domain
-   Version 1.4  11 December 2005  Mark Adler */
-
-/* Version history:
-   1.0  30 Oct 2004  First version
-   1.1   8 Nov 2004  Add void casting for unused return values
-                     Use switch statement for inflate() return values
-   1.2   9 Nov 2004  Add assertions to document zlib guarantees
-   1.3   6 Apr 2005  Remove incorrect assertion in inf()
-   1.4  11 Dec 2005  Add hack to avoid MSDOS end-of-line conversions
-                     Avoid some compiler warnings for input and output buffers
- */
-
-#include <stdio.h>
-#include <string.h>
-#include <assert.h>
-#include "zlib.h"
-
-#if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__)
-#  include <fcntl.h>
-#  include <io.h>
-#  define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
-#else
-#  define SET_BINARY_MODE(file)
-#endif
-
-#define CHUNK 16384
-
-/* Compress from file source to file dest until EOF on source.
-   def() returns Z_OK on success, Z_MEM_ERROR if memory could not be
-   allocated for processing, Z_STREAM_ERROR if an invalid compression
-   level is supplied, Z_VERSION_ERROR if the version of zlib.h and the
-   version of the library linked do not match, or Z_ERRNO if there is
-   an error reading or writing the files. */
-int def(FILE *source, FILE *dest, int level)
-{
-    int ret, flush;
-    unsigned have;
-    z_stream strm;
-    unsigned char in[CHUNK];
-    unsigned char out[CHUNK];
-
-    /* allocate deflate state */
-    strm.zalloc = Z_NULL;
-    strm.zfree = Z_NULL;
-    strm.opaque = Z_NULL;
-    ret = deflateInit(&strm, level);
-    if (ret != Z_OK)
-        return ret;
-
-    /* compress until end of file */
-    do {
-        strm.avail_in = fread(in, 1, CHUNK, source);
-        if (ferror(source)) {
-            (void)deflateEnd(&strm);
-            return Z_ERRNO;
-        }
-        flush = feof(source) ? Z_FINISH : Z_NO_FLUSH;
-        strm.next_in = in;
-
-        /* run deflate() on input until output buffer not full, finish
-           compression if all of source has been read in */
-        do {
-            strm.avail_out = CHUNK;
-            strm.next_out = out;
-            ret = deflate(&strm, flush);    /* no bad return value */
-            assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
-            have = CHUNK - strm.avail_out;
-            if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
-                (void)deflateEnd(&strm);
-                return Z_ERRNO;
-            }
-        } while (strm.avail_out == 0);
-        assert(strm.avail_in == 0);     /* all input will be used */
-
-        /* done when last data in file processed */
-    } while (flush != Z_FINISH);
-    assert(ret == Z_STREAM_END);        /* stream will be complete */
-
-    /* clean up and return */
-    (void)deflateEnd(&strm);
-    return Z_OK;
-}
-
-/* Decompress from file source to file dest until stream ends or EOF.
-   inf() returns Z_OK on success, Z_MEM_ERROR if memory could not be
-   allocated for processing, Z_DATA_ERROR if the deflate data is
-   invalid or incomplete, Z_VERSION_ERROR if the version of zlib.h and
-   the version of the library linked do not match, or Z_ERRNO if there
-   is an error reading or writing the files. */
-int inf(FILE *source, FILE *dest)
-{
-    int ret;
-    unsigned have;
-    z_stream strm;
-    unsigned char in[CHUNK];
-    unsigned char out[CHUNK];
-
-    /* allocate inflate state */
-    strm.zalloc = Z_NULL;
-    strm.zfree = Z_NULL;
-    strm.opaque = Z_NULL;
-    strm.avail_in = 0;
-    strm.next_in = Z_NULL;
-    ret = inflateInit(&strm);
-    if (ret != Z_OK)
-        return ret;
-
-    /* decompress until deflate stream ends or end of file */
-    do {
-        strm.avail_in = fread(in, 1, CHUNK, source);
-        if (ferror(source)) {
-            (void)inflateEnd(&strm);
-            return Z_ERRNO;
-        }
-        if (strm.avail_in == 0)
-            break;
-        strm.next_in = in;
-
-        /* run inflate() on input until output buffer not full */
-        do {
-            strm.avail_out = CHUNK;
-            strm.next_out = out;
-            ret = inflate(&strm, Z_NO_FLUSH);
-            assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
-            switch (ret) {
-            case Z_NEED_DICT:
-                ret = Z_DATA_ERROR;     /* and fall through */
-            case Z_DATA_ERROR:
-            case Z_MEM_ERROR:
-                (void)inflateEnd(&strm);
-                return ret;
-            }
-            have = CHUNK - strm.avail_out;
-            if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
-                (void)inflateEnd(&strm);
-                return Z_ERRNO;
-            }
-        } while (strm.avail_out == 0);
-
-        /* done when inflate() says it's done */
-    } while (ret != Z_STREAM_END);
-
-    /* clean up and return */
-    (void)inflateEnd(&strm);
-    return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR;
-}
-
-/* report a zlib or i/o error */
-void zerr(int ret)
-{
-    fputs("zpipe: ", stderr);
-    switch (ret) {
-    case Z_ERRNO:
-        if (ferror(stdin))
-            fputs("error reading stdin\n", stderr);
-        if (ferror(stdout))
-            fputs("error writing stdout\n", stderr);
-        break;
-    case Z_STREAM_ERROR:
-        fputs("invalid compression level\n", stderr);
-        break;
-    case Z_DATA_ERROR:
-        fputs("invalid or incomplete deflate data\n", stderr);
-        break;
-    case Z_MEM_ERROR:
-        fputs("out of memory\n", stderr);
-        break;
-    case Z_VERSION_ERROR:
-        fputs("zlib version mismatch!\n", stderr);
-    }
-}
-
-/* compress or decompress from stdin to stdout */
-int main(int argc, char **argv)
-{
-    int ret;
-
-    /* avoid end-of-line conversions */
-    SET_BINARY_MODE(stdin);
-    SET_BINARY_MODE(stdout);
-
-    /* do compression if no arguments */
-    if (argc == 1) {
-        ret = def(stdin, stdout, Z_DEFAULT_COMPRESSION);
-        if (ret != Z_OK)
-            zerr(ret);
-        return ret;
-    }
-
-    /* do decompression if -d specified */
-    else if (argc == 2 && strcmp(argv[1], "-d") == 0) {
-        ret = inf(stdin, stdout);
-        if (ret != Z_OK)
-            zerr(ret);
-        return ret;
-    }
-
-    /* otherwise, report usage */
-    else {
-        fputs("zpipe usage: zpipe [-d] < source > dest\n", stderr);
-        return 1;
-    }
-}

3rdparty/zlib/zlib.cabal

@@ -1,116 +0,0 @@
-cabal-version:   >= 1.10
-name:            zlib
-version:         0.6.2.1
-
-copyright:       (c) 2006-2016 Duncan Coutts
-license:         BSD3
-license-file:    LICENSE
-author:          Duncan Coutts <duncan@community.haskell.org>
-maintainer:      Duncan Coutts <duncan@community.haskell.org>
-bug-reports:     https://github.com/haskell/zlib/issues
-category:        Codec
-synopsis:        Compression and decompression in the gzip and zlib formats
-description:     This package provides a pure interface for compressing and 
-                 decompressing streams of data represented as lazy 
-                 'ByteString's. It uses the
-                 <https://en.wikipedia.org/wiki/Zlib zlib C library>
-                 so it has high performance. It supports the \"zlib\",
-                 \"gzip\" and \"raw\" compression formats.
-                 .
-                 It provides a convenient high level API suitable for most
-                 tasks and for the few cases where more control is needed it
-                 provides access to the full zlib feature set.
-build-type:      Simple
-tested-with:     GHC ==7.0.4, GHC ==7.2.2, GHC ==7.4.2, GHC ==7.6.3, GHC ==7.8.4, GHC ==7.10.3, GHC ==8.0.1, GHC==8.0.2, GHC ==8.2.2, GHC ==8.4.4, GHC==8.6.5, GHC==8.8.3, GHC==8.10.1
-
-extra-source-files: changelog
-                    -- zlib C sources (for Windows)
-                    cbits/crc32.h cbits/inffast.h cbits/inflate.h
-                    cbits/trees.h cbits/deflate.h cbits/inffixed.h
-                    cbits/inftrees.h cbits/zutil.h cbits/gzguts.h
-                    -- test data files
-                    test/data/bad-crc.gz test/data/custom-dict.zlib
-                    test/data/custom-dict.zlib-dict test/data/hello.gz
-                    test/data/not-gzip test/data/two-files.gz
-                    -- demo programs:
-                    examples/gzip.hs examples/gunzip.hs
-
-source-repository head
-  type: git
-  location: https://github.com/haskell/zlib.git
-
-flag non-blocking-ffi
-  default:     False
-  manual:      True
-  description: The (de)compression calls can sometimes take a long time, which
-               prevents other Haskell threads running. Enabling this flag
-               avoids this unfairness, but with greater overall cost.
-
-flag pkg-config
-  default:     False
-  manual:      True
-  description: Use @pkg-config(1)@ to locate foreign @zlib@ library.
-
-flag static
-  default:     False
-  manual:      True
-  description: Use the bundled sources. Requires pkg-config to be False. For windows, this is the default.
-
-
-library
-  exposed-modules: Codec.Compression.GZip,
-                   Codec.Compression.Zlib,
-                   Codec.Compression.Zlib.Raw,
-                   Codec.Compression.Zlib.Internal
-  other-modules:   Codec.Compression.Zlib.Stream
-  if impl(ghc < 7)
-    default-language: Haskell98
-    default-extensions: PatternGuards
-  else
-    default-language: Haskell2010
-  other-extensions: CPP, ForeignFunctionInterface, RankNTypes, BangPatterns,
-                    DeriveDataTypeable
-  if impl(ghc >= 7.2)
-    other-extensions: DeriveGeneric
-  if impl(ghc >= 7.6)
-    other-extensions: CApiFFI
-  build-depends:   base >= 4 && < 4.15,
-                   bytestring >= 0.9 && < 0.11
-  if impl(ghc >= 7.2 && < 7.6)
-    build-depends: ghc-prim
-  includes:        zlib.h
-  ghc-options:     -Wall -fwarn-tabs
-  if flag(non-blocking-ffi)
-    cpp-options:   -DNON_BLOCKING_FFI
-  if flag(pkg-config)
-    -- NB: pkg-config is available on windows as well when using msys2
-    pkgconfig-depends: zlib
-  else
-    -- don't use pkg-config
-    if !os(windows) && !flag(static)
-      -- Normally we use the the standard system zlib.
-      extra-libraries: z
-    else
-      -- However for the benefit of users of Windows (which does not have zlib
-      -- by default) we bundle a complete copy of the C sources of zlib-1.2.8
-      c-sources:   cbits/adler32.c cbits/compress.c cbits/crc32.c
-                   cbits/deflate.c cbits/infback.c
-                   cbits/inffast.c cbits/inflate.c cbits/inftrees.c
-                   cbits/trees.c cbits/uncompr.c cbits/zutil.c
-      include-dirs:  cbits
-      install-includes: zlib.h zconf.h
-
-test-suite tests
-  type: exitcode-stdio-1.0
-  main-is:         Test.hs
-  other-modules:   Utils,
-                   Test.Codec.Compression.Zlib.Internal,
-                   Test.Codec.Compression.Zlib.Stream
-  hs-source-dirs:  test
-  default-language: Haskell2010
-  build-depends:   base, bytestring, zlib,
-                   QuickCheck       == 2.*,
-                   tasty            >= 0.8 && < 1.4,
-                   tasty-quickcheck >= 0.8 && < 0.11,
-                   tasty-hunit      >= 0.8 && < 0.11
-  ghc-options:     -Wall

CHANGELOG.md

@@ -1,7 +1,18 @@
 # Revision history for ghcup
 
-## 0.1.13 -- ????-??-??
+## 0.1.14 -- 2021-03-07
 
+* Major bugfix: fix handling of stray versions wrt [#116](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/116)
+* Fix error messages and overhaul pretty printing wrt [#115](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/115)
+
+## 0.1.13 -- 2021-02-26
+
+* Support ARMv7/AARCH64
+* Add command line completions for installed and available versions wrt [MR #70](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/70)
+* Allow to cycle through set tools wrt [#114](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/114)
+* Fix item selection with unavailable versions wrt [#107](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/107)
+* Allow for dynamic post-install, post-remove and pre-compile msgs wrt [MR #68](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/68)
+* Alert user if upgraded ghcup is shadowed by old ghcup wrt [#111](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/111)
 * Fix to `ghcup` directory creation and placement for the XDG install mode ([MR #49](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/49))
 * Do 755 permissions on executables, wrt #97
 * Add [NO_COLOR](https://no-color.org/) support wrt [MR #47](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/47)

README.md

@@ -18,6 +18,7 @@ Similar in scope to [rustup](https://github.com/rust-lang-nursery/rustup.rs), [p
      * [Shell-completion](#shell-completion)
      * [Cross support](#cross-support)
      * [XDG support](#xdg-support)
+     * [Env variables](#env-variables)
      * [Installing custom bindists](#installing-custom-bindists)
    * [Design goals](#design-goals)
    * [How](#how)
@@ -124,6 +125,17 @@ Then you can control the locations via XDG environment variables as such:
 * `XDG_BIN_HOME`: binaries end up here (default: `~/.local/bin`)
 * `XDG_CONFIG_HOME`: the config file is stored in `ghcup` subdir as `config.yaml` (default: `~/.config`)
 
+### Env variables
+
+This is the complete list of env variables that change GHCup behavior:
+
+* `GHCUP_USE_XDG_DIRS`: see [XDG support](#xdg-support) above
+* `TMPDIR`: where ghcup does the work (unpacking, building, ...)
+* `GHCUP_INSTALL_BASE_PREFIX`: the base of ghcup (default: `$HOME`)
+* `GHCUP_CURL_OPTS`: additional options that can be passed to curl
+* `GHCUP_WGET_OPTS`: additional options that can be passed to wget
+* `CC`/`LD` etc.: full environment is passed to the build system when compiling GHC via GHCup
+
 ### Installing custom bindists
 
 There are a couple of good use cases to install custom bindists:
@@ -168,6 +180,7 @@ In addition this script can also install `cabal-install`.
 
 ## Known users
 
+* Github action [haskell/actions/setup](https://github.com/haskell/actions/tree/main/setup)
 * [vabal](https://github.com/Franciman/vabal)
 
 ## Known problems

app/ghcup-gen/Main.hs

@@ -44,11 +44,10 @@ data Input
 fileInput :: Parser Input
 fileInput =
   FileInput
-    <$> (strOption
+    <$> strOption
           (long "file" <> short 'f' <> metavar "FILENAME" <> help
             "Input file to validate"
           )
-        )
 
 stdInput :: Parser Input
 stdInput = flag'
@@ -76,7 +75,7 @@ tarballFilterP = option readm $
       case span (/= '-') s of
         (_, []) -> fail "invalid format, missing '-' after the tool name"
         (t, v) | [tool] <- [ tool | tool <- [minBound..maxBound], low (show tool) == low t ] ->
-          TarballFilter <$> pure (Just tool) <*> makeRegexOptsM compIgnoreCase execBlank (drop 1 v)
+          pure (TarballFilter $ Just tool) <*> makeRegexOptsM compIgnoreCase execBlank (drop 1 v)
         _ -> fail "invalid tool"
     low = fmap toLower
 
@@ -86,21 +85,18 @@ opts = Options <$> com
 
 com :: Parser Command
 com = subparser
-  (  (command
+  (  command
        "check"
        (   ValidateYAML
-       <$> (info (validateYAMLOpts <**> helper)
-                 (progDesc "Validate the YAML")
-           )
+       <$> info (validateYAMLOpts <**> helper)
+                (progDesc "Validate the YAML")
        )
-     )
-  <> (command
+  <> command
        "check-tarballs"
        (info
          ((ValidateTarballs <$> validateYAMLOpts <*> tarballFilterP) <**> helper)
          (progDesc "Validate all tarballs (download and checksum)")
        )
-     )
   )
 
 

app/ghcup-gen/Validate.hs

@@ -32,6 +32,7 @@ import           Optics
 import           System.Exit
 import           System.IO
 import           Text.ParserCombinators.ReadP
+import           Text.PrettyPrint.HughesPJClass ( prettyShow )
 import           Text.Regex.Posix
 
 import qualified Data.ByteString               as B
@@ -67,7 +68,7 @@ validate dls = do
     forM_ (M.toList dls) $ \(t, versions) ->
       forM_ (M.toList versions) $ \(v, vi) ->
         forM_ (M.toList $ _viArch vi) $ \(arch, pspecs) -> do
-          checkHasRequiredPlatforms t v arch (M.keys pspecs)
+          checkHasRequiredPlatforms t v (_viTags vi) arch (M.keys pspecs)
 
     checkGHCVerIsValid
     forM_ (M.toList dls) $ \(t, _) -> checkMandatoryTags t
@@ -81,26 +82,30 @@ validate dls = do
         lift $ $(logInfo) [i|All good|]
         pure ExitSuccess
  where
-  checkHasRequiredPlatforms t v arch pspecs = do
+  checkHasRequiredPlatforms t v tags arch pspecs = do
     let v' = prettyVer v
-    when (not $ any (== Linux UnknownLinux) pspecs) $ do
+        arch' = prettyShow arch
+    when (notElem (Linux UnknownLinux) pspecs) $ do
       lift $ $(logError)
-        [i|Linux UnknownLinux missing for for #{t} #{v'} #{arch}|]
+        [i|Linux UnknownLinux missing for for #{t} #{v'} #{arch'}|]
       addError
-    when ((not $ any (== Darwin) pspecs) && arch == A_64) $ do
-      lift $ $(logError) [i|Darwin missing for #{t} #{v'} #{arch}|]
+    when ((notElem Darwin pspecs) && arch == A_64) $ do
+      lift $ $(logError) [i|Darwin missing for #{t} #{v'} #{arch'}|]
       addError
-    when ((not $ any (== FreeBSD) pspecs) && arch == A_64) $ lift $ $(logWarn)
-      [i|FreeBSD missing for #{t} #{v'} #{arch}|]
+    when ((notElem FreeBSD pspecs) && arch == A_64) $ lift $ $(logWarn)
+      [i|FreeBSD missing for #{t} #{v'} #{arch'}|]
 
     -- alpine needs to be set explicitly, because
     -- we cannot assume that "Linux UnknownLinux" runs on Alpine
     -- (although it could be static)
-    when (not $ any (== Linux Alpine) pspecs) $
+    when (notElem (Linux Alpine) pspecs) $
       case t of
-        GHCup -> (lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]) >> addError
-        Cabal | v > [vver|2.4.1.0|] -> (lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]) >> addError
-        _     -> lift $ $(logWarn) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]
+        GHCup | arch `elem` [A_64, A_32] -> lift ($(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]) >> addError
+        Cabal | v > [vver|2.4.1.0|]
+              , arch `elem` [A_64, A_32] -> lift ($(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|]) >> addError
+        GHC | Latest `elem` tags || Recommended `elem` tags
+            , arch `elem` [A_64, A_32] -> lift ($(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|])
+        _ -> lift $ $(logWarn) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|]
 
   checkUniqueTags tool = do
     let allTags = join $ M.elems $ availableToolVersions dls tool
@@ -111,7 +116,7 @@ validate dls = do
                     (\case
                       [] -> throwM $ InternalError "empty inner list"
                       (t : ts) ->
-                        pure $ (t, ) $ if isUniqueTag t then ts == [] else True
+                        pure $ (t, ) (not (isUniqueTag t) || null ts)
                     )
                 . group
                 . sort
@@ -185,7 +190,7 @@ validateTarballs (TarballFilter tool versionRegex) dls = do
           %& indices (matchTest versionRegex . T.unpack . prettyVer)
           % (viSourceDL % _Just `summing` viArch % each % each % each)
     when (null dlis) $ $(logError) [i|no tarballs selected by filter|] *> addError
-    forM_ dlis $ downloadAll
+    forM_ dlis downloadAll
 
     -- exit
     e <- liftIO $ readIORef ref
@@ -198,7 +203,7 @@ validateTarballs (TarballFilter tool versionRegex) dls = do
  where
   runLogger = myLoggerT LoggerConfig { lcPrintDebug = True
                                      , colorOutter  = B.hPut stderr
-                                     , rawOutter    = (\_ -> pure ())
+                                     , rawOutter    = \_ -> pure ()
                                      }
   downloadAll dli = do
     dirs <- liftIO getDirs

app/ghcup/BrickMain.hs

@@ -47,6 +47,7 @@ import           Prelude                 hiding ( appendFile )
 import           System.Environment
 import           System.Exit
 import           System.IO.Unsafe
+import           Text.PrettyPrint.HughesPJClass ( prettyShow )
 import           URI.ByteString
 
 import qualified GHCup.Types                   as GT
@@ -97,16 +98,15 @@ keyHandlers KeyBindings {..} =
   , (bSet, const "Set"      , withIOAction set')
   , (bChangelog, const "ChangeLog", withIOAction changelog')
   , ( bShowAll
-    , (\BrickSettings {..} ->
-        if showAll then "Hide old versions" else "Show all versions"
-      )
+    , \BrickSettings {..} ->
+       if showAll then "Hide old versions" else "Show all versions"
     , hideShowHandler
     )
-  , (bUp, const "Up", \BrickState {..} -> continue (BrickState { appState = (moveCursor 1 appState Up), .. }))
-  , (bDown, const "Down", \BrickState {..} -> continue (BrickState { appState = (moveCursor 1 appState Down), .. }))
+  , (bUp, const "Up", \BrickState {..} -> continue BrickState{ appState = moveCursor 1 appState Up, .. })
+  , (bDown, const "Down", \BrickState {..} -> continue BrickState{ appState = moveCursor 1 appState Down, .. })
   ]
  where
-  hideShowHandler (BrickState {..}) =
+  hideShowHandler BrickState{..} =
     let newAppSettings   = appSettings { showAll = not . showAll $ appSettings }
         newInternalState = constructList appData newAppSettings (Just appState)
     in  continue (BrickState appData newAppSettings newInternalState appKeys)
@@ -114,19 +114,18 @@ keyHandlers KeyBindings {..} =
 
 showKey :: Vty.Key -> String
 showKey (Vty.KChar c) = [c]
-showKey (Vty.KUp) = "↑"
-showKey (Vty.KDown) = "↓"
+showKey Vty.KUp = "↑"
+showKey Vty.KDown = "↓"
 showKey key = tail (show key)
 
 
 ui :: AttrMap -> BrickState -> Widget String
-ui dimAttrs BrickState { appSettings = as@(BrickSettings {}), ..}
-  = ( padBottom Max
-    $ ( withBorderStyle unicode
-      $ borderWithLabel (str "GHCup")
-      $ (center $ (header <=> hBorder <=> renderList' appState))
+ui dimAttrs BrickState{ appSettings = as@BrickSettings{}, ..}
+  = padBottom Max
+      ( withBorderStyle unicode
+        $ borderWithLabel (str "GHCup")
+          (center (header <=> hBorder <=> renderList' appState))
       )
-    )
     <=> footer
 
  where
@@ -135,15 +134,16 @@ ui dimAttrs BrickState { appSettings = as@(BrickSettings {}), ..}
       . txtWrap
       . T.pack
       . foldr1 (\x y -> x <> "  " <> y)
-      $ (fmap (\(key, s, _) -> (showKey key <> ":" <> s as)) $ keyHandlers appKeys)
+      . fmap (\(key, s, _) -> showKey key <> ":" <> s as)
+      $ keyHandlers appKeys
   header =
-    (minHSize 2 $ emptyWidget)
-      <+> (padLeft (Pad 2) $ minHSize 6 $ str "Tool")
-      <+> (minHSize 15 $ str "Version")
-      <+> (padLeft (Pad 1) $ minHSize 25 $ str "Tags")
-      <+> (padLeft (Pad 5) $ str "Notes")
+    minHSize 2 emptyWidget
+      <+> padLeft (Pad 2) (minHSize 6 $ str "Tool")
+      <+> minHSize 15 (str "Version")
+      <+> padLeft (Pad 1) (minHSize 25 $ str "Tags")
+      <+> padLeft (Pad 5) (str "Notes")
   renderList' = withDefAttr listAttr . drawListElements renderItem True
-  renderItem _ b listResult@(ListResult {..}) =
+  renderItem _ b listResult@ListResult{..} =
     let marks = if
           | lSet       -> (withAttr "set" $ str "✔✔")
           | lInstalled -> (withAttr "installed" $ str "✓ ")
@@ -152,7 +152,10 @@ ui dimAttrs BrickState { appSettings = as@(BrickSettings {}), ..}
           Nothing -> T.unpack . prettyVer $ lVer
           Just c  -> T.unpack (c <> "-" <> prettyVer lVer)
         dim
-          | lNoBindist = updateAttrMap (const dimAttrs) . withAttr "no-bindist"
+          | lNoBindist && not lInstalled
+            && not b -- TODO: overloading dim and active ignores active
+                       --       so we hack around it here
+          = updateAttrMap (const dimAttrs) . withAttr "no-bindist"
           | otherwise  = id
         hooray
           | elem Latest lTag && not lInstalled =
@@ -161,24 +164,23 @@ ui dimAttrs BrickState { appSettings = as@(BrickSettings {}), ..}
         active = if b then forceAttr "active" else id
     in  hooray $ active $ dim
           (   marks
-          <+> (( padLeft (Pad 2)
-               $ minHSize 6
-               $ (printTool lTool)
+          <+> padLeft (Pad 2)
+               ( minHSize 6
+                 (printTool lTool)
                )
-              )
-          <+> (minHSize 15 $ (str ver))
+          <+> minHSize 15 (str ver)
           <+> (let l = catMaybes . fmap printTag $ sort lTag
                in  padLeft (Pad 1) $ minHSize 25 $ if null l
                      then emptyWidget
                      else foldr1 (\x y -> x <+> str "," <+> y) l
               )
-          <+> ( padLeft (Pad 5)
-              $ let notes = printNotes listResult
+          <+> padLeft (Pad 5)
+              ( let notes = printNotes listResult
                 in  if null notes
                       then emptyWidget
-                      else foldr1 (\x y -> x <+> str "," <+> y) $ notes
+                      else foldr1 (\x y -> x <+> str "," <+> y) notes
               )
-          <+> (vLimit 1 $ fill ' ')
+          <+> vLimit 1 (fill ' ')
           )
 
   printTag Recommended    = Just $ withAttr "recommended" $ str "recommended"
@@ -277,7 +279,7 @@ defaultAttributes no_color = attrMap
 dimAttributes :: Bool -> AttrMap
 dimAttributes no_color = attrMap
   (Vty.defAttr `Vty.withStyle` Vty.dim)
-  [ ("active"    , Vty.defAttr `withBackColor` Vty.blue)
+  [ ("active"    , Vty.defAttr `withBackColor` Vty.blue) -- has no effect ??
   , ("no-bindist", Vty.defAttr `Vty.withStyle` Vty.dim)
   ]
   where
@@ -285,7 +287,7 @@ dimAttributes no_color = attrMap
                   | otherwise = Vty.withBackColor
 
 eventHandler :: BrickState -> BrickEvent n e -> EventM n (Next BrickState)
-eventHandler st@(BrickState {..}) ev = do
+eventHandler st@BrickState{..} ev = do
   AppState { keyBindings = kb } <- liftIO $ readIORef settings'
   case ev of
     (MouseDown _ Vty.BScrollUp _ _) ->
@@ -294,9 +296,9 @@ eventHandler st@(BrickState {..}) ev = do
       continue (BrickState { appState = moveCursor 1 appState Down, .. })
     (VtyEvent (Vty.EvResize _ _)) -> continue st
     (VtyEvent (Vty.EvKey Vty.KUp _)) ->
-      continue (BrickState { appState = (moveCursor 1 appState Up), .. })
+      continue BrickState{ appState = moveCursor 1 appState Up, .. }
     (VtyEvent (Vty.EvKey Vty.KDown _)) ->
-      continue (BrickState { appState = (moveCursor 1 appState Down), .. })
+      continue BrickState{ appState = moveCursor 1 appState Down, .. }
     (VtyEvent (Vty.EvKey key _)) ->
       case find (\(key', _, _) -> key' == key) (keyHandlers kb) of
         Nothing -> continue st
@@ -305,7 +307,7 @@ eventHandler st@(BrickState {..}) ev = do
 
 
 moveCursor :: Int -> BrickInternalState -> Direction -> BrickInternalState
-moveCursor steps ais@(BrickInternalState {..}) direction =
+moveCursor steps ais@BrickInternalState{..} direction =
   let newIx = if direction == Down then ix + steps else ix - steps
   in  case clr !? newIx of
         Just _  -> BrickInternalState { ix = newIx, .. }
@@ -321,7 +323,7 @@ withIOAction action as = case listSelectedElement' (appState as) of
   Nothing      -> continue as
   Just (ix, e) -> suspendAndResume $ do
     action as (ix, e) >>= \case
-      Left  err -> putStrLn $ ("Error: " <> err)
+      Left  err -> putStrLn ("Error: " <> err)
       Right _   -> putStrLn "Success"
     getAppData Nothing (pfreq . appData $ as) >>= \case
       Right data' -> do
@@ -335,7 +337,7 @@ withIOAction action as = case listSelectedElement' (appState as) of
 -- This synchronises @BrickInternalState@ with @BrickData@
 -- and @BrickSettings@.
 updateList :: BrickData -> BrickState -> BrickState
-updateList appD (BrickState {..}) =
+updateList appD BrickState{..} =
   let newInternalState = constructList appD appSettings (Just appState)
   in  BrickState { appState    = newInternalState
                  , appData     = appD
@@ -348,11 +350,11 @@ constructList :: BrickData
               -> BrickSettings
               -> Maybe BrickInternalState
               -> BrickInternalState
-constructList appD appSettings mapp =
-  replaceLR (filterVisible (showAll appSettings)) (lr appD) mapp
+constructList appD appSettings =
+  replaceLR (filterVisible (showAll appSettings)) (lr appD)
 
 listSelectedElement' :: BrickInternalState -> Maybe (Int, ListResult)
-listSelectedElement' (BrickInternalState {..}) = fmap (ix, ) $ clr !? ix
+listSelectedElement' BrickInternalState{..} = fmap (ix, ) $ clr !? ix
 
 
 selectLatest :: Vector ListResult -> Int
@@ -416,22 +418,29 @@ install' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
               , TarDirDoesNotExist
               ]
 
-  (run $ do
+  run (do
       case lTool of
-        GHC   -> liftE $ installGHCBin dls lVer pfreq
-        Cabal -> liftE $ installCabalBin dls lVer pfreq
-        GHCup -> liftE $ upgradeGHCup dls Nothing False pfreq $> ()
-        HLS   -> liftE $ installHLSBin dls lVer pfreq $> ()
+        GHC   -> do
+          let vi = getVersionInfo lVer GHC dls
+          liftE $ installGHCBin dls lVer pfreq $> vi
+        Cabal -> do
+          let vi = getVersionInfo lVer Cabal dls
+          liftE $ installCabalBin dls lVer pfreq $> vi
+        GHCup -> do
+          let vi = snd <$> getLatest dls GHCup
+          liftE $ upgradeGHCup dls Nothing False pfreq $> vi
+        HLS   -> do
+          let vi = getVersionInfo lVer HLS dls
+          liftE $ installHLSBin dls lVer pfreq $> vi
     )
     >>= \case
-          VRight _                          -> pure $ Right ()
+          VRight vi                         -> do
+            forM_ (_viPostInstall =<< vi) $ \msg ->
+              runLogger $ $(logInfo) msg
+            pure $ Right ()
           VLeft  (V (AlreadyInstalled _ _)) -> pure $ Right ()
-          VLeft (V (BuildFailed _ e)) ->
-            pure $ Left [i|Build failed with #{e}|]
-          VLeft (V NoDownload) ->
-            pure $ Left [i|No available version for #{prettyVer lVer}|]
           VLeft (V NoUpdate) -> pure $ Right ()
-          VLeft e -> pure $ Left [i|#{e}
+          VLeft e -> pure $ Left [i|#{prettyShow e}
 Also check the logs in ~/.ghcup/logs|]
 
 
@@ -446,7 +455,7 @@ set' _ (_, ListResult {..}) = do
           . flip runReaderT settings
           . runE @'[FileDoesNotExistError , NotInstalled , TagNotFound]
 
-  (run $ do
+  run (do
       case lTool of
         GHC   -> liftE $ setGHC (GHCTargetVersion lCross lVer) SetGHCOnly $> ()
         Cabal -> liftE $ setCabal lVer $> ()
@@ -455,27 +464,31 @@ set' _ (_, ListResult {..}) = do
     )
     >>= \case
           VRight _ -> pure $ Right ()
-          VLeft  e -> pure $ Left [i|#{e}|]
+          VLeft  e -> pure $ Left (prettyShow e)
 
 
 del' :: BrickState -> (Int, ListResult) -> IO (Either String ())
-del' _ (_, ListResult {..}) = do
+del' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
   settings <- readIORef settings'
   l        <- readIORef logger'
   let runLogger = myLoggerT l
 
   let run = runLogger . flip runReaderT settings . runE @'[NotInstalled]
 
-  (run $ do
+  run (do
+      let vi = getVersionInfo lVer lTool dls
       case lTool of
-        GHC   -> liftE $ rmGHCVer (GHCTargetVersion lCross lVer) $> ()
-        Cabal -> liftE $ rmCabalVer lVer $> ()
-        HLS   -> liftE $ rmHLSVer lVer $> ()
-        GHCup -> pure ()
+        GHC   -> liftE $ rmGHCVer (GHCTargetVersion lCross lVer) $> vi
+        Cabal -> liftE $ rmCabalVer lVer $> vi
+        HLS   -> liftE $ rmHLSVer lVer $> vi
+        GHCup -> pure Nothing
     )
     >>= \case
-          VRight _ -> pure $ Right ()
-          VLeft  e -> pure $ Left [i|#{e}|]
+          VRight vi -> do
+            forM_ (join $ fmap _viPostRemove vi) $ \msg ->
+              runLogger $ $(logInfo) msg
+            pure $ Right ()
+          VLeft  e -> pure $ Left (prettyShow e)
 
 
 changelog' :: BrickState -> (Int, ListResult) -> IO (Either String ())
@@ -490,7 +503,7 @@ changelog' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
             FreeBSD -> "xdg-open"
       exec cmd True [serializeURIRef' uri] Nothing Nothing >>= \case
         Right _ -> pure $ Right ()
-        Left  e -> pure $ Left [i|#{e}|]
+        Left  e -> pure $ Left $ prettyShow e
 
 
 settings' :: IORef AppState
@@ -570,7 +583,7 @@ getDownloads' = do
 
   case r of
     VRight a -> pure $ Right a
-    VLeft  e -> pure $ Left [i|#{e}|]
+    VLeft  e -> pure $ Left (prettyShow e)
 
 
 getAppData :: Maybe GHCupDownloads
@@ -587,6 +600,6 @@ getAppData mg pfreq' = do
     case r of
       Right dls -> do
         lV <- listVersions dls Nothing Nothing pfreq'
-        pure $ Right $ (BrickData (reverse lV) dls pfreq')
+        pure $ Right $ BrickData (reverse lV) dls pfreq'
       Left e -> pure $ Left [i|#{e}|]
 

bootstrap-haskell

@@ -69,7 +69,7 @@ _done() {
 download_ghcup() {
 	_plat="$(uname -s)"
 	_arch=$(uname -m)
-	_ghver="0.1.12"
+	_ghver="0.1.14"
 	_base_url="https://downloads.haskell.org/~ghcup"
 
     case "${_plat}" in
@@ -89,6 +89,12 @@ download_ghcup() {
 				i*86)
 					_url=${_base_url}/${_ghver}/i386-linux-ghcup-${_ghver}
 					;;
+				armv7*)
+					_url=${_base_url}/${_ghver}/armv7-linux-ghcup-${_ghver}
+					;;
+				aarch64|arm64|armv8l)
+					_url=${_base_url}/${_ghver}/aarch64-linux-ghcup-${_ghver}
+					;;
 				*) die "Unknown architecture: ${_arch}"
 					;;
 			esac
@@ -267,6 +273,7 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
 					"") break ;;
 					fish)
 						if ! grep -q "ghcup-env" "${GHCUP_PROFILE_FILE}" ; then
+							mkdir -p "${GHCUP_PROFILE_FILE%/*}"
 							echo "# ghcup-env" >> "${GHCUP_PROFILE_FILE}"
 							echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME" >> "${GHCUP_PROFILE_FILE}"
 							echo "test -f $GHCUP_DIR/env ; and set -gx PATH \$HOME/.cabal/bin $GHCUP_BIN \$PATH" >> "${GHCUP_PROFILE_FILE}"

cabal.ghc8104.project

@@ -0,0 +1,20 @@
+packages: ./ghcup.cabal
+
+with-compiler: ghc-8.10.4
+
+optional-packages: ./3rdparty/*/*.cabal
+
+optimization: 2
+
+package streamly
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+
+package ghcup
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+
+constraints: http-io-streams -brotli
+
+package libarchive
+  flags: -system-libarchive
+
+allow-newer: base, ghc-prim, template-haskell

cabal.ghc8104.project.freeze

@@ -0,0 +1,261 @@
+active-repositories: hackage.haskell.org:merge
+constraints: any.Cabal ==3.2.1.0,
+             any.HUnit ==1.6.2.0,
+             any.IfElse ==0.85,
+             any.QuickCheck ==2.14.2,
+             QuickCheck -old-random +templatehaskell,
+             any.StateVar ==1.2.1,
+             any.abstract-deque ==0.3,
+             abstract-deque -usecas,
+             any.aeson ==1.5.6.0,
+             aeson -bytestring-builder -cffi -developer -fast,
+             any.aeson-pretty ==0.8.8,
+             aeson-pretty -lib-only,
+             any.alex ==3.2.6,
+             alex +small_base,
+             any.ansi-terminal ==0.11,
+             ansi-terminal -example,
+             any.ansi-wl-pprint ==0.6.9,
+             ansi-wl-pprint -example,
+             any.array ==0.5.4.0,
+             any.ascii-string ==1.0.1.4,
+             any.assoc ==1.0.2,
+             any.async ==2.2.3,
+             async -bench,
+             any.atomic-primops ==0.8.4,
+             atomic-primops -debug,
+             any.attoparsec ==0.13.2.5,
+             attoparsec -developer,
+             any.auto-update ==0.1.6,
+             any.base ==4.14.1.0,
+             any.base-compat ==0.11.2,
+             any.base-compat-batteries ==0.11.2,
+             any.base-orphans ==0.8.4,
+             any.base16-bytestring ==1.0.1.0,
+             any.base64-bytestring ==1.2.0.1,
+             any.bifunctors ==5.5.10,
+             bifunctors +semigroups +tagged,
+             any.binary ==0.8.8.0,
+             any.blaze-builder ==0.4.2.1,
+             any.bytestring ==0.10.12.0,
+             any.bz2 ==1.0.1.0,
+             bz2 -cross +with-bzlib,
+             any.c2hs ==0.28.7,
+             c2hs +base3 -regression,
+             any.call-stack ==0.3.0,
+             any.case-insensitive ==1.2.1.0,
+             any.casing ==0.1.4.1,
+             any.cereal ==0.5.8.1,
+             cereal -bytestring-builder,
+             any.chs-cabal ==0.1.1.0,
+             any.chs-deps ==0.1.0.0,
+             chs-deps -cross,
+             any.clock ==0.8.2,
+             clock -llvm,
+             any.cmdargs ==0.10.21,
+             cmdargs +quotation -testprog,
+             any.colour ==2.3.5,
+             any.comonad ==5.0.8,
+             comonad +containers +distributive +indexed-traversable,
+             any.composition-prelude ==3.0.0.2,
+             composition-prelude -development,
+             any.concurrent-output ==1.10.12,
+             any.conduit ==1.3.4.1,
+             any.conduit-extra ==1.3.5,
+             any.containers ==0.6.2.1,
+             any.contravariant ==1.5.3,
+             contravariant +semigroups +statevar +tagged,
+             any.cryptohash-sha256 ==0.11.102.0,
+             cryptohash-sha256 -exe +use-cbits,
+             any.data-default-class ==0.1.2.0,
+             any.data-fix ==0.3.1,
+             any.deepseq ==1.4.4.0,
+             any.deferred-folds ==0.9.17,
+             any.directory ==1.3.6.0,
+             any.distributive ==0.6.2.1,
+             distributive +semigroups +tagged,
+             any.dlist ==1.0,
+             dlist -werror,
+             any.easy-file ==0.2.2,
+             any.errors ==2.3.0,
+             any.exceptions ==0.10.4,
+             any.fast-logger ==3.0.3,
+             any.filepath ==1.4.2.1,
+             any.focus ==1.0.2,
+             any.foldl ==1.4.11,
+             any.free ==5.1.6,
+             any.fusion-plugin-types ==0.1.0,
+             any.generic-arbitrary ==0.1.0,
+             any.generics-sop ==0.5.1.1,
+             any.ghc-boot-th ==8.10.4,
+             any.ghc-prim ==0.6.1,
+             ghcup -internal-downloader -tar -tui,
+             any.happy ==1.20.0,
+             any.hashable ==1.3.1.0,
+             hashable +integer-gmp,
+             any.haskell-src-exts ==1.23.1,
+             any.haskell-src-meta ==0.8.7,
+             any.haskus-utils-data ==1.4,
+             any.haskus-utils-types ==1.5.1,
+             any.haskus-utils-variant ==3.1,
+             any.heaps ==0.3.6.1,
+             any.hpath ==0.11.0,
+             any.hpath-directory ==0.14.1,
+             any.hpath-filepath ==0.10.4,
+             any.hpath-io ==0.14.1,
+             any.hpath-posix ==0.13.2,
+             any.hsc2hs ==0.68.7,
+             hsc2hs -in-ghc-tree,
+             any.hspec ==2.7.8,
+             any.hspec-core ==2.7.8,
+             any.hspec-discover ==2.7.8,
+             any.hspec-expectations ==0.8.2,
+             any.hspec-golden-aeson ==0.7.0.0,
+             any.indexed-profunctors ==0.1,
+             any.indexed-traversable ==0.1.1,
+             any.indexed-traversable-instances ==0.1,
+             any.integer-gmp ==1.0.3.0,
+             any.integer-logarithms ==1.0.3.1,
+             integer-logarithms -check-bounds +integer-gmp,
+             any.language-c ==0.8.3,
+             language-c -allwarnings +iecfpextension +separatesyb +usebytestrings,
+             any.libarchive ==3.0.2.1,
+             libarchive -cross -low-memory -system-libarchive,
+             any.libyaml ==0.1.2,
+             libyaml -no-unicode -system-libyaml,
+             any.lifted-base ==0.2.3.12,
+             any.list-t ==1.0.4,
+             any.lockfree-queue ==0.2.3.1,
+             lzma -static,
+             any.math-functions ==0.3.4.1,
+             math-functions +system-erf +system-expm1,
+             any.megaparsec ==9.0.1,
+             megaparsec -dev,
+             any.microlens ==0.4.12.0,
+             any.microlens-mtl ==0.2.0.1,
+             any.microlens-th ==0.4.3.9,
+             any.mmorph ==1.1.5,
+             any.monad-control ==1.0.2.3,
+             any.monad-logger ==0.3.36,
+             monad-logger +template_haskell,
+             any.monad-loops ==0.4.3,
+             monad-loops +base4,
+             any.mono-traversable ==1.0.15.1,
+             any.mtl ==2.2.2,
+             any.mwc-random ==0.15.0.1,
+             any.network ==3.1.2.1,
+             network -devel,
+             any.old-locale ==1.0.0.7,
+             any.old-time ==1.1.0.3,
+             any.optics ==0.4,
+             any.optics-core ==0.4,
+             optics-core -explicit-generic-labels,
+             any.optics-extra ==0.4,
+             any.optics-th ==0.4,
+             any.optics-vl ==0.2.1,
+             any.optparse-applicative ==0.16.1.0,
+             optparse-applicative +process,
+             any.os-release ==1.0.2,
+             os-release -devel,
+             any.parallel ==3.2.2.0,
+             any.parsec ==3.1.14.0,
+             any.parser-combinators ==1.3.0,
+             parser-combinators -dev,
+             any.pretty ==1.1.3.6,
+             any.pretty-terminal ==0.1.0.0,
+             any.primitive ==0.7.1.0,
+             any.primitive-extras ==0.8.2,
+             any.primitive-unlifted ==0.1.3.0,
+             any.process ==1.6.9.0,
+             any.profunctors ==5.6.2,
+             any.quickcheck-arbitrary-adt ==0.3.1.0,
+             any.quickcheck-io ==0.2.0,
+             any.random ==1.2.0,
+             any.recursion-schemes ==5.2.2,
+             recursion-schemes +template-haskell,
+             any.regex-posix ==0.96.0.0,
+             regex-posix -_regex-posix-clib,
+             any.resourcet ==1.2.4.2,
+             any.rts ==1.0,
+             any.safe ==0.3.19,
+             any.safe-exceptions ==0.1.7.1,
+             any.scientific ==0.3.6.2,
+             scientific -bytestring-builder -integer-simple,
+             any.semigroupoids ==5.3.5,
+             semigroupoids +comonad +containers +contravariant +distributive +tagged +unordered-containers,
+             any.setenv ==0.1.1.3,
+             any.sop-core ==0.5.0.1,
+             any.split ==0.2.3.4,
+             any.splitmix ==0.1.0.3,
+             splitmix -optimised-mixer,
+             any.stm ==2.5.0.0,
+             any.stm-chans ==3.0.0.4,
+             any.streaming-commons ==0.2.2.1,
+             streaming-commons -use-bytestring-builder,
+             any.streamly ==0.7.3,
+             streamly -debug -dev -examples -examples-sdl -fusion-plugin -has-llvm -inspection -no-fusion -streamk,
+             any.streamly-bytestring ==0.1.2,
+             any.streamly-posix ==0.1.0.1,
+             any.strict ==0.4.0.1,
+             strict +assoc,
+             any.strict-base ==0.4.0.0,
+             any.string-interpolate ==0.3.1.0,
+             string-interpolate -bytestring-builder -extended-benchmarks -text-builder,
+             any.syb ==0.7.2.1,
+             any.tagged ==0.8.6.1,
+             tagged +deepseq +transformers,
+             any.tasty ==1.3.1,
+             tasty +clock,
+             any.tasty-hunit ==0.10.0.3,
+             any.tasty-quickcheck ==0.10.1.2,
+             any.template-haskell ==2.16.0.0,
+             any.terminal-size ==0.3.2.1,
+             any.terminfo ==0.4.1.4,
+             any.text ==1.2.4.1,
+             any.text-conversions ==0.3.1,
+             any.text-short ==0.1.3,
+             text-short -asserts,
+             any.tf-random ==0.5,
+             any.th-abstraction ==0.4.2.0,
+             any.th-compat ==0.1.1,
+             any.th-lift ==0.8.2,
+             any.th-lift-instances ==0.1.18,
+             any.th-orphans ==0.13.11,
+             any.th-reify-many ==0.1.9,
+             any.these ==1.1.1.1,
+             these +assoc,
+             any.time ==1.9.3,
+             any.time-compat ==1.9.5,
+             time-compat -old-locale,
+             any.transformers ==0.5.6.2,
+             any.transformers-base ==0.4.5.2,
+             transformers-base +orphaninstances,
+             any.transformers-compat ==0.6.6,
+             transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
+             any.typed-process ==0.2.6.0,
+             any.unbounded-delays ==0.1.1.1,
+             any.unix ==2.7.2.2,
+             any.unix-bytestring ==0.3.7.3,
+             any.unix-compat ==0.5.3,
+             unix-compat -old-time,
+             any.unix-time ==0.4.7,
+             any.unliftio-core ==0.2.0.1,
+             any.unordered-containers ==0.2.13.0,
+             unordered-containers -debug,
+             any.uri-bytestring ==0.3.3.0,
+             uri-bytestring -lib-werror,
+             any.utf8-string ==1.0.2,
+             any.uuid-types ==1.0.4,
+             any.vector ==0.12.2.0,
+             vector +boundschecks -internalchecks -unsafechecks -wall,
+             any.vector-algorithms ==0.8.0.4,
+             vector-algorithms +bench +boundschecks -internalchecks -llvm +properties -unsafechecks,
+             any.versions ==4.0.3,
+             any.vty ==5.33,
+             any.wcwidth ==0.0.2,
+             wcwidth -cli +split-base,
+             any.word8 ==0.1.3,
+             any.yaml ==0.11.5.0,
+             yaml +no-examples +no-exe,
+             zlib -non-blocking-ffi -pkg-config -static
+index-state: hackage.haskell.org 2021-03-07T18:36:25Z

cabal.ghc884.project

@@ -1,47 +1,20 @@
--- Generated by stackage-to-hackage
-
-index-state: 2020-10-24T20:53:55Z
+packages: ./ghcup.cabal
 
 with-compiler: ghc-8.8.4
 
-packages:
-    ./
-  , 3rdparty/lzma/
-  , 3rdparty/lzma-clib/
-  , 3rdparty/zlib/
+optional-packages: ./3rdparty/*/*.cabal
 
-source-repository-package
-    type: git
-    location: https://github.com/haskus/packages.git
-    tag: 80a1c5fc07f7226c424250ec17f674cd4d618f42
-    subdir: haskus-utils-types
+optimization: 2
 
-source-repository-package
-    type: git
-    location: https://github.com/hasufell/hpath.git
-    tag: bf6d28cf989b70286e12fecc183d5bbf5454a1a2
-    subdir: hpath-directory
-            hpath-io
-
-source-repository-package
-    type: git
-    location: https://github.com/hasufell/text-conversions.git
-    tag: 9abf0e5e5664a3178367597c32db19880477a53c
-
-allow-older: *
-allow-newer: *
-
-package lzma
-    ghc-options: -O2
-
-package lzma-clib
-    ghc-options: -O2
-
-package zlib
-    ghc-options: -O2
+package streamly
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
 
 package ghcup
     ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
 
-package streamly
-    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+constraints: http-io-streams -brotli
+
+package libarchive
+  flags: -system-libarchive
+
+allow-newer: base, ghc-prim, template-haskell

cabal.project

@@ -2,24 +2,6 @@ packages: ./ghcup.cabal
 
 optional-packages: ./3rdparty/*/*.cabal
 
-source-repository-package
-    type: git
-    location: https://github.com/haskus/packages.git
-    tag: 80a1c5fc07f7226c424250ec17f674cd4d618f42
-    subdir: haskus-utils-types
-
-source-repository-package
-    type: git
-    location: https://github.com/hasufell/hpath.git
-    tag: bf6d28cf989b70286e12fecc183d5bbf5454a1a2
-    subdir: hpath-io
-
-source-repository-package
-    type: git
-    location: https://github.com/hasufell/hpath.git
-    tag: bf6d28cf989b70286e12fecc183d5bbf5454a1a2
-    subdir: hpath-directory
-
 optimization: 2
 
 package streamly
@@ -27,6 +9,8 @@ package streamly
 
 package ghcup
     ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+    tests: True
+    flags: +tui
 
 constraints: http-io-streams -brotli
 

ghcup-0.0.2.yaml

@@ -1384,7 +1384,7 @@ ghcupDownloads:
               dlUri: https://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-freebsd-12.1-release.tar.xz
               dlHash: 9705e16d03497b46be4ad477e6c64d10890af853eafa8a9adf6dba89aa9e05f7
   GHCup:
-    0.1.11:
+    0.1.14:
       viTags:
       - Recommended
       - Latest
@@ -1394,22 +1394,22 @@ ghcupDownloads:
         A_64:
           Linux_UnknownLinux:
             unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-linux-ghcup-0.1.11
-              dlHash: 99d97c9a1dce76892001e5cffd50cc23bf804f2282998c546d1b965aa2179699
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-linux-ghcup-0.1.14
+              dlHash: e9b314d248f4d4604ce64cee1be7161c77c8940efd11986c9205779ec3b598dd
           Darwin:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-apple-darwin-ghcup-0.1.11
-              dlHash: 4b91dcd9bfdc40534156b8fadea3f317b3c44af1255169895f4911a221f819c6
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-apple-darwin-ghcup-0.1.14
+              dlHash: 69ede9db36c0ae631b679fceb87dd856d4753ee26f33610da37dd7a694809919
           FreeBSD:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-portbld-freebsd-ghcup-0.1.11
-              dlHash: 6f04ce98d3f3eb9299ce74f8264aa956f0dc38a64a3bd12ee048b7f146e9e1b4
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-portbld-freebsd-ghcup-0.1.14
+              dlHash: 68b09404cf49061da539463f42f8ad67c9cef5c5d3f68a3c7c4f6760e8442bb9
           Linux_Alpine:
             unknown_versioning: *ghcup-64
         A_32:
           Linux_UnknownLinux:
             unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/i386-linux-ghcup-0.1.11
-              dlHash: ec339e4c2b8b4d502f66a03c0d3f112cb68cd922dd3c4a6f66323628cf6a76c2
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/i386-linux-ghcup-0.1.14
+              dlHash: ecb1157f010d2421764c52ab0cdbbf9a5c3da555827172c7b904d5f3f96c80fa
           Linux_Alpine:
             unknown_versioning: *ghcup-32

ghcup-0.0.3.yaml

@@ -1451,7 +1451,7 @@ ghcupDownloads:
               dlUri: https://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-freebsd-12.1-release.tar.xz
               dlHash: 9705e16d03497b46be4ad477e6c64d10890af853eafa8a9adf6dba89aa9e05f7
   GHCup:
-    0.1.12:
+    0.1.14:
       viTags:
       - Recommended
       - Latest
@@ -1461,23 +1461,23 @@ ghcupDownloads:
         A_64:
           Linux_UnknownLinux:
             unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-linux-ghcup-0.1.12
-              dlHash: 83088569ddf2d35df494f440dedd9c8eb2a53276d665f7de731f6554986c2ddb
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-linux-ghcup-0.1.14
+              dlHash: e9b314d248f4d4604ce64cee1be7161c77c8940efd11986c9205779ec3b598dd
           Darwin:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-apple-darwin-ghcup-0.1.12
-              dlHash: 1336efb0851e1ed267838f97f6c36cbceb5363ad0ae359f04f1bc43d0c5f2cef
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-apple-darwin-ghcup-0.1.14
+              dlHash: 69ede9db36c0ae631b679fceb87dd856d4753ee26f33610da37dd7a694809919
           FreeBSD:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-portbld-freebsd-ghcup-0.1.12
-              dlHash: a72123e972a53d667574c7d276a81842701a07fce2b434e4d856e561c34772fe
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-portbld-freebsd-ghcup-0.1.14
+              dlHash: 68b09404cf49061da539463f42f8ad67c9cef5c5d3f68a3c7c4f6760e8442bb9
           Linux_Alpine:
             unknown_versioning: *ghcup-64
         A_32:
           Linux_UnknownLinux:
             unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/i386-linux-ghcup-0.1.12
-              dlHash: 4bc79a272dfcd16143f08d9f8e33f2fef66dc53f3a0659bdab56ac3cbecf9e84
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/i386-linux-ghcup-0.1.14
+              dlHash: ecb1157f010d2421764c52ab0cdbbf9a5c3da555827172c7b904d5f3f96c80fa
           Linux_Alpine:
             unknown_versioning: *ghcup-32
   HLS:

ghcup-0.0.4.yaml

@@ -28,7 +28,7 @@ toolRequirements:
           - libncurses5
           - libtinfo5
           notes: ''
-        ">= 20.04":
+        "( >= 20.04 && < 20.10 )":
           distroPKGs:
           - build-essential
           - curl
@@ -40,6 +40,18 @@ toolRequirements:
           - libncurses5
           - libtinfo5
           notes: ''
+        "( >= 20.10 )":
+          distroPKGs:
+          - build-essential
+          - curl
+          - libffi-dev
+          - libffi8ubuntu1
+          - libgmp-dev
+          - libgmp10
+          - libncurses-dev
+          - libncurses5
+          - libtinfo5
+          notes: ''
       Linux_CentOS:
         '( >= 7 && < 8 )':
           distroPKGs:
@@ -64,6 +76,19 @@ toolRequirements:
           - xz
           - perl
           notes: ''
+      Linux_Fedora:
+        unknown_versioning:
+          distroPKGs:
+          - gcc
+          - gcc-c++
+          - gmp
+          - gmp-devel
+          - make
+          - ncurses
+          - ncurses-compat-libs
+          - xz
+          - perl
+          notes: ''
       Linux_Alpine:
         unknown_versioning:
           distroPKGs:
@@ -113,6 +138,7 @@ ghcupDownloads:
         dlUri: https://downloads.haskell.org/~ghc/7.10.3/ghc-7.10.3-src.tar.xz
         dlSubdir: ghc-7.10.3
         dlHash: cf90cedce1c28fd0e2b9e72fe8a938756668d18ea1fcc884a19f698658ac4fef
+      viPostRemove: &ghc-post-remove "After removing GHC you might also want to clean up your cabal store at: ~/.cabal/store/ghc-<ghcver>"
       viArch:
         A_64:
           Linux_Debian:
@@ -176,6 +202,7 @@ ghcupDownloads:
         dlUri: https://downloads.haskell.org/~ghc/8.0.2/ghc-8.0.2-src.tar.xz
         dlSubdir: ghc-8.0.2
         dlHash: 11625453e1d0686b3fa6739988f70ecac836cadc30b9f0c8b49ef9091d6118b1
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -193,7 +220,7 @@ ghcupDownloads:
             unknown_versioning: *ghc-802-64-deb8
           Linux_Alpine:
             unknown_versioning:
-              dlUri: https://files.hasufell.de/ghc/ghc-8.0.2-x86_64-alpine-linux.tar.xz
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.0.2/ghc-8.0.2-x86_64-alpine-linux.tar.xz
               dlSubdir: ghc-8.0.2
               dlHash: 517783b660a27ebf95b2568d47292fd633d5f9a4de4c80ad1ccf05e1b9d7313f
           Linux_UnknownLinux:
@@ -220,7 +247,7 @@ ghcupDownloads:
               dlHash: 818621342a2161b8afcc995a0765816bb40aefbfa1db2c8a7d59c04d8b18228a
           Linux_Alpine:
             unknown_versioning:
-              dlUri: https://files.hasufell.de/ghc/ghc-8.0.2-i386-alpine-linux.tar.xz
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.0.2/ghc-8.0.2-i386-alpine-linux.tar.xz
               dlSubdir: ghc-8.0.2
               dlHash: b4cd12a1048b2fff2f23c9eec0dd3a1174d54d017f8d79ec79af4534118e6881
           Linux_UnknownLinux:
@@ -234,6 +261,7 @@ ghcupDownloads:
         dlUri: https://downloads.haskell.org/~ghc/8.2.2/ghc-8.2.2-src.tar.xz
         dlSubdir: ghc-8.2.2
         dlHash: bb8ec3634aa132d09faa270bbd604b82dfa61f04855655af6f9d14a9eedc05fc
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -251,7 +279,7 @@ ghcupDownloads:
             unknown_versioning: *ghc-822-64-deb8
           Linux_Alpine:
             unknown_versioning:
-              dlUri: https://files.hasufell.de/ghc/ghc-8.2.2-x86_64-alpine-linux.tar.xz
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.2.2/ghc-8.2.2-x86_64-alpine-linux.tar.xz
               dlSubdir: ghc-8.2.2
               dlHash: adcf3a320a3c402aba07ae9586990dc3c0b550e96aeffb1b9e194313d3ba716d
           Linux_UnknownLinux:
@@ -287,7 +315,7 @@ ghcupDownloads:
             unknown_versioning: *ghc-822-32-deb8
           Linux_Alpine:
             unknown_versioning:
-              dlUri: https://files.hasufell.de/ghc/ghc-8.2.2-i386-alpine-linux.tar.xz
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.2.2/ghc-8.2.2-i386-alpine-linux.tar.xz
               dlSubdir: ghc-8.2.2
               dlHash: 467534c32552cfd318753112dbc70af003693aad4b0081f2a07e61f5b5ea2c22
           Linux_UnknownLinux:
@@ -301,6 +329,7 @@ ghcupDownloads:
         dlUri: https://downloads.haskell.org/~ghc/8.4.1/ghc-8.4.1-src.tar.xz
         dlSubdir: ghc-8.4.1
         dlHash: 39ae2f25192408f355693e5a3c8b6ff613ddb7c4da998fdf26210143a61839d2
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -350,6 +379,7 @@ ghcupDownloads:
         dlUri: https://downloads.haskell.org/~ghc/8.4.2/ghc-8.4.2-src.tar.xz
         dlSubdir: ghc-8.4.2
         dlHash: 01cc32f24a06bf3b2428351b6d7fec791e82d042426d29ad9e5a245b35f0047b
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -404,6 +434,7 @@ ghcupDownloads:
         dlUri: https://downloads.haskell.org/~ghc/8.4.3/ghc-8.4.3-src.tar.xz
         dlSubdir: ghc-8.4.3
         dlHash: ae47afda985830de8811243255aa3744dfb9207cb980af74393298b2b62160d6
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -452,6 +483,7 @@ ghcupDownloads:
         dlUri: https://downloads.haskell.org/~ghc/8.4.4/ghc-8.4.4-src.tar.xz
         dlSubdir: ghc-8.4.4
         dlHash: 11117735a58e507c481c09f3f39ae5a314e9fbf49fc3109528f99ea7959004b2
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -482,7 +514,7 @@ ghcupDownloads:
             unknown_versioning: *ghc-844-64-centos
           Linux_Alpine:
             unknown_versioning:
-              dlUri: https://files.hasufell.de/ghc/ghc-8.4.4-x86_64-alpine-linux.tar.xz
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.4.4/ghc-8.4.4-x86_64-alpine-linux.tar.xz
               dlSubdir: ghc-8.4.4
               dlHash: 336affff8314d3dc5e85d9c09015ae2ba8a7658b459c8c8ae77ecaa551a56ae7
           Linux_AmazonLinux:
@@ -511,7 +543,7 @@ ghcupDownloads:
             unknown_versioning: *ghc-844-32-deb8
           Linux_Alpine:
             unknown_versioning:
-              dlUri: https://files.hasufell.de/ghc/ghc-8.4.4-i386-alpine-linux.tar.xz
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.4.4/ghc-8.4.4-i386-alpine-linux.tar.xz
               dlSubdir: ghc-8.4.4
               dlHash: 892888d388ef5c9cadf5cfba1146d62237c25b9b066fb62fee940b2b285fd308
           Linux_UnknownLinux:
@@ -525,6 +557,7 @@ ghcupDownloads:
         dlUri: https://downloads.haskell.org/~ghc/8.6.1/ghc-8.6.1-src.tar.xz
         dlSubdir: ghc-8.6.1
         dlHash: 2c25c26d1e5c47c7cbb2a1d8e6456524033e7a71409184dd3125e3fc5a3c7036
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -579,6 +612,7 @@ ghcupDownloads:
         dlUri: https://downloads.haskell.org/~ghc/8.6.2/ghc-8.6.2-src.tar.xz
         dlSubdir: ghc-8.6.2
         dlHash: caaa819d21280ecde90a4773143dee188711e9ff175a27cfbaee56eb851d76d5
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -624,6 +658,7 @@ ghcupDownloads:
         dlUri: https://downloads.haskell.org/~ghc/8.6.3/ghc-8.6.3-src.tar.xz
         dlSubdir: ghc-8.6.3
         dlHash: 9f9e37b7971935d88ba80426c36af14b1e0b3ec1d9c860f44a4391771bc07f23
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -687,6 +722,7 @@ ghcupDownloads:
         dlUri: https://downloads.haskell.org/~ghc/8.6.4/ghc-8.6.4-src.tar.xz
         dlSubdir: ghc-8.6.4
         dlHash: 5b5d07e4463203a433c3ed3df461ba6cce11b6d2b9b264db31f3429075d0303a
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -735,6 +771,7 @@ ghcupDownloads:
         dlUri: https://downloads.haskell.org/~ghc/8.6.5/ghc-8.6.5-src.tar.xz
         dlSubdir: ghc-8.6.5
         dlHash: 4d4aa1e96f4001b934ac6193ab09af5d6172f41f5a5d39d8e43393b9aafee361
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -765,7 +802,7 @@ ghcupDownloads:
             unknown_versioning: *ghc-865-64-centos
           Linux_Alpine:
             unknown_versioning:
-              dlUri: https://files.hasufell.de/ghc/ghc-8.6.5-x86_64-alpine-linux.tar.xz
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.6.5/ghc-8.6.5-x86_64-alpine-linux.tar.xz
               dlSubdir: ghc-8.6.5
               dlHash: b9d3ed7f7aa24ef2d58bb579252289caa0b8877adee3685e3af2fb73d440afdc
           Linux_AmazonLinux:
@@ -779,7 +816,7 @@ ghcupDownloads:
               dlHash: dfc1bdb1d303a87a8552aa17f5b080e61351f2823c2b99071ec23d0837422169
           FreeBSD:
             unknown_versioning:
-              dlUri: https://files.hasufell.de/ghc/ghc-8.6.5-x86_64-portbld-freebsd.tar.xz
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.6.5/ghc-8.6.5-x86_64-portbld-freebsd.tar.xz
               dlSubdir: ghc-8.6.5
               dlHash: 83a3059a630d40a98e26cb5b520354e12094a96e36ba2f5ab002dad94cf2fb37
         A_32:
@@ -794,11 +831,17 @@ ghcupDownloads:
             unknown_versioning: *ghc-865-32-deb9
           Linux_Alpine:
             unknown_versioning:
-              dlUri: https://files.hasufell.de/ghc/ghc-8.6.5-i386-alpine-linux.tar.xz
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.6.5/ghc-8.6.5-i386-alpine-linux.tar.xz
               dlSubdir: ghc-8.6.5
               dlHash: 3737837550d9b177acfe150e3a3cd4545427ded020487c2ed5194d7b8f116349
           Linux_UnknownLinux:
             unknown_versioning: *ghc-865-32-deb9
+        A_ARM64:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.6.5/ghc-8.6.5-aarch64-ubuntu18.04-linux.tar.xz
+              dlSubdir: ghc-8.6.5
+              dlHash: 1852589037e4b2805ab517bc430e25a3125c4a118a1674ffefbb443394a0c786
     8.8.1:
       viTags:
       - base-4.13.0.0
@@ -808,6 +851,7 @@ ghcupDownloads:
         dlUri: https://downloads.haskell.org/~ghc/8.8.1/ghc-8.8.1-src.tar.xz
         dlSubdir: ghc-8.8.1
         dlHash: 908a83d9b814da74585de9d39687189e6260ec3848131f9d9236cab8a123721a
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -866,6 +910,7 @@ ghcupDownloads:
         dlUri: https://downloads.haskell.org/~ghc/8.8.2/ghc-8.8.2-src.tar.xz
         dlSubdir: ghc-8.8.2
         dlHash: 01cea54d90686b97bcc9960b108beaffccd4336dee930dcf9beaf52b1f370a0b
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -924,6 +969,7 @@ ghcupDownloads:
         dlUri: https://downloads.haskell.org/~ghc/8.8.3/ghc-8.8.3-src.tar.xz
         dlSubdir: ghc-8.8.3
         dlHash: e0dcc0aaf3e234c5978f29e6df62947e97720ab404ec0158343df211c5480f89
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -963,7 +1009,7 @@ ghcupDownloads:
               dlHash: 7016de90dd226b06fc79d0759c5d4c83c2ab01d8c678905442c28bd948dbb782
           FreeBSD:
             unknown_versioning:
-              dlUri: https://files.hasufell.de/ghc/ghc-8.8.3-x86_64-portbld-freebsd.tar.xz
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.8.3/ghc-8.8.3-x86_64-portbld-freebsd.tar.xz
               dlSubdir: ghc-8.8.3
               dlHash: 569719075b4d14b3875a899df522090ae31e6fe085e6dffe518e875b09a2f0be
         A_32:
@@ -978,6 +1024,12 @@ ghcupDownloads:
             unknown_versioning: *ghc-883-32-deb9
           Linux_UnknownLinux:
             unknown_versioning: *ghc-883-32-deb9
+        A_ARM64:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.8.3/ghc-8.8.3-aarch64-deb9-linux.tar.xz
+              dlSubdir: ghc-8.8.3
+              dlHash: 2a6821d0e7326cfa7670851702924bbab3b092415ba41247c37419158327eed9
     8.8.4:
       viTags:
       - base-4.13.0.0
@@ -986,6 +1038,7 @@ ghcupDownloads:
         dlUri: https://downloads.haskell.org/~ghc/8.8.4/ghc-8.8.4-src.tar.xz
         dlSubdir: ghc-8.8.4
         dlHash: f0505e38b2235ff9f1090b51f44d6c8efd371068e5a6bb42a2a6d8b67b5ffc2d
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -1016,7 +1069,7 @@ ghcupDownloads:
             unknown_versioning: *ghc-884-64-centos
           Linux_Alpine:
             unknown_versioning:
-              dlUri: https://files.hasufell.de/ghc/ghc-8.8.4-x86_64-alpine-linux.tar.xz
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.8.4/ghc-8.8.4-x86_64-alpine-linux.tar.xz
               dlSubdir: ghc-8.8.4
               dlHash: 90c6a1661de7f20c7d169cd6270125035b3332063e45103ce028df0beecf434e
           Linux_AmazonLinux:
@@ -1030,7 +1083,7 @@ ghcupDownloads:
               dlHash: e80a789e9d8cfb41dd87f3284b75432427c4461c1731d220d04ead8733ccdb5e
           FreeBSD:
             unknown_versioning:
-              dlUri: https://files.hasufell.de/ghc/ghc-8.8.4-x86_64-portbld-freebsd.tar.xz
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.8.4/ghc-8.8.4-x86_64-portbld-freebsd.tar.xz
               dlSubdir: ghc-8.8.4
               dlHash: 8cebe5ccf454e82acd1ff52ca57590d1ab0f3f44a981b46257ec12158c8c447e
         A_32:
@@ -1045,7 +1098,7 @@ ghcupDownloads:
             unknown_versioning: *ghc-884-32-deb9
           Linux_Alpine:
             unknown_versioning:
-              dlUri: https://files.hasufell.de/ghc/ghc-8.8.4-i386-alpine-linux.tar.xz
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.8.4/ghc-8.8.4-i386-alpine-linux.tar.xz
               dlSubdir: ghc-8.8.4
               dlHash: 1d18e89ee031197e55c48683e78a7ffc67601ac5fd9f73aac555eb064b3859a2
           Linux_UnknownLinux:
@@ -1059,6 +1112,7 @@ ghcupDownloads:
         dlUri: https://downloads.haskell.org/~ghc/8.10.1/ghc-8.10.1-src.tar.xz
         dlSubdir: ghc-8.10.1
         dlHash: 4e3b07f83a266b3198310f19f71e371ebce97c769b14f0d688f4cbf2a2a1edf5
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -1106,7 +1160,7 @@ ghcupDownloads:
               dlHash: 65b1ca361093de4804a7e40b3e68178e1ef720f84f743641ec8d95e56a45b3a8
           FreeBSD:
             unknown_versioning:
-              dlUri: https://files.hasufell.de/ghc/ghc-8.10.1-x86_64-portbld-freebsd.tar.xz
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.10.1/ghc-8.10.1-x86_64-portbld-freebsd.tar.xz
               dlSubdir: ghc-8.10.1
               dlHash: e8646ec9b60fd40aa9505ee055f22f04601290ab7a1342c2cf37c34de9d3f142
         A_32:
@@ -1122,19 +1176,33 @@ ghcupDownloads:
             unknown_versioning: *ghc-8101-32-deb9
           Linux_Alpine:
             unknown_versioning:
-              dlUri: https://files.hasufell.de/ghc/ghc-8.10.1-i386-alpine-linux.tar.xz
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.10.1/ghc-8.10.1-i386-alpine-linux.tar.xz
               dlSubdir: ghc-8.10.1
               dlHash: 7360cc6b29e9b4ab08f6ea5bc3bcca6f5c216933e81ef1620dcdd700f1fdb289
           Linux_UnknownLinux:
             unknown_versioning: *ghc-8101-32-deb9
+        A_ARM64:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.1/ghc-8.10.1-aarch64-deb9-linux.tar.xz
+              dlSubdir: ghc-8.10.1
+              dlHash: c099011e07999db917e797fb5d89c31f075a562556ab99be8ab0accbf2a94db7
+        A_ARM:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.1/ghc-8.10.1-armv7-deb9-linux.tar.xz
+              dlSubdir: ghc-8.10.1
+              dlHash: afe1bde2b0d6deb0320b9460fffe5d9427e302df85aec866b9c1458777d52b28
     8.10.2:
       viTags:
+      - old
       - base-4.14.1.0
       viChangeLog: https://downloads.haskell.org/~ghc/8.10.2/docs/html/users_guide/8.10.2-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.10.2/ghc-8.10.2-src.tar.xz
         dlSubdir: ghc-8.10.2
         dlHash: 9c573a4621a78723950617c223559bdc325ea6a3409264aedf68f05510b0880b
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -1200,18 +1268,30 @@ ghcupDownloads:
             unknown_versioning: *ghc-8102-32-deb9
           Linux_Alpine:
             unknown_versioning:
-              dlUri: https://files.hasufell.de/ghc/ghc-8.10.2-i386-alpine-linux.tar.xz
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.10.2/ghc-8.10.2-i386-alpine-linux.tar.xz
               dlSubdir: ghc-8.10.2
               dlHash: 9ee1cf1e85e9536088b3c9e80e975074e525ea378cd4eb156071bbc4b7b38327
+        A_ARM64:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.2/ghc-8.10.2-aarch64-deb10-linux.tar.xz
+              dlSubdir: ghc-8.10.2
+              dlHash: 5cf24189077e6e2dce2aa16367ad8a53f603e751a15010dfb23d067206e55593
+        A_ARM:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.2/ghc-8.10.2-armv7-deb10-linux.tar.xz
+              dlSubdir: ghc-8.10.2
+              dlHash: bb9c97826b1f4d7a8ef8bce0616b612f1ded10480ef10fcf7fb4e6d10a6681c8
     8.10.3:
       viTags:
-      - Recommended
       - base-4.14.1.0
       viChangeLog: https://downloads.haskell.org/~ghc/8.10.3/docs/html/users_guide/8.10.3-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-src.tar.xz
         dlSubdir: ghc-8.10.3
         dlHash: ccdc8319549028a708d7163e2967382677b1a5a379ff94d948195b5cf46eb931
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -1277,9 +1357,112 @@ ghcupDownloads:
             unknown_versioning: *ghc-8103-32-deb9
           Linux_Alpine:
             unknown_versioning:
-              dlUri: https://files.hasufell.de/ghc/ghc-8.10.3-i386-alpine-linux.tar.xz
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.10.3/ghc-8.10.3-i386-alpine-linux.tar.xz
               dlSubdir: ghc-8.10.3
               dlHash: 309201cdefd2d13b8b3fd09c26c6137048c490d219a0a9c7407c3ce1d011f60c
+        A_ARM64:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-aarch64-deb10-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: a531432d505a1fe886cdc8639d168eb1c92d76464c1270713e01ce81891bbadb
+        A_ARM:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-armv7-deb10-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: b823b58cae36fbac0741680ca7605180fa4cf4c6ae439123d282184b94d32fd6
+    8.10.4:
+      viTags:
+      - Recommended
+      - base-4.14.1.0
+      viChangeLog: https://downloads.haskell.org/~ghc/8.10.4/docs/html/users_guide/8.10.4-notes.html
+      viSourceDL:
+        dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-src.tar.xz
+        dlSubdir: ghc-8.10.4
+        dlHash: 52af871b4e08550257d720c2944ac85727d0b948407cef1bebfe7508c224910e
+      viPostRemove: *ghc-post-remove
+      viPreCompile: "If you have autoconf >= 2.70 you'll need this patch https://gitlab.haskell.org/ghc/ghc/-/snippets/2040 (see the --patchdir option)"
+      viArch:
+        A_64:
+          Linux_Debian:
+            '( >= 9 && < 10 )': &ghc-8104-64-deb9
+              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-x86_64-deb9-linux.tar.xz
+              dlSubdir: ghc-8.10.4
+              dlHash: 5694200a5c38f22c142baf850b1d2f3784211d2ec9302e11693259a1ae8e38b7
+            '( >= 10 && < 11 )': &ghc-8104-64-deb10
+              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-x86_64-deb10-linux.tar.xz
+              dlSubdir: ghc-8.10.4
+              dlHash: 816365565e9927459b035515a7db6a0db62f9796f327389b6f8a0035d12fbda0
+            unknown_versioning: *ghc-8104-64-deb9
+          Linux_Ubuntu:
+            unknown_versioning: &ghc-8104-64-fedora
+              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-x86_64-fedora27-linux.tar.xz
+              dlSubdir: ghc-8.10.4
+              dlHash: a189eed900a8717d6d7906bafd10b9a9a9688ad942d1c75e19df480376dff9ea
+            '( >= 16 && < 19 )': *ghc-8104-64-deb9
+          Linux_Mint:
+            unknown_versioning: *ghc-8104-64-deb10
+          Linux_Fedora:
+            '( >= 27 && < 28 )': *ghc-8104-64-fedora
+            unknown_versioning: *ghc-8104-64-fedora
+          Linux_CentOS:
+            '( >= 7 && < 8 )': &ghc-8104-64-centos
+              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-x86_64-centos7-linux.tar.xz
+              dlSubdir: ghc-8.10.4
+              dlHash: fb8a91f0cf06594172aff46c2f6f7486179e1c3760855c79fbdd3012598cc2cd
+            unknown_versioning: *ghc-8104-64-centos
+          Linux_RedHat:
+            unknown_versioning: *ghc-8104-64-centos
+          Linux_Alpine:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-x86_64-alpine3.10-linux-integer-simple.tar.xz
+              dlSubdir: ghc-8.10.4-x86_64-unknown-linux
+              dlHash: 74c2c07537832708502716ef4ec40019f8e552ddda13c8eadf8f7c4b03a79359
+          Linux_AmazonLinux:
+            unknown_versioning: *ghc-8104-64-centos
+          Linux_UnknownLinux:
+            unknown_versioning: *ghc-8104-64-fedora
+          Darwin:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-x86_64-apple-darwin.tar.xz
+              dlSubdir: ghc-8.10.4
+              dlHash: 725ecf6543e63b81a3581fb8c97afd21a08ae11bc0fa4f8ee25d45f0362ef6d5
+          FreeBSD:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-x86_64-portbld-freebsd.tar.xz
+              dlSubdir: ghc-8.10.4
+              dlHash: c9776a2ccf9629b03e967206a507fcdcb6c5189800a626e9461ababf6733c357
+        A_32:
+          Linux_Debian:
+            '( >= 9 && < 10 )': &ghc-8104-32-deb9
+              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-i386-deb9-linux.tar.xz
+              dlSubdir: ghc-8.10.4
+              dlHash: 0022c5b9ac22825bb7b4745af3d92cef0ba1ecd01fab3ef387ddbd47146569ad
+            unknown_versioning: *ghc-8104-32-deb9
+          Linux_Ubuntu:
+            unknown_versioning: *ghc-8104-32-deb9
+          Linux_Mint:
+            unknown_versioning: *ghc-8104-32-deb9
+          Linux_UnknownLinux:
+            unknown_versioning: *ghc-8104-32-deb9
+          Linux_Alpine:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.10.4/ghc-8.10.4-i386-alpine-linux.tar.xz
+              dlSubdir: ghc-8.10.4
+              dlHash: 9161a98bed763692101854d83af69c1316030cfe5ee6f6acde283d04ef139735
+        A_ARM64:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-aarch64-deb10-linux.tar.xz
+              dlSubdir: ghc-8.10.4
+              dlHash: 249da6310be799a5eefe0579b6dae1701eb984afb980fe08309d19cf704038ed
+        A_ARM:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-armv7-deb10-linux.tar.xz
+              dlSubdir: ghc-8.10.4
+              dlHash: 0d18ef83593272f6196a41cc3abdc48dfe5e14372db75d71ea19fe35320c4e81
     9.0.1:
       viTags:
       - Latest
@@ -1289,6 +1472,7 @@ ghcupDownloads:
         dlUri: https://downloads.haskell.org/~ghc/9.0.1/ghc-9.0.1-src.tar.xz
         dlSubdir: ghc-9.0.1
         dlHash: a5230314e4065f9fcc371dfe519748fd85c825b279abf72a24e09b83578a35f9
+      viPostRemove: *ghc-post-remove
       viArch:
         A_64:
           Linux_Debian:
@@ -1352,6 +1536,23 @@ ghcupDownloads:
             unknown_versioning: *ghc-901-32-deb9
           Linux_UnknownLinux:
             unknown_versioning: *ghc-901-32-deb9
+          Linux_Alpine:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/9.0.1/ghc-9.0.1-i386-alpine-linux.tar.xz
+              dlSubdir: ghc-9.0.1
+              dlHash: ebfeb3b91e6f2bb5a49fd3376746f7fd1b89e62e9838bf5b1530a8756ff1e6aa
+        A_ARM64:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/9.0.1/ghc-9.0.1-aarch64-deb9-linux.tar.xz
+              dlSubdir: ghc-9.0.1
+              dlHash: fac7a0bdfc83c05df94024a2d67b8f00a9cd2733b9cb41fb8ad76be399014906
+        A_ARM:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/9.0.1/ghc-9.0.1-armv7-deb9-linux.tar.xz
+              dlSubdir: ghc-9.0.1
+              dlHash: 6f404f9b88468407b3a9ec5800bcc2d01dd453ef3d63414853b4fbbd4d8df496
   Cabal:
     2.4.1.0:
       viTags:
@@ -1418,8 +1619,7 @@ ghcupDownloads:
               dlHash: 6898ccd6e6dc0872999c06daaf61d546164e12f60a1880d09852c9f0c59c5cf6
     3.2.0.0:
       viTags:
-      - Recommended
-      - Latest
+      - old
       viChangeLog: https://downloads.haskell.org/~cabal/cabal-install-3.2.0.0/changelog
       viArch:
         A_64:
@@ -1448,32 +1648,52 @@ ghcupDownloads:
             unknown_versioning:
               dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.2.0.0/cabal-install-3.2.0.0-i386-unknown-linux.tar.xz
               dlHash: 2b3ac28549916de5f3379241797eaf60e84b6c001f2abbe73d9fadbbaf768e93
-    3.4.0.0-rc4:
+    3.4.0.0:
       viTags:
-      - Prerelease
+      - Recommended
+      - Latest
       viChangeLog: https://github.com/haskell/cabal/blob/master/release-notes/cabal-install-3.4.0.0.md
       viArch:
         A_64:
           Linux_Ubuntu:
-            unknown_versioning: &cabal-3400rc4-ubuntu
-              dlUri: http://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-ubuntu-16.04.tar.xz
-              dlHash: a1be168876816a624b206c55596d9bb5f442541c889ee2438d664698122b9ffe
+            unknown_versioning: &cabal-3400-ubuntu
+              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.4.0.0/cabal-install-3.4.0.0-x86_64-ubuntu-16.04.tar.xz
+              dlHash: cf28f9ffd763476aa2b1730d85cbf155d366fac541f78ee3951e8cb2d6de63e6
           Linux_Alpine:
             unknown_versioning:
-              dlUri: http://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-alpine-3.11.6-static-noofd.tar.xz
-              dlHash: 49dab6684483594e4c7c3e561ec477268002605253ad34701b471277efbe91bc
+              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.4.0.0/cabal-install-3.4.0.0-x86_64-alpine-3.11.6-static-noofd.tar.xz
+              dlHash: c74073fe79110946182e522fcadc8dcabf07c87583e8cf7801ed4e0c327241f6
           Linux_UnknownLinux:
-            unknown_versioning: *cabal-3400rc4-ubuntu
+            unknown_versioning: *cabal-3400-ubuntu
           Darwin:
             unknown_versioning:
-              dlUri: http://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-darwin-sierra.tar.xz
-              dlHash: a3f809a3388e90b9fdf52444e30ea9aad3894e2cbe53c37fc3311ceb106eda9e
+              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.4.0.0/cabal-install-3.4.0.0-x86_64-darwin-sierra.tar.xz
+              dlHash: cb10be9a53e856aa2d852fd88fb6944f138783ffe0ea84d93c9a69244e34ea91
           FreeBSD:
             unknown_versioning:
-              dlUri: http://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-freebsd-12.1-release.tar.xz
-              dlHash: 9705e16d03497b46be4ad477e6c64d10890af853eafa8a9adf6dba89aa9e05f7
+              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.4.0.0/cabal-install-3.4.0.0-x86_64-freebsd-12.1-release.tar.xz
+              dlHash: a1e2db664ec00e42a1e071a4181f6476f6e0bad321f1ddc0cf27831119f4c6d4
+        A_32:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.4.0.0/cabal-install-3.4.0.0-i386-debian-9.tar.xz
+              dlHash: ef3750644a53f7b1fad141b2ad02d4c7a3b239ec0cbfa7f0528fb02c1dfcebce
+          Linux_Alpine:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/cabal/3.4.0.0/cabal-install-3.4.0.0-i386-alpine-linux-musl.tar.gz
+              dlHash: 95adb65f3a72aa8d9ce83685bc06e1eee5b801f56e204e27e957e8a35abd9cf8
+        A_ARM64:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.4.0.0/cabal-install-3.4.0.0-aarch64-ubuntu-18.04.tar.xz
+              dlHash: 04d378347896dfdc3510b192b97489815cfa5d692f46e2758da0f789e682b8f0
+        A_ARM:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal/3.4.0.0/cabal-install-3.4.0.0-armv7-linux-bootstrapped.tar.xz
+              dlHash: 16c0d1eaba24bed14f3e152970179a45d9f9bb5cc839b2c210ad06eb7d4826ed
   GHCup:
-    0.1.12:
+    0.1.14:
       viTags:
       - Recommended
       - Latest
@@ -1483,40 +1703,51 @@ ghcupDownloads:
         A_64:
           Linux_UnknownLinux:
             unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-linux-ghcup-0.1.12
-              dlHash: 83088569ddf2d35df494f440dedd9c8eb2a53276d665f7de731f6554986c2ddb
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-linux-ghcup-0.1.14
+              dlHash: e9b314d248f4d4604ce64cee1be7161c77c8940efd11986c9205779ec3b598dd
           Darwin:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-apple-darwin-ghcup-0.1.12
-              dlHash: 1336efb0851e1ed267838f97f6c36cbceb5363ad0ae359f04f1bc43d0c5f2cef
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-apple-darwin-ghcup-0.1.14
+              dlHash: 69ede9db36c0ae631b679fceb87dd856d4753ee26f33610da37dd7a694809919
           FreeBSD:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-portbld-freebsd-ghcup-0.1.12
-              dlHash: a72123e972a53d667574c7d276a81842701a07fce2b434e4d856e561c34772fe
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/x86_64-portbld-freebsd-ghcup-0.1.14
+              dlHash: 68b09404cf49061da539463f42f8ad67c9cef5c5d3f68a3c7c4f6760e8442bb9
           Linux_Alpine:
             unknown_versioning: *ghcup-64
         A_32:
           Linux_UnknownLinux:
             unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/i386-linux-ghcup-0.1.12
-              dlHash: 4bc79a272dfcd16143f08d9f8e33f2fef66dc53f3a0659bdab56ac3cbecf9e84
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/i386-linux-ghcup-0.1.14
+              dlHash: ecb1157f010d2421764c52ab0cdbbf9a5c3da555827172c7b904d5f3f96c80fa
           Linux_Alpine:
             unknown_versioning: *ghcup-32
+        A_ARM64:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/aarch64-linux-ghcup-0.1.14
+              dlHash: 78a15f8a03917a89b67536af0993d7526d2722248a3a5cd8c500adffd7cd7691
+        A_ARM:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.14/armv7-linux-ghcup-0.1.14
+              dlHash: 5484dc9e16553c3d1707a9f83404c3c795dc01d01ef998cf173caf960abe793b
   HLS:
-    0.9.0:
+    1.0.0:
       viTags:
         - Recommended
         - Latest
-      viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#090
+      viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#100
+      viPostInstall: "This is just the server part of your LSP configuration. Consult the README on how to configure HLS, your project and your LSP client in your editor: https://github.com/haskell/haskell-language-server/blob/master/README.md"
       viArch:
         A_64:
           Linux_UnknownLinux:
             unknown_versioning: &hls-64
-              dlUri: https://github.com/haskell/haskell-language-server/releases/download/0.9.0/haskell-language-server-Linux-0.9.0.tar.gz
-              dlHash: 6933216e2fcdc51a32a828f7880403d83433b6585ff393da196f6db1d4e1e53f
+              dlUri: https://github.com/haskell/haskell-language-server/releases/download/1.0.0/haskell-language-server-Linux-1.0.0.tar.gz
+              dlHash: 4fab18998c5f67118a26b75b059f3b3e2ad345b6325515a552d1a24cdf87ed3f
           Darwin:
             unknown_versioning:
-              dlUri: https://github.com/haskell/haskell-language-server/releases/download/0.9.0/haskell-language-server-macOS-0.9.0.tar.gz
-              dlHash: f6197977941e803e128889f1170bebca97a80c1b62234bf5c7b1032ab3df68f4
+              dlUri: https://github.com/haskell/haskell-language-server/releases/download/1.0.0/haskell-language-server-macOS-1.0.0.tar.gz
+              dlHash: 74e7624c889c0235f0b02d7e7f164d5eb95b611d584fc8602f0b3a099b73f8be
           Linux_Alpine:
             unknown_versioning: *hls-64

ghcup.cabal

@@ -1,6 +1,6 @@
 cabal-version:      3.0
 name:               ghcup
-version:            0.1.12
+version:            0.1.14
 synopsis:           ghc toolchain installer as an exe/library
 description:
   A rewrite of the shell script ghcup, for providing
@@ -52,7 +52,7 @@ common async
   build-depends: async >=0.8
 
 common base
-  build-depends: base >=4.12 && <5
+  build-depends: base >=4.13 && <5
 
 common base16-bytestring
   build-depends: base16-bytestring >= 0.1.1.6
@@ -150,6 +150,9 @@ common optparse-applicative
 common parsec
   build-depends: parsec >=3.1
 
+common pretty
+  build-depends: pretty >=1.1.3.1
+
 common pretty-terminal
   build-depends: pretty-terminal >=0.1.0.0
 
@@ -169,7 +172,7 @@ common split
   build-depends: split >=0.2.3.4
 
 common streamly
-  build-depends: streamly >=0.7.1
+  build-depends: streamly >=0.7.3
 
 common streamly-posix
   build-depends: streamly-posix >=0.1.0.0
@@ -241,7 +244,7 @@ common yaml
   build-depends: yaml >=0.11.4.0
 
 common zlib
-  build-depends: zlib >=0.6.2.1
+  build-depends: zlib >=0.6.2.2
 
 common config
   default-language:   Haskell2010
@@ -288,6 +291,7 @@ library
     , optics
     , optics-vl
     , parsec
+    , pretty
     , pretty-terminal
     , regex-posix
     , resourcet
@@ -336,11 +340,13 @@ library
     GHCup.Utils.Version.QQ
     GHCup.Version
 
+  other-modules:
+    Paths_ghcup
+
   default-extensions:
     Strict
     StrictData
 
-  -- other-modules:
   -- other-extensions:
   hs-source-dirs:  lib
 
@@ -375,6 +381,7 @@ executable ghcup
     , monad-logger
     , mtl
     , optparse-applicative
+    , pretty
     , pretty-terminal
     , resourcet
     , safe
@@ -430,6 +437,7 @@ executable ghcup-gen
     , mtl
     , optics
     , optparse-applicative
+    , pretty
     , pretty-terminal
     , regex-posix
     , resourcet

hie.yaml

@@ -1,19 +1,10 @@
 cradle:
   cabal:
-    - path: "./lib"
-      component: "lib:ghcup"
-
-    - path: "./app/ghcup/Main.hs"
-      component: "ghcup:exe:ghcup"
-
-    - path: "./app/ghcup/BrickMain.hs"
-      component: "ghcup:exe:ghcup"
-
-    - path: "./app/ghcup-gen/Main.hs"
-      component: "ghcup:exe:ghcup-gen"
-
-    - path: "./app/ghcup-gen/Validate.hs"
-      component: "ghcup:exe:ghcup-gen"
-
-    - path: "./test"
-      component: "ghcup:test:ghcup-test"
+  - component: "ghcup:lib:ghcup"
+    path: ./lib
+  - component: "ghcup:exe:ghcup"
+    path: ./app/ghcup
+  - component: "ghcup:exe:ghcup-gen"
+    path: "./app/ghcup-gen"
+  - component: "ghcup:test:ghcup-test"
+    path: ./test

lib/GHCup.hs

@@ -123,10 +123,9 @@ installGHCBindist :: ( MonadFail m
                        m
                        ()
 installGHCBindist dlinfo ver pfreq = do
-  let tver = (mkTVer ver)
+  let tver = mkTVer ver
   lift $ $(logDebug) [i|Requested to install GHC with #{ver}|]
-  whenM (lift $ ghcInstalled tver)
-    $ (throwE $ AlreadyInstalled GHC ver)
+  whenM (lift $ ghcInstalled tver) (throwE $ AlreadyInstalled GHC ver)
 
   -- download (or use cached version)
   dl                           <- liftE $ downloadCached dlinfo Nothing
@@ -173,7 +172,7 @@ installPackedGHC :: ( MonadMask m
                        , ArchiveResult
 #endif
                        ] m ()
-installPackedGHC dl msubdir inst ver pfreq@(PlatformRequest {..}) = do
+installPackedGHC dl msubdir inst ver pfreq@PlatformRequest{..} = do
   -- unpack
   tmpUnpack <- lift mkGhcupTmpDir
   liftE $ unpackToDir tmpUnpack dl
@@ -182,7 +181,7 @@ installPackedGHC dl msubdir inst ver pfreq@(PlatformRequest {..}) = do
   -- the subdir of the archive where we do the work
   workdir <- maybe (pure tmpUnpack)
                    (liftE . intoSubdir tmpUnpack)
-                   (msubdir)
+                   msubdir
 
   liftE $ runBuildAction tmpUnpack
                          (Just inst)
@@ -201,11 +200,11 @@ installUnpackedGHC :: ( MonadReader AppState m
                    -> Version       -- ^ The GHC version
                    -> PlatformRequest
                    -> Excepts '[ProcessError] m ()
-installUnpackedGHC path inst ver (PlatformRequest {..}) = do
+installUnpackedGHC path inst ver PlatformRequest{..} = do
   lift $ $(logInfo) "Installing GHC (this may take a while)"
   lEM $ execLogged "./configure"
                    False
-                   (["--prefix=" <> toFilePath inst] ++ alpineArgs)
+                   (("--prefix=" <> toFilePath inst) : alpineArgs)
                    [rel|ghc-configure|]
                    (Just path)
                    Nothing
@@ -283,7 +282,7 @@ installCabalBindist :: ( MonadMask m
                           ]
                          m
                          ()
-installCabalBindist dlinfo ver (PlatformRequest {..}) = do
+installCabalBindist dlinfo ver PlatformRequest {..} = do
   lift $ $(logDebug) [i|Requested to install cabal version #{ver}|]
 
   AppState {dirs = Dirs {..}} <- lift ask
@@ -295,7 +294,7 @@ installCabalBindist dlinfo ver (PlatformRequest {..}) = do
           -- ignore when the installation is a legacy cabal (binary, not symlink)
           $ getSymbolicLinkStatus (toFilePath (binDir </> [rel|cabal|]))
       )
-    $ (throwE $ AlreadyInstalled Cabal ver)
+      (throwE $ AlreadyInstalled Cabal ver)
 
   -- download (or use cached version)
   dl                           <- liftE $ downloadCached dlinfo Nothing
@@ -311,12 +310,10 @@ installCabalBindist dlinfo ver (PlatformRequest {..}) = do
   liftE $ installCabal' workdir binDir
 
   -- create symlink if this is the latest version
-  cVers <- lift $ fmap rights $ getInstalledCabals
+  cVers <- lift $ fmap rights getInstalledCabals
   let lInstCabal = headMay . reverse . sort $ cVers
   when (maybe True (ver >=) lInstCabal) $ liftE $ setCabal ver
 
-  pure ()
-
  where
   -- | Install an unpacked cabal distribution.
   installCabal' :: (MonadLogger m, MonadCatch m, MonadIO m)
@@ -331,7 +328,7 @@ installCabalBindist dlinfo ver (PlatformRequest {..}) = do
     let destPath = inst </> destFileName
     handleIO (throwE . CopyError . show) $ liftIO $ copyFile
       (path </> cabalFile)
-      (destPath)
+      destPath
       Overwrite
     lift $ chmod_755 destPath
 
@@ -398,13 +395,13 @@ installHLSBindist :: ( MonadMask m
                         ]
                        m
                        ()
-installHLSBindist dlinfo ver (PlatformRequest {..}) = do
+installHLSBindist dlinfo ver PlatformRequest{..} = do
   lift $ $(logDebug) [i|Requested to install hls version #{ver}|]
 
   AppState {dirs = Dirs {..}} <- lift ask
 
   whenM (lift (hlsInstalled ver))
-    $ (throwE $ AlreadyInstalled HLS ver)
+    (throwE $ AlreadyInstalled HLS ver)
 
   -- download (or use cached version)
   dl                           <- liftE $ downloadCached dlinfo Nothing
@@ -420,12 +417,10 @@ installHLSBindist dlinfo ver (PlatformRequest {..}) = do
   liftE $ installHLS' workdir binDir
 
   -- create symlink if this is the latest version
-  hlsVers <- lift $ fmap rights $ getInstalledHLSs
+  hlsVers <- lift $ fmap rights getInstalledHLSs
   let lInstHLS = headMay . reverse . sort $ hlsVers
   when (maybe True (ver >=) lInstHLS) $ liftE $ setHLS ver
 
-  pure ()
-
  where
   -- | Install an unpacked hls distribution.
   installHLS' :: (MonadFail m, MonadLogger m, MonadCatch m, MonadIO m)
@@ -525,7 +520,7 @@ setGHC ver sghc = do
   let verBS = verToBS (_tvVersion ver)
   ghcdir                        <- lift $ ghcupGHCDir ver
 
-  whenM (lift $ fmap not $ ghcInstalled ver) (throwE (NotInstalled GHC (ver ^. tvVersion % to prettyVer)))
+  whenM (lift $ not <$> ghcInstalled ver) (throwE (NotInstalled GHC ver))
 
   -- symlink destination
   AppState { dirs = Dirs {..} } <- lift ask
@@ -603,9 +598,9 @@ setCabal ver = do
   AppState {dirs = Dirs {..}} <- lift ask
   liftIO $ createDirRecursive' binDir
 
-  whenM (liftIO $ fmap not $ doesFileExist (binDir </> targetFile))
+  whenM (liftIO $ not <$> doesFileExist (binDir </> targetFile))
     $ throwE
-    $ NotInstalled Cabal (prettyVer ver)
+    $ NotInstalled Cabal (GHCTargetVersion Nothing ver)
 
   let cabalbin = binDir </> [rel|cabal|]
 
@@ -647,7 +642,7 @@ setHLS ver = do
 
   -- set haskell-language-server-<ghcver> symlinks
   bins <- lift $ hlsServerBinaries ver
-  when (bins == []) $ throwE $ NotInstalled HLS (prettyVer ver)
+  when (null bins) $ throwE $ NotInstalled HLS (GHCTargetVersion Nothing ver)
 
   forM_ bins $ \f -> do
     let destL = toFilePath f
@@ -705,7 +700,7 @@ data ListResult = ListResult
 -- | Extract all available tool versions and their tags.
 availableToolVersions :: GHCupDownloads -> Tool -> Map.Map Version [Tag]
 availableToolVersions av tool = view
-  (at tool % non Map.empty % to (fmap (_viTags)))
+  (at tool % non Map.empty % to (fmap _viTags))
   av
 
 
@@ -733,13 +728,13 @@ listVersions av lt criteria pfreq = do
       case t of
         GHC -> do
           slr <- strayGHCs avTools
-          pure $ (sort (slr ++ lr))
+          pure (sort (slr ++ lr))
         Cabal -> do
           slr <- strayCabals avTools
-          pure $ (sort (slr ++ lr))
+          pure (sort (slr ++ lr))
         HLS -> do
           slr <- strayHLS avTools
-          pure $ (sort (slr ++ lr))
+          pure (sort (slr ++ lr))
         GHCup -> pure lr
     Nothing -> do
       ghcvers   <- listVersions av (Just GHC) criteria pfreq
@@ -761,21 +756,21 @@ listVersions av lt criteria pfreq = do
           Nothing -> do
             lSet    <- fmap (maybe False (\(GHCTargetVersion _ v ) -> v == _tvVersion)) $ ghcSet Nothing
             fromSrc <- ghcSrcInstalled tver
-            hlsPowered <- fmap (elem _tvVersion) $ hlsGHCVersions
+            hlsPowered <- fmap (elem _tvVersion) hlsGHCVersions
             pure $ Just $ ListResult
               { lTool      = GHC
               , lVer       = _tvVersion
               , lCross     = Nothing
               , lTag       = []
               , lInstalled = True
-              , lStray     = maybe True (const False) (Map.lookup _tvVersion avTools)
+              , lStray     = isNothing (Map.lookup _tvVersion avTools)
               , lNoBindist = False
               , ..
               }
       Right tver@GHCTargetVersion{ .. } -> do
         lSet    <- fmap (maybe False (\(GHCTargetVersion _ v ) -> v == _tvVersion)) $ ghcSet _tvTarget
         fromSrc <- ghcSrcInstalled tver
-        hlsPowered <- fmap (elem _tvVersion) $ hlsGHCVersions
+        hlsPowered <- fmap (elem _tvVersion) hlsGHCVersions
         pure $ Just $ ListResult
           { lTool      = GHC
           , lVer       = _tvVersion
@@ -801,14 +796,14 @@ listVersions av lt criteria pfreq = do
         case Map.lookup ver avTools of
           Just _  -> pure Nothing
           Nothing -> do
-            lSet    <- fmap (maybe False (== ver)) $ cabalSet
+            lSet    <- fmap (== Just ver) cabalSet
             pure $ Just $ ListResult
               { lTool      = Cabal
               , lVer       = ver
               , lCross     = Nothing
               , lTag       = []
               , lInstalled = True
-              , lStray     = maybe True (const False) (Map.lookup ver avTools)
+              , lStray     = isNothing (Map.lookup ver avTools)
               , lNoBindist = False
               , fromSrc    = False -- actually, we don't know :>
               , hlsPowered = False
@@ -829,14 +824,14 @@ listVersions av lt criteria pfreq = do
         case Map.lookup ver avTools of
           Just _  -> pure Nothing
           Nothing -> do
-            lSet    <- fmap (maybe False (== ver)) $ hlsSet
+            lSet    <- fmap (== Just ver) hlsSet
             pure $ Just $ ListResult
               { lTool      = HLS
               , lVer       = ver
               , lCross     = Nothing
               , lTag       = []
               , lInstalled = True
-              , lStray     = maybe True (const False) (Map.lookup ver avTools)
+              , lStray     = isNothing (Map.lookup ver avTools)
               , lNoBindist = False
               , fromSrc    = False -- actually, we don't know :>
               , hlsPowered = False
@@ -856,11 +851,11 @@ listVersions av lt criteria pfreq = do
       lSet       <- fmap (maybe False (\(GHCTargetVersion _ v') -> v' == v)) $ ghcSet Nothing
       lInstalled <- ghcInstalled tver
       fromSrc    <- ghcSrcInstalled tver
-      hlsPowered <- fmap (elem v) $ hlsGHCVersions
+      hlsPowered <- fmap (elem v) hlsGHCVersions
       pure ListResult { lVer = v, lCross = Nothing , lTag = tags, lTool = t, lStray = False, .. }
     Cabal -> do
       let lNoBindist = isLeft $ getDownloadInfo Cabal v pfreq av
-      lSet <- fmap (maybe False (== v)) $ cabalSet
+      lSet <- fmap (== Just v) cabalSet
       lInstalled <- cabalInstalled v
       pure ListResult { lVer    = v
                       , lCross  = Nothing
@@ -886,7 +881,7 @@ listVersions av lt criteria pfreq = do
                       }
     HLS -> do
       let lNoBindist = isLeft $ getDownloadInfo HLS v pfreq av
-      lSet <- fmap (maybe False (== v)) $ hlsSet
+      lSet <- fmap (== Just v) hlsSet
       lInstalled <- hlsInstalled v
       pure ListResult { lVer    = v
                       , lCross  = Nothing
@@ -927,9 +922,9 @@ rmGHCVer :: ( MonadReader AppState m
          => GHCTargetVersion
          -> Excepts '[NotInstalled] m ()
 rmGHCVer ver = do
-  isSetGHC <- lift $ fmap (maybe False (== ver)) $ ghcSet (_tvTarget ver)
+  isSetGHC <- lift $ fmap (== Just ver) $ ghcSet (_tvTarget ver)
 
-  whenM (lift $ fmap not $ ghcInstalled ver) (throwE (NotInstalled GHC (ver ^. tvVersion % to prettyVer)))
+  whenM (lift $ fmap not $ ghcInstalled ver) (throwE (NotInstalled GHC ver))
   dir <- lift $ ghcupGHCDir ver
 
   -- this isn't atomic, order matters
@@ -960,8 +955,7 @@ rmGHCVer ver = do
 
   liftIO
     $ hideError doesNotExistErrorType
-    $ deleteFile
-    $ (baseDir </> [rel|share|])
+    $ deleteFile (baseDir </> [rel|share|])
 
 
 -- | Delete a cabal version. Will try to fix the @cabal@ symlink
@@ -970,17 +964,17 @@ rmCabalVer :: (MonadReader AppState m, MonadThrow m, MonadLogger m, MonadIO m, M
            => Version
            -> Excepts '[NotInstalled] m ()
 rmCabalVer ver = do
-  whenM (lift $ fmap not $ cabalInstalled ver) $ throwE (NotInstalled Cabal (prettyVer ver))
+  whenM (lift $ fmap not $ cabalInstalled ver) $ throwE (NotInstalled Cabal (GHCTargetVersion Nothing ver))
 
-  cSet      <- lift $ cabalSet
+  cSet      <- lift cabalSet
 
   AppState {dirs = Dirs {..}} <- lift ask
 
   cabalFile <- lift $ parseRel ("cabal-" <> verToBS ver)
   liftIO $ hideError doesNotExistErrorType $ deleteFile (binDir </> cabalFile)
 
-  when (maybe False (== ver) cSet) $ do
-    cVers <- lift $ fmap rights $ getInstalledCabals
+  when (Just ver == cSet) $ do
+    cVers <- lift $ fmap rights getInstalledCabals
     case headMay . reverse . sort $ cVers of
       Just latestver -> setCabal latestver
       Nothing        -> liftIO $ hideError doesNotExistErrorType $ deleteFile
@@ -993,23 +987,23 @@ rmHLSVer :: (MonadReader AppState m, MonadThrow m, MonadLogger m, MonadIO m, Mon
          => Version
          -> Excepts '[NotInstalled] m ()
 rmHLSVer ver = do
-  whenM (lift $ fmap not $ hlsInstalled ver) $ throwE (NotInstalled HLS (prettyVer ver))
+  whenM (lift $ fmap not $ hlsInstalled ver) $ throwE (NotInstalled HLS (GHCTargetVersion Nothing ver))
 
-  isHlsSet      <- lift $ hlsSet
+  isHlsSet      <- lift hlsSet
 
   AppState {dirs = Dirs {..}} <- lift ask
 
   bins <- lift $ hlsAllBinaries ver
   forM_ bins $ \f -> liftIO $ deleteFile (binDir </> f)
 
-  when (maybe False (== ver) isHlsSet) $ do
+  when (Just ver == isHlsSet) $ do
     -- delete all set symlinks
     oldSyms <- lift hlsSymlinks
     forM_ oldSyms $ \f -> do
       lift $ $(logDebug) [i|rm #{toFilePath (binDir </> f)}|]
       liftIO $ deleteFile (binDir </> f)
     -- set latest hls
-    hlsVers <- lift $ fmap rights $ getInstalledHLSs
+    hlsVers <- lift $ fmap rights getInstalledHLSs
     case headMay . reverse . sort $ hlsVers of
       Just latestver -> setHLS latestver
       Nothing        -> pure ()
@@ -1034,7 +1028,7 @@ getDebugInfo = do
   diGHCDir       <- lift ghcupGHCBaseDir
   let diCacheDir = cacheDir
   diArch         <- lE getArchitecture
-  diPlatform     <- liftE $ getPlatform
+  diPlatform     <- liftE getPlatform
   pure $ DebugInfo { .. }
 
 
@@ -1081,12 +1075,12 @@ compileGHC :: ( MonadMask m
                  ]
                 m
                 ()
-compileGHC dls tver bstrap jobs mbuildConfig patchdir aargs pfreq@(PlatformRequest {..})
+compileGHC dls tver bstrap jobs mbuildConfig patchdir aargs pfreq@PlatformRequest{..}
   = do
     lift $ $(logDebug) [i|Requested to compile: #{tver} with #{bstrap}|]
 
     alreadyInstalled <- lift $ ghcInstalled tver
-    alreadySet <- fmap (maybe False (==tver)) $ lift $ ghcSet (_tvTarget tver)
+    alreadySet <- fmap (== Just tver) $ lift $ ghcSet (_tvTarget tver)
 
     -- download source tarball
     dlInfo <-
@@ -1131,7 +1125,6 @@ compileGHC dls tver bstrap jobs mbuildConfig patchdir aargs pfreq@(PlatformReque
 
     -- restore
     when alreadySet $ liftE $ void $ setGHC tver SetGHCOnly
-    pure ()
 
  where
   defaultConf = case _tvTarget tver of
@@ -1165,29 +1158,28 @@ Stage1Only = YES|]
                       (Path Abs)  -- ^ output path of bindist
   compileBindist bghc ghcdir workdir = do
     lift $ $(logInfo) [i|configuring build|]
-    liftE $ checkBuildConfig
+    liftE checkBuildConfig
 
     AppState { dirs = Dirs {..} } <- lift ask
 
     forM_ patchdir $ \dir -> liftE $ applyPatches dir workdir
 
-    cEnv <- liftIO $ getEnvironment
+    cEnv <- liftIO getEnvironment
 
     if
-      | (_tvVersion tver) >= [vver|8.8.0|] -> do
+      | _tvVersion tver >= [vver|8.8.0|] -> do
         bghcPath <- case bghc of
           Right ghc' -> pure ghc'
           Left  bver -> do
             spaths <- catMaybes . fmap parseAbs <$> liftIO getSearchPath
-            (liftIO $ searchPath spaths bver) !? NotFoundInPATH bver
+            liftIO (searchPath spaths bver) !? NotFoundInPATH bver
         lEM $ execLogged
           "./configure"
           False
           (  ["--prefix=" <> toFilePath ghcdir]
-          ++ (maybe mempty
+          ++ maybe mempty
                     (\x -> ["--target=" <> E.encodeUtf8 x])
                     (_tvTarget tver)
-             )
           ++ fmap E.encodeUtf8 aargs
           )
           [rel|ghc-conf|]
@@ -1200,10 +1192,9 @@ Stage1Only = YES|]
           (  [ "--prefix=" <> toFilePath ghcdir
              , "--with-ghc=" <> either toFilePath toFilePath bghc
              ]
-          ++ (maybe mempty
-                    (\x -> ["--target=" <> E.encodeUtf8 x])
-                    (_tvTarget tver)
-             )
+          ++ maybe mempty
+                   (\x -> ["--target=" <> E.encodeUtf8 x])
+                   (_tvTarget tver)
           ++ fmap E.encodeUtf8 aargs
           )
           [rel|ghc-conf|]
@@ -1240,7 +1231,7 @@ Stage1Only = YES|]
       $ c
     tarName <-
       parseRel
-        [i|ghc-#{prettyTVer tver}-#{prettyPfReq pfreq}-#{cDigest}.tar#{takeExtension (toFilePath tar)}|]
+        [i|ghc-#{tVerToText tver}-#{pfReqToString pfreq}-#{cDigest}.tar#{takeExtension (toFilePath tar)}|]
     let tarPath = cacheDir </> tarName
     handleIO (throwE . CopyError . show) $ liftIO $ copyFile (workdir </> tar)
                                                              tarPath
@@ -1267,7 +1258,7 @@ Stage1Only = YES|]
 
    -- for cross, we need Stage1Only
     case _tvTarget tver of
-      Just _ -> when (not $ elem "Stage1Only = YES" lines') $ throwE
+      Just _ -> when ("Stage1Only = YES" `notElem` lines') $ throwE
         (InvalidBuildConfig
           [s|Cross compiling needs to be a Stage1 build, add "Stage1Only = YES" to your config!|]
         )
@@ -1308,18 +1299,30 @@ upgradeGHCup :: ( MonadMask m
 upgradeGHCup dls mtarget force pfreq = do
   AppState {dirs = Dirs {..}} <- lift ask
   lift $ $(logInfo) [i|Upgrading GHCup...|]
-  let latestVer = fromJust $ getLatest dls GHCup
+  let latestVer = fromJust $ fst <$> getLatest dls GHCup
   when (not force && (latestVer <= pvpToVersion ghcUpVer)) $ throwE NoUpdate
   dli   <- lE $ getDownloadInfo GHCup latestVer pfreq dls
   tmp   <- lift withGHCupTmpDir
   let fn = [rel|ghcup|]
   p <- liftE $ download dli tmp (Just fn)
-  let fullDest = fromMaybe (binDir </> fn) mtarget
-  liftIO $ hideError NoSuchThing $ deleteFile fullDest
+  let destDir = dirname destFile
+      destFile = fromMaybe (binDir </> fn) mtarget
+  lift $ $(logDebug) [i|mkdir -p #{toFilePath destDir}|]
+  liftIO $ createDirRecursive' destDir
+  lift $ $(logDebug) [i|rm -f #{toFilePath destFile}|]
+  liftIO $ hideError NoSuchThing $ deleteFile destFile
+  lift $ $(logDebug) [i|cp #{toFilePath p} #{toFilePath destFile}|]
   handleIO (throwE . CopyError . show) $ liftIO $ copyFile p
-                                                           fullDest
+                                                           destFile
                                                            Overwrite
-  lift $ chmod_755 fullDest
+  lift $ chmod_755 destFile
+
+  liftIO (isInPath destFile) >>= \b -> unless b $
+    lift $ $(logWarn) [i|"#{toFilePath (dirname destFile)}" is not in PATH! You have to add it in order to use ghcup.|]
+  liftIO (isShadowed destFile) >>= \case
+    Nothing -> pure ()
+    Just pa -> lift $ $(logWarn) [i|ghcup is shadowed by "#{toFilePath pa}". The upgrade will not be in effect, unless you remove "#{toFilePath pa}" or make sure "#{toFilePath destDir}" comes before "#{toFilePath (dirname pa)}" in PATH.|]
+
   pure latestVer
 
 

lib/GHCup/Download.hs

@@ -127,7 +127,7 @@ getDownloadsF urlSource = do
     GHCupURL -> liftE getBase
     (OwnSource url) -> do
       bs <- reThrowAll DownloadFailed $ downloadBS url
-      lE' JSONDecodeError $ bimap show id $ Y.decodeEither' (L.toStrict bs)
+      lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bs)
     (OwnSpec av) -> pure av
     (AddSource (Left ext)) -> do
       base <- liftE getBase
@@ -135,32 +135,10 @@ getDownloadsF urlSource = do
     (AddSource (Right uri)) -> do
       base <- liftE getBase
       bsExt <- reThrowAll DownloadFailed $ downloadBS uri
-      ext <- lE' JSONDecodeError $ bimap show id $ Y.decodeEither' (L.toStrict bsExt)
+      ext <- lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bsExt)
       pure (mergeGhcupInfo base ext)
- where
-  readFromCache :: (MonadIO m, MonadCatch m, MonadLogger m, MonadReader AppState m)
-                => Excepts '[JSONError, FileDoesNotExistError] m GHCupInfo
-  readFromCache = do
-    AppState {dirs = Dirs {..}} <- lift ask
-    lift $ $(logWarn)
-      [i|Could not get download info, trying cached version (this may not be recent!)|]
-    let path = view pathL' ghcupURL
-    yaml_file <- (cacheDir </>) <$> urlBaseName path
-    bs        <-
-      handleIO' NoSuchThing
-                (\_ -> throwE $ FileDoesNotExistError (toFilePath yaml_file))
-      $ liftIO
-      $ readFile yaml_file
-    lE' JSONDecodeError $ bimap show id $ Y.decodeEither' (L.toStrict bs)
 
-  getBase :: (MonadFail m, MonadIO m, MonadCatch m, MonadLogger m, MonadReader AppState m)
-          => Excepts '[JSONError , FileDoesNotExistError] m GHCupInfo
-  getBase =
-    handleIO (\_ -> readFromCache)
-    $ catchE @_ @'[JSONError, FileDoesNotExistError]
-        (\(DownloadFailed _) -> readFromCache)
-    $ ((reThrowAll @_ @_ @'[JSONError, DownloadFailed] DownloadFailed $ smartDl ghcupURL)
-      >>= (liftE . lE' @_ @_ @'[JSONError] JSONDecodeError . bimap show id . Y.decodeEither' . L.toStrict))
+    where
 
   mergeGhcupInfo :: GHCupInfo -- ^ base to merge with
                  -> GHCupInfo -- ^ extension overwriting the base
@@ -172,6 +150,32 @@ getDownloadsF urlSource = do
                            ) base
     in GHCupInfo tr new
 
+
+readFromCache :: (MonadIO m, MonadCatch m, MonadLogger m, MonadReader AppState m)
+              => Excepts '[JSONError, FileDoesNotExistError] m GHCupInfo
+readFromCache = do
+  AppState {dirs = Dirs {..}} <- lift ask
+  lift $ $(logWarn)
+    [i|Could not get download info, trying cached version (this may not be recent!)|]
+  let path = view pathL' ghcupURL
+  yaml_file <- (cacheDir </>) <$> urlBaseName path
+  bs        <-
+    handleIO' NoSuchThing
+              (\_ -> throwE $ FileDoesNotExistError (toFilePath yaml_file))
+    $ liftIO
+    $ readFile yaml_file
+  lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bs)
+
+
+getBase :: (MonadFail m, MonadIO m, MonadCatch m, MonadLogger m, MonadReader AppState m)
+        => Excepts '[JSONError , FileDoesNotExistError] m GHCupInfo
+getBase =
+  handleIO (\_ -> readFromCache)
+  $ catchE @_ @'[JSONError, FileDoesNotExistError]
+      (\(DownloadFailed _) -> readFromCache)
+  (reThrowAll @_ @_ @'[JSONError, DownloadFailed] DownloadFailed (smartDl ghcupURL)
+    >>= (liftE . lE' @_ @_ @'[JSONError] JSONDecodeError . first show . Y.decodeEither' . L.toStrict))
+    where
   -- First check if the json file is in the ~/.ghcup/cache dir
   -- and check it's access time. If it has been accessed within the
   -- last 5 minutes, just reuse it.
@@ -209,8 +213,8 @@ getDownloadsF urlSource = do
       then do
         accessTime <-
           PF.accessTimeHiRes
-            <$> (liftIO $ PF.getFileStatus (toFilePath json_file))
-        currentTime <- liftIO $ getPOSIXTime
+            <$> liftIO (PF.getFileStatus (toFilePath json_file))
+        currentTime <- liftIO getPOSIXTime
 
         -- access time won't work on most linuxes, but we can try regardless
         if (currentTime - accessTime) > 300
@@ -308,8 +312,8 @@ getDownloadInfo t v (PlatformRequest a p mv) dls = maybe
     in  fmap snd
           .   find
                 (\(mverRange, _) -> maybe
-                  (mv' == Nothing)
-                  (\range -> maybe False (flip versionRange range) mv')
+                  (isNothing mv')
+                  (\range -> maybe False (`versionRange` range) mv')
                   mverRange
                 )
           .   M.toList
@@ -361,7 +365,7 @@ download dli dest mfn
          (liftIO $ hideError doesNotExistErrorType $ deleteFile destFile)
      $ catchAllE @_ @'[ProcessError, DownloadFailed, UnsupportedScheme]
           (\e ->
-            (liftIO $ hideError doesNotExistErrorType $ deleteFile destFile)
+            liftIO (hideError doesNotExistErrorType $ deleteFile destFile)
               >> (throwE . DownloadFailed $ e)
           ) $ do
               lift getDownloader >>= \case
@@ -412,7 +416,7 @@ downloadCached dli mfn = do
       if
         | fileExists -> do
           liftE $ checkDigest dli cachfile
-          pure $ cachfile
+          pure cachfile
         | otherwise -> liftE $ download dli cacheDir mfn
     False -> do
       tmp <- lift withGHCupTmpDir
@@ -449,7 +453,7 @@ downloadBS uri'
   = dl False
   | scheme == "file"
   = liftIOException doesNotExistErrorType (FileDoesNotExistError path)
-    $ (liftIO $ RD.readFile path)
+    (liftIO $ RD.readFile path)
   | otherwise
   = throwE UnsupportedScheme
 

lib/GHCup/Download/IOStreams.hs

@@ -1,10 +1,6 @@
 {-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE DeriveGeneric         #-}
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE OverloadedStrings     #-}
-{-# LANGUAGE QuasiQuotes           #-}
-{-# LANGUAGE TemplateHaskell       #-}
-{-# LANGUAGE TypeApplications      #-}
 {-# LANGUAGE TypeFamilies          #-}
 
 
@@ -72,7 +68,7 @@ downloadBS' :: MonadIO m
                   , TooManyRedirs
                   ]
                  m
-                 (L.ByteString)
+                 L.ByteString
 downloadBS' https host path port = do
   bref <- liftIO $ newIORef (mempty :: Builder)
   let stepper bs = modifyIORef bref (<> byteString bs)
@@ -132,7 +128,7 @@ downloadInternal = go (5 :: Int)
           if
             | scode >= 200 && scode < 300 -> downloadStream r i' >> pure Nothing
             | scode >= 300 && scode < 400 -> case getHeader r "Location" of
-              Just r' -> pure $ Just $ r'
+              Just r' -> pure $ Just r'
               Nothing -> throwE NoLocationHeader
             | otherwise -> throwE $ HTTPStatusError scode
         )
@@ -151,7 +147,7 @@ downloadInternal = go (5 :: Int)
             Nothing -> 0
 
       mpb <- if progressBar
-        then Just <$> (liftIO $ newProgressBar defStyle 10 (Progress 0 size ()))
+        then Just <$> liftIO (newProgressBar defStyle 10 (Progress 0 size ()))
         else pure Nothing
 
       outStream <- liftIO $ Streams.makeOutputStream
@@ -224,9 +220,9 @@ headInternal = go (5 :: Int)
           if
             | scode >= 200 && scode < 300 -> do
               let headers = getHeaderMap r
-              pure $ Right $ headers
+              pure $ Right headers
             | scode >= 300 && scode < 400 -> case getHeader r "Location" of
-              Just r' -> pure $ Left $ r'
+              Just r' -> pure $ Left r'
               Nothing -> throwE NoLocationHeader
             | otherwise -> throwE $ HTTPStatusError scode
         )
@@ -243,7 +239,7 @@ withConnection' :: Bool
                 -> Maybe Int
                 -> (Connection -> IO a)
                 -> IO a
-withConnection' https host port action = bracket acquire closeConnection action
+withConnection' https host port = bracket acquire closeConnection
 
  where
   acquire = case https of

lib/GHCup/Download/Utils.hs

@@ -1,10 +1,6 @@
 {-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE DeriveGeneric         #-}
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE OverloadedStrings     #-}
-{-# LANGUAGE QuasiQuotes           #-}
-{-# LANGUAGE TemplateHaskell       #-}
-{-# LANGUAGE TypeApplications      #-}
 {-# LANGUAGE TypeFamilies          #-}
 
 
@@ -55,7 +51,7 @@ uriToQuadruple URI {..} = do
   let queryBS =
         BS.intercalate "&"
           . fmap (\(x, y) -> encodeQuery x <> "=" <> encodeQuery y)
-          $ (queryPairs uriQuery)
+          $ queryPairs uriQuery
       port =
         preview (_Just % authorityPortL' % _Just % portNumberL') uriAuthority
       fullpath = if BS.null queryBS then uriPath else uriPath <> "?" <> queryBS

lib/GHCup/Errors.hs

@@ -1,7 +1,12 @@
+{-# OPTIONS_GHC -Wno-orphans #-}
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds               #-}
 {-# LANGUAGE ExistentialQuantification #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE StandaloneDeriving #-}
-{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE QuasiQuotes           #-}
+{-# LANGUAGE TypeOperators           #-}
+{-# LANGUAGE FlexibleInstances           #-}
 
 {-|
 Module      : GHCup.Errors
@@ -15,13 +20,21 @@ Portability : POSIX
 module GHCup.Errors where
 
 import           GHCup.Types
+import           GHCup.Utils.Prelude
 
+#if !defined(TAR)
+import           Codec.Archive
+#endif
 import           Control.Exception.Safe
 import           Data.ByteString                ( ByteString )
+import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Versions
-import           Haskus.Utils.Variant
 import           HPath
+import           Haskus.Utils.Variant
+import           Text.PrettyPrint
+import           Text.PrettyPrint.HughesPJClass
+import           URI.ByteString
 
 
 
@@ -35,97 +48,203 @@ import           HPath
 data NoCompatiblePlatform = NoCompatiblePlatform String -- the platform we got
   deriving Show
 
+instance Pretty NoCompatiblePlatform where
+  pPrint (NoCompatiblePlatform str') =
+    text ("Could not find a compatible platform. Got: " ++ str')
+
 -- | Unable to find a download for the requested versio/distro.
 data NoDownload = NoDownload
   deriving Show
 
+instance Pretty NoDownload where
+  pPrint NoDownload =
+    text "Unable to find a download for the requested version/distro."
+
 -- | No update available or necessary.
 data NoUpdate = NoUpdate
   deriving Show
 
+instance Pretty NoUpdate where
+  pPrint NoUpdate = text "No update available or necessary."
+
 -- | The Architecture is unknown and unsupported.
 data NoCompatibleArch = NoCompatibleArch String
   deriving Show
 
+instance Pretty NoCompatibleArch where
+  pPrint (NoCompatibleArch arch) =
+    text ("The Architecture is unknown or unsupported. Got: " ++ arch)
+
 -- | Unable to figure out the distribution of the host.
 data DistroNotFound = DistroNotFound
   deriving Show
 
+instance Pretty DistroNotFound where
+  pPrint DistroNotFound =
+    text "Unable to figure out the distribution of the host."
+
 -- | The archive format is unknown. We don't know how to extract it.
 data UnknownArchive = UnknownArchive ByteString
   deriving Show
 
+instance Pretty UnknownArchive where
+  pPrint (UnknownArchive file) =
+    text [i|The archive format is unknown. We don't know how to extract the file "#{decUTF8Safe file}"|]
+
 -- | The scheme is not supported (such as ftp).
 data UnsupportedScheme = UnsupportedScheme
   deriving Show
 
+instance Pretty UnsupportedScheme where
+  pPrint UnsupportedScheme = text "The scheme is not supported (such as ftp)."
+
 -- | Unable to copy a file.
 data CopyError = CopyError String
   deriving Show
 
+instance Pretty CopyError where
+  pPrint (CopyError reason) =
+    text ("Unable to copy a file. Reason was: " ++ reason)
+
 -- | Unable to find a tag of a tool.
 data TagNotFound = TagNotFound Tag Tool
   deriving Show
 
+instance Pretty TagNotFound where
+  pPrint (TagNotFound tag tool) =
+    text "Unable to find tag" <+> pPrint tag <+> text [i|of tool "#{tool}"|]
+
+-- | Unable to find the next version of a tool (the one after the currently
+-- set one).
+data NextVerNotFound = NextVerNotFound Tool
+  deriving Show
+
+instance Pretty NextVerNotFound where
+  pPrint (NextVerNotFound tool) =
+    text [i|Unable to find next (the one after the currently set one) version of tool "#{tool}"|]
+
 -- | The tool (such as GHC) is already installed with that version.
 data AlreadyInstalled = AlreadyInstalled Tool Version
   deriving Show
 
+instance Pretty AlreadyInstalled where
+  pPrint (AlreadyInstalled tool ver') =
+    text [i|#{tool}-#{prettyShow ver'} is already installed|]
+
 -- | The tool is not installed. Some operations rely on a tool
 -- to be installed (such as setting the current GHC version).
-data NotInstalled = NotInstalled Tool Text
+data NotInstalled = NotInstalled Tool GHCTargetVersion
   deriving Show
 
+instance Pretty NotInstalled where
+  pPrint (NotInstalled tool ver) =
+    text [i|The version "#{prettyShow ver}" of the tool "#{tool}" is not installed.|]
+
 -- | An executable was expected to be in PATH, but was not found.
 data NotFoundInPATH = NotFoundInPATH (Path Rel)
   deriving Show
 
+instance Pretty NotFoundInPATH where
+  pPrint (NotFoundInPATH exe) =
+    text [i|The exe "#{decUTF8Safe . toFilePath $ exe}" was not found in PATH.|]
+
 -- | JSON decoding failed.
 data JSONError = JSONDecodeError String
   deriving Show
 
+instance Pretty JSONError where
+  pPrint (JSONDecodeError err) =
+    text [i|JSON decoding failed with: #{err}|]
+
 -- | A file that is supposed to exist does not exist
 -- (e.g. when we use file scheme to "download" something).
 data FileDoesNotExistError = FileDoesNotExistError ByteString
   deriving Show
 
+instance Pretty FileDoesNotExistError where
+  pPrint (FileDoesNotExistError file) =
+    text [i|File "#{decUTF8Safe file}" does not exist.|]
+
 data TarDirDoesNotExist = TarDirDoesNotExist TarDir
   deriving Show
 
+instance Pretty TarDirDoesNotExist where
+  pPrint (TarDirDoesNotExist dir) =
+    text "Tar directory does not exist:" <+> pPrint dir
+
 -- | File digest verification failed.
 data DigestError = DigestError Text Text
   deriving Show
 
+instance Pretty DigestError where
+  pPrint (DigestError currentDigest expectedDigest) =
+    text [i|Digest error: expected "#{expectedDigest}", but got "#{currentDigest}"|]
+
 -- | Unexpected HTTP status.
 data HTTPStatusError = HTTPStatusError Int
   deriving Show
 
+instance Pretty HTTPStatusError where
+  pPrint (HTTPStatusError status) =
+    text [i|Unexpected HTTP status: #{status}|]
+
 -- | The 'Location' header was expected during a 3xx redirect, but not found.
 data NoLocationHeader = NoLocationHeader
   deriving Show
 
+instance Pretty NoLocationHeader where
+  pPrint NoLocationHeader =
+    text [i|The 'Location' header was expected during a 3xx redirect, but not found.|]
+
 -- | Too many redirects.
 data TooManyRedirs = TooManyRedirs
   deriving Show
 
+instance Pretty TooManyRedirs where
+  pPrint TooManyRedirs =
+    text [i|Too many redirections.|]
+
 -- | A patch could not be applied.
 data PatchFailed = PatchFailed
   deriving Show
 
+instance Pretty PatchFailed where
+  pPrint PatchFailed =
+    text [i|A patch could not be applied.|]
+
 -- | The tool requirements could not be found.
 data NoToolRequirements = NoToolRequirements
   deriving Show
 
+instance Pretty NoToolRequirements where
+  pPrint NoToolRequirements =
+    text [i|The Tool requirements could not be found.|]
+
 data InvalidBuildConfig = InvalidBuildConfig Text
   deriving Show
 
+instance Pretty InvalidBuildConfig where
+  pPrint (InvalidBuildConfig reason) =
+    text [i|The build config is invalid. Reason was: #{reason}|]
+
+data NoToolVersionSet = NoToolVersionSet Tool
+  deriving Show
+
+instance Pretty NoToolVersionSet where
+  pPrint (NoToolVersionSet tool) =
+    text [i|No version is set for tool "#{tool}".|]
+
 
     -------------------------
     --[ High-level errors ]--
     -------------------------
 
 -- | A download failed. The underlying error is encapsulated.
-data DownloadFailed = forall es . Show (V es) => DownloadFailed (V es)
+data DownloadFailed = forall x xs . (Show x, Show (V xs), Pretty x, Pretty (V xs)) => DownloadFailed (V (x ': xs))
+
+instance Pretty DownloadFailed where
+  pPrint (DownloadFailed reason) =
+    text "Download failed:" <+> pPrint reason
 
 deriving instance Show DownloadFailed
 
@@ -133,12 +252,20 @@ deriving instance Show DownloadFailed
 -- | A build failed.
 data BuildFailed = forall es . Show (V es) => BuildFailed (Path Abs) (V es)
 
+instance Pretty BuildFailed where
+  pPrint (BuildFailed path reason) =
+    text [i|BuildFailed failed in dir "#{decUTF8Safe . toFilePath $ path}": #{reason}|]
+
 deriving instance Show BuildFailed
 
 
 -- | Setting the current GHC version failed.
 data GHCupSetError = forall es . Show (V es) => GHCupSetError (V es)
 
+instance Pretty GHCupSetError where
+  pPrint (GHCupSetError reason) =
+    text [i|Setting the current GHC version failed: #{reason}|]
+
 deriving instance Show GHCupSetError
 
 
@@ -151,11 +278,65 @@ deriving instance Show GHCupSetError
 data ParseError = ParseError String
   deriving Show
 
+instance Pretty ParseError where
+  pPrint (ParseError reason) =
+    text [i|Parsing failed: #{reason}|]
+
 instance Exception ParseError
 
 
 data UnexpectedListLength = UnexpectedListLength String
   deriving Show
 
+instance Pretty UnexpectedListLength where
+  pPrint (UnexpectedListLength reason) =
+    text [i|List length unexpected: #{reason}|]
+
 instance Exception UnexpectedListLength
 
+
+
+    ------------------------
+    --[ orphan instances ]--
+    ------------------------
+
+instance Pretty (V '[]) where
+   {-# INLINABLE pPrint #-}
+   pPrint _ = undefined
+
+instance
+   ( Pretty x
+   , Pretty (V xs)
+   ) => Pretty (V (x ': xs))
+   where
+      pPrint v = case popVariantHead v of
+         Right x -> pPrint x
+         Left xs -> pPrint xs
+
+instance Pretty URIParseError where
+  pPrint (MalformedScheme reason) =
+    text [i|Failed to parse URI. Malformed scheme: #{reason}|]
+  pPrint MalformedUserInfo =
+    text [i|Failed to parse URI. Malformed user info.|]
+  pPrint MalformedQuery =
+    text [i|Failed to parse URI. Malformed query.|]
+  pPrint MalformedFragment =
+    text [i|Failed to parse URI. Malformed fragment.|]
+  pPrint MalformedHost =
+    text [i|Failed to parse URI. Malformed host.|]
+  pPrint MalformedPort =
+    text [i|Failed to parse URI. Malformed port.|]
+  pPrint MalformedPath =
+    text [i|Failed to parse URI. Malformed path.|]
+  pPrint (OtherError err) =
+    text [i|Failed to parse URI: #{err}|]
+
+#if !defined(TAR)
+instance Pretty ArchiveResult where
+  pPrint ArchiveFatal = text "Archive result: fatal"
+  pPrint ArchiveFailed = text "Archive result: failed"
+  pPrint ArchiveWarn = text "Archive result: warning"
+  pPrint ArchiveRetry = text "Archive result: retry"
+  pPrint ArchiveOk = text "Archive result: Ok"
+  pPrint ArchiveEOF = text "Archive result: EOF"
+#endif

lib/GHCup/Platform.hs

@@ -92,17 +92,16 @@ getPlatform = do
       pure $ PlatformResult { _platform = Linux distro, _distroVersion = ver }
     "darwin" -> do
       ver <-
-        ( either (const Nothing) Just
+        either (const Nothing) Just
           . versioning
           -- TODO: maybe do this somewhere else
           . getMajorVersion
           . decUTF8Safe
-          )
-          <$> getDarwinVersion
+        <$> getDarwinVersion
       pure $ PlatformResult { _platform = Darwin, _distroVersion = ver }
     "freebsd" -> do
       ver <-
-        (either (const Nothing) Just . versioning . decUTF8Safe)
+        either (const Nothing) Just . versioning . decUTF8Safe
           <$> getFreeBSDVersion
       pure $ PlatformResult { _platform = FreeBSD, _distroVersion = ver }
     what -> throwE $ NoCompatiblePlatform what
@@ -157,7 +156,7 @@ getLinuxDistro = do
 
   try_os_release :: IO (Text, Maybe Text)
   try_os_release = do
-    Just (OsRelease { name = name, version_id = version_id }) <-
+    Just OsRelease{ name = name, version_id = version_id } <-
       fmap osRelease <$> parseOsRelease
     pure (T.pack name, fmap T.pack version_id)
 
@@ -174,7 +173,7 @@ getLinuxDistro = do
     let nameRegex n =
           makeRegexOpts compIgnoreCase
                         execBlank
-                        (([s|\<|] <> fS n <> [s|\>|] :: ByteString)) :: Regex
+                        ([s|\<|] <> fS n <> [s|\>|] :: ByteString) :: Regex
     let verRegex =
           makeRegexOpts compIgnoreCase
                         execBlank

lib/GHCup/Requirements.hs

@@ -49,8 +49,8 @@ getCommonRequirements pr tr =
     in  fmap snd
           .   find
                 (\(mverRange, _) -> maybe
-                  (mv' == Nothing)
-                  (\range -> maybe False (flip versionRange range) mv')
+                  (isNothing mv')
+                  (\range -> maybe False (`versionRange` range) mv')
                   mverRange
                 )
           .   M.toList

lib/GHCup/Types.hs

@@ -1,6 +1,8 @@
+{-# OPTIONS_GHC -Wno-orphans #-}
 {-# LANGUAGE CPP               #-}
 {-# LANGUAGE DeriveGeneric     #-}
 {-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE QuasiQuotes           #-}
 
 {-|
 Module      : GHCup.Types
@@ -15,12 +17,16 @@ module GHCup.Types where
 
 import           Data.Map.Strict                ( Map )
 import           Data.List.NonEmpty             ( NonEmpty (..) )
+import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Versions
 import           HPath
+import           Text.PrettyPrint.HughesPJClass (Pretty, pPrint, text)
 import           URI.ByteString
 
 import qualified Data.Text                     as T
+import qualified Data.Text.Encoding            as E
+import qualified Data.Text.Encoding.Error      as E
 import qualified GHC.Generics                  as GHC
 import qualified Graphics.Vty                  as Vty
 
@@ -85,10 +91,14 @@ data Tool = GHC
 -- | All necessary information of a tool version, including
 -- source download and per-architecture downloads.
 data VersionInfo = VersionInfo
-  { _viTags      :: [Tag]              -- ^ version specific tag
-  , _viChangeLog :: Maybe URI
-  , _viSourceDL  :: Maybe DownloadInfo -- ^ source tarball
-  , _viArch      :: ArchitectureSpec   -- ^ descend for binary downloads per arch
+  { _viTags        :: [Tag]              -- ^ version specific tag
+  , _viChangeLog   :: Maybe URI
+  , _viSourceDL    :: Maybe DownloadInfo -- ^ source tarball
+  , _viArch        :: ArchitectureSpec   -- ^ descend for binary downloads per arch
+  -- informative messages
+  , _viPostInstall :: Maybe Text
+  , _viPostRemove  :: Maybe Text
+  , _viPreCompile  :: Maybe Text
   }
   deriving (Eq, GHC.Generic, Show)
 
@@ -102,6 +112,21 @@ data Tag = Latest
          | UnknownTag String  -- ^ used for upwardscompat
          deriving (Ord, Eq, GHC.Generic, Show) -- FIXME: manual JSON instance
 
+tagToString :: Tag -> String
+tagToString Recommended        = "recommended"
+tagToString Latest             = "latest"
+tagToString Prerelease         = "prerelease"
+tagToString (Base       pvp'') = "base-" ++ T.unpack (prettyPVP pvp'')
+tagToString (UnknownTag t    ) = t
+tagToString Old                = ""
+
+instance Pretty Tag where
+  pPrint Recommended        = text "recommended"
+  pPrint Latest             = text "latest"
+  pPrint Prerelease         = text "prerelease"
+  pPrint (Base       pvp'') = text ("base-" ++ T.unpack (prettyPVP pvp''))
+  pPrint (UnknownTag t    ) = text t
+  pPrint Old                = mempty
 
 data Architecture = A_64
                   | A_32
@@ -113,15 +138,18 @@ data Architecture = A_64
                   | A_ARM64
   deriving (Eq, GHC.Generic, Ord, Show)
 
-prettyArch :: Architecture -> String
-prettyArch A_64 = "x86_64"
-prettyArch A_32 = "i386"
-prettyArch A_PowerPC = "powerpc"
-prettyArch A_PowerPC64 = "powerpc64"
-prettyArch A_Sparc = "sparc"
-prettyArch A_Sparc64 = "sparc64"
-prettyArch A_ARM = "arm"
-prettyArch A_ARM64 = "aarch64"
+archToString :: Architecture -> String
+archToString A_64 = "x86_64"
+archToString A_32 = "i386"
+archToString A_PowerPC = "powerpc"
+archToString A_PowerPC64 = "powerpc64"
+archToString A_Sparc = "sparc"
+archToString A_Sparc64 = "sparc64"
+archToString A_ARM = "arm"
+archToString A_ARM64 = "aarch64"
+
+instance Pretty Architecture where
+  pPrint = text . archToString
 
 data Platform = Linux LinuxDistro
               -- ^ must exit
@@ -130,10 +158,13 @@ data Platform = Linux LinuxDistro
               | FreeBSD
   deriving (Eq, GHC.Generic, Ord, Show)
 
-prettyPlatfrom :: Platform -> String
-prettyPlatfrom (Linux distro) = "linux-" ++ prettyDistro distro
-prettyPlatfrom Darwin = "darwin"
-prettyPlatfrom FreeBSD = "freebsd"
+platformToString :: Platform -> String
+platformToString (Linux distro) = "linux-" ++ distroToString distro
+platformToString Darwin = "darwin"
+platformToString FreeBSD = "freebsd"
+
+instance Pretty Platform where
+  pPrint = text . platformToString
 
 data LinuxDistro = Debian
                  | Ubuntu
@@ -151,18 +182,21 @@ data LinuxDistro = Debian
                  -- ^ must exit
   deriving (Eq, GHC.Generic, Ord, Show)
 
-prettyDistro :: LinuxDistro -> String
-prettyDistro Debian = "debian"
-prettyDistro Ubuntu = "ubuntu"
-prettyDistro Mint= "mint"
-prettyDistro Fedora = "fedora"
-prettyDistro CentOS = "centos"
-prettyDistro RedHat = "redhat"
-prettyDistro Alpine = "alpine"
-prettyDistro AmazonLinux = "amazon"
-prettyDistro Gentoo = "gentoo"
-prettyDistro Exherbo = "exherbo"
-prettyDistro UnknownLinux = "unknown"
+distroToString :: LinuxDistro -> String
+distroToString Debian = "debian"
+distroToString Ubuntu = "ubuntu"
+distroToString Mint= "mint"
+distroToString Fedora = "fedora"
+distroToString CentOS = "centos"
+distroToString RedHat = "redhat"
+distroToString Alpine = "alpine"
+distroToString AmazonLinux = "amazon"
+distroToString Gentoo = "gentoo"
+distroToString Exherbo = "exherbo"
+distroToString UnknownLinux = "unknown"
+
+instance Pretty LinuxDistro where
+  pPrint = text . distroToString
 
 
 -- | An encapsulation of a download. This can be used
@@ -187,6 +221,10 @@ data TarDir = RealDir (Path Rel)
             | RegexDir String     -- ^ will be compiled to regex, the first match will "win"
             deriving (Eq, Ord, GHC.Generic, Show)
 
+instance Pretty TarDir where
+  pPrint (RealDir path) = text [i|#{E.decodeUtf8With E.lenientDecode . toFilePath $ path}|]
+  pPrint (RegexDir regex) = text regex
+
 
 -- | Where to fetch GHCupDownloads from.
 data URLSource = GHCupURL
@@ -306,12 +344,15 @@ data PlatformResult = PlatformResult
   }
   deriving (Eq, Show)
 
-prettyPlatform :: PlatformResult -> String
-prettyPlatform PlatformResult { _platform = plat, _distroVersion = Just v' }
+platResToString :: PlatformResult -> String
+platResToString PlatformResult { _platform = plat, _distroVersion = Just v' }
   = show plat <> ", " <> T.unpack (prettyV v')
-prettyPlatform PlatformResult { _platform = plat, _distroVersion = Nothing }
+platResToString PlatformResult { _platform = plat, _distroVersion = Nothing }
   = show plat
 
+instance Pretty PlatformResult where
+  pPrint = text . platResToString
+
 data PlatformRequest = PlatformRequest
   { _rArch     :: Architecture
   , _rPlatform :: Platform
@@ -319,14 +360,17 @@ data PlatformRequest = PlatformRequest
   }
   deriving (Eq, Show)
 
-prettyPfReq :: PlatformRequest -> String
-prettyPfReq (PlatformRequest arch plat ver) =
-  prettyArch arch ++ "-" ++ prettyPlatfrom plat ++ pver
+pfReqToString :: PlatformRequest -> String
+pfReqToString (PlatformRequest arch plat ver) =
+  archToString arch ++ "-" ++ platformToString plat ++ pver
  where
   pver = case ver of
-           Just v' -> "-" ++ (T.unpack $ prettyV v')
+           Just v' -> "-" ++ T.unpack (prettyV v')
            Nothing -> ""
 
+instance Pretty PlatformRequest where
+  pPrint = text . pfReqToString
+
 -- | A GHC identified by the target platform triple
 -- and the version.
 data GHCTargetVersion = GHCTargetVersion
@@ -339,11 +383,13 @@ data GHCTargetVersion = GHCTargetVersion
 mkTVer :: Version -> GHCTargetVersion
 mkTVer = GHCTargetVersion Nothing
 
+tVerToText :: GHCTargetVersion -> Text
+tVerToText (GHCTargetVersion (Just t) v') = t <> "-" <> prettyVer v'
+tVerToText (GHCTargetVersion Nothing  v') = prettyVer v'
 
 -- | Assembles a path of the form: <target-triple>-<version>
-prettyTVer :: GHCTargetVersion -> Text
-prettyTVer (GHCTargetVersion (Just t) v') = t <> "-" <> prettyVer v'
-prettyTVer (GHCTargetVersion Nothing  v') = prettyVer v'
+instance Pretty GHCTargetVersion where
+  pPrint = text . T.unpack . tVerToText
 
 
 -- | A comparator and a version.
@@ -361,3 +407,9 @@ data VersionRange = SimpleRange (NonEmpty VersionCmp) -- And
                   | OrRange (NonEmpty VersionCmp) VersionRange
   deriving (Eq, GHC.Generic, Ord, Show)
 
+
+instance Pretty Versioning where
+  pPrint = text . T.unpack . prettyV
+
+instance Pretty Version where
+  pPrint = text . T.unpack . prettyVer

lib/GHCup/Types/JSON.hs

@@ -148,7 +148,7 @@ instance FromJSONKey Platform where
                   $  "Unexpected failure in decoding LinuxDistro: "
                   <> show dstr
         Nothing -> fail "Unexpected failure in Platform stripPrefix"
-    | otherwise -> fail $ "Failure in Platform (FromJSONKey)"
+    | otherwise -> fail "Failure in Platform (FromJSONKey)"
 
 instance ToJSONKey Architecture where
   toJSONKey = genericToJSONKey defaultJSONKeyOptions
@@ -272,7 +272,7 @@ verRangeToText  (SimpleRange cmps) =
                      (versionCmpToText <$> NE.toList cmps)
   in  "( " <> inner <> " )"
 verRangeToText (OrRange cmps range) =
-  let left  = verRangeToText $ (SimpleRange cmps)
+  let left  = verRangeToText (SimpleRange cmps)
       right = verRangeToText range
   in  left <> " || " <> right
 
@@ -288,7 +288,7 @@ versionRangeP = go <* MP.eof
   go =
     MP.try orParse
       <|> MP.try (fmap SimpleRange andParse)
-      <|> (fmap (SimpleRange . pure) versionCmpP)
+      <|> fmap (SimpleRange . pure) versionCmpP
 
   orParse :: MP.Parsec Void T.Text VersionRange
   orParse =
@@ -300,9 +300,7 @@ versionRangeP = go <* MP.eof
   andParse =
     fmap (\h t -> h :| t)
          (MPC.space *> MP.chunk "(" *> MPC.space *> versionCmpP)
-      <*> ( MP.try
-          $ MP.many (MPC.space *> MP.chunk "&&" *> MPC.space *> versionCmpP)
-          )
+      <*> MP.try (MP.many (MPC.space *> MP.chunk "&&" *> MPC.space *> versionCmpP))
       <*  MPC.space
       <*  MP.chunk ")"
       <*  MPC.space

lib/GHCup/Utils.hs

@@ -121,13 +121,13 @@ rmMinorSymlinks :: ( MonadReader AppState m
                    )
                 => GHCTargetVersion
                 -> Excepts '[NotInstalled] m ()
-rmMinorSymlinks tv@(GHCTargetVersion {..}) = do
+rmMinorSymlinks tv@GHCTargetVersion{..} = do
   AppState { dirs = Dirs {..} } <- lift ask
 
   files                         <- liftE $ ghcToolFiles tv
   forM_ files $ \f -> do
     f_xyz <- liftIO $ parseRel (toFilePath f <> B.singleton _hyphen <> verToBS _tvVersion)
-    let fullF = (binDir </> f_xyz)
+    let fullF = binDir </> f_xyz
     lift $ $(logDebug) [i|rm -f #{toFilePath fullF}|]
     liftIO $ hideError doesNotExistErrorType $ deleteFile fullF
 
@@ -147,11 +147,11 @@ rmPlain target = do
   forM_ mtv $ \tv -> do
     files <- liftE $ ghcToolFiles tv
     forM_ files $ \f -> do
-      let fullF = (binDir </> f)
+      let fullF = binDir </> f
       lift $ $(logDebug) [i|rm -f #{toFilePath fullF}|]
       liftIO $ hideError doesNotExistErrorType $ deleteFile fullF
     -- old ghcup
-    let hdc_file = (binDir </> [rel|haddock-ghc|])
+    let hdc_file = binDir </> [rel|haddock-ghc|]
     lift $ $(logDebug) [i|rm -f #{toFilePath hdc_file}|]
     liftIO $ hideError doesNotExistErrorType $ deleteFile hdc_file
 
@@ -166,7 +166,7 @@ rmMajorSymlinks :: ( MonadReader AppState m
                    )
                 => GHCTargetVersion
                 -> Excepts '[NotInstalled] m ()
-rmMajorSymlinks tv@(GHCTargetVersion {..}) = do
+rmMajorSymlinks tv@GHCTargetVersion{..} = do
   AppState { dirs = Dirs {..} } <- lift ask
   (mj, mi) <- getMajorMinorV _tvVersion
   let v' = intToText mj <> "." <> intToText mi
@@ -174,7 +174,7 @@ rmMajorSymlinks tv@(GHCTargetVersion {..}) = do
   files                         <- liftE $ ghcToolFiles tv
   forM_ files $ \f -> do
     f_xyz <- liftIO $ parseRel (toFilePath f <> B.singleton _hyphen <> E.encodeUtf8 v')
-    let fullF = (binDir </> f_xyz)
+    let fullF = binDir </> f_xyz
     lift $ $(logDebug) [i|rm -f #{toFilePath fullF}|]
     liftIO $ hideError doesNotExistErrorType $ deleteFile fullF
 
@@ -212,7 +212,7 @@ ghcSet mtarget = do
 
   -- link destination is of the form ../ghc/<ver>/bin/ghc
   -- for old ghcup, it is ../ghc/<ver>/bin/ghc-<ver>
-  liftIO $ handleIO' NoSuchThing (\_ -> pure $ Nothing) $ do
+  liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ do
     link <- readSymbolicLink $ toFilePath ghcBin
     Just <$> ghcLinkVersion link
 
@@ -256,7 +256,7 @@ getInstalledCabals = do
   bins   <- liftIO $ handleIO (\_ -> pure []) $ findFiles
     binDir
     (makeRegexOpts compExtended execBlank ([s|^cabal-.*$|] :: ByteString))
-  vs <- forM bins $ \f -> case fmap version (fmap decUTF8Safe . B.stripPrefix "cabal-" . toFilePath $ f) of
+  vs <- forM bins $ \f -> case fmap (version . decUTF8Safe) . B.stripPrefix "cabal-" . toFilePath $ f of
     Just (Right r) -> pure $ Right r
     Just (Left  _) -> pure $ Left f
     Nothing        -> pure $ Left f
@@ -267,8 +267,8 @@ getInstalledCabals = do
 -- | Whether the given cabal version is installed.
 cabalInstalled :: (MonadIO m, MonadReader AppState m, MonadCatch m) => Version -> m Bool
 cabalInstalled ver = do
-  vers <- fmap rights $ getInstalledCabals
-  pure $ elem ver $ vers
+  vers <- fmap rights getInstalledCabals
+  pure $ elem ver vers
 
 
 -- Return the currently set cabal version, if any.
@@ -279,7 +279,7 @@ cabalSet = do
   b        <- handleIO (\_ -> pure False) $ fmap (== SymbolicLink) $ liftIO $ getFileType cabalbin
   if
     | b -> do
-      liftIO $ handleIO' NoSuchThing (\_ -> pure $ Nothing) $ do
+      liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ do
         broken <- isBrokenSymlink cabalbin
         if broken
           then pure Nothing
@@ -321,23 +321,20 @@ getInstalledHLSs = do
                    execBlank
                    ([s|^haskell-language-server-wrapper-.*$|] :: ByteString)
     )
-  vs <- forM bins $ \f ->
+  forM bins $ \f ->
     case
-        fmap
-          version
-          (fmap decUTF8Safe . B.stripPrefix "haskell-language-server-wrapper-" . toFilePath $ f)
+          fmap (version . decUTF8Safe) . B.stripPrefix "haskell-language-server-wrapper-" . toFilePath $ f
       of
         Just (Right r) -> pure $ Right r
         Just (Left  _) -> pure $ Left f
         Nothing        -> pure $ Left f
-  pure $ vs
 
 
 -- | Whether the given HLS version is installed.
 hlsInstalled :: (MonadIO m, MonadReader AppState m, MonadCatch m) => Version -> m Bool
 hlsInstalled ver = do
-  vers <- fmap rights $ getInstalledHLSs
-  pure $ elem ver $ vers
+  vers <- fmap rights getInstalledHLSs
+  pure $ elem ver vers
 
 
 
@@ -347,7 +344,7 @@ hlsSet = do
   AppState {dirs = Dirs {..}} <- ask
   let hlsBin = binDir </> [rel|haskell-language-server-wrapper|]
 
-  liftIO $ handleIO' NoSuchThing (\_ -> pure $ Nothing) $ do
+  liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ do
     broken <- isBrokenSymlink hlsBin
     if broken
       then pure Nothing
@@ -376,15 +373,13 @@ hlsGHCVersions = do
   vers                          <- forM h $ \h' -> do
     bins <- hlsServerBinaries h'
     pure $ fmap
-      (\bin ->
-        version
-          . decUTF8Safe
-          . fromJust
-          . B.stripPrefix "haskell-language-server-"
-          . head
-          . B.split _tilde
-          . toFilePath
-          $ bin
+      (version
+        . decUTF8Safe
+        . fromJust
+        . B.stripPrefix "haskell-language-server-"
+        . head
+        . B.split _tilde
+        . toFilePath
       )
       bins
   pure . rights . concat . maybeToList $ vers
@@ -421,7 +416,7 @@ hlsWrapperBinary ver = do
       )
     )
   case wrapper of
-    []  -> pure $ Nothing
+    []  -> pure Nothing
     [x] -> pure $ Just x
     _   -> throwM $ UnexpectedListLength
       "There were multiple hls wrapper binaries for a single version"
@@ -497,13 +492,9 @@ getGHCForMajor major' minor' mt = do
 getLatestGHCFor :: Int -- ^ major version component
                 -> Int -- ^ minor version component
                 -> GHCupDownloads
-                -> Maybe Version
-getLatestGHCFor major' minor' dls = do
-  join
-    . fmap (lastMay . filter (\v -> matchMajor v major' minor'))
-    . preview (ix GHC % to Map.keys)
-    $ dls
-
+                -> Maybe (Version, VersionInfo)
+getLatestGHCFor major' minor' dls =
+  preview (ix GHC % to Map.toDescList) dls >>= lastMay . filter (\(v, _) -> matchMajor v major' minor')
 
 
 
@@ -524,7 +515,7 @@ unpackToDir :: (MonadLogger m, MonadIO m, MonadThrow m)
 #endif
                         ] m ()
 unpackToDir dest av = do
-  fp <- (decUTF8Safe . toFilePath) <$> basename av
+  fp <- decUTF8Safe . toFilePath <$> basename av
   let dfp = decUTF8Safe . toFilePath $ dest
   lift $ $(logInfo) [i|Unpacking: #{fp} to #{dfp}|]
   fn <- toFilePath <$> basename av
@@ -570,9 +561,9 @@ intoSubdir bdir tardir = case tardir of
     let rs = splitOn "/" r
     foldlM
       (\y x ->
-        (fmap sort . handleIO (\_ -> pure []) . liftIO . findFiles y . regex $ x) >>= \case
+        (handleIO (\_ -> pure []) . liftIO . findFiles y . regex $ x) >>= (\case
           []      -> throwE $ TarDirDoesNotExist tardir
-          (p : _) -> pure (y </> p)
+          (p : _) -> pure (y </> p)) . sort
       )
       bdir
       rs
@@ -591,22 +582,21 @@ intoSubdir bdir tardir = case tardir of
 getTagged :: Tag
           -> AffineFold (Map.Map Version VersionInfo) (Version, VersionInfo)
 getTagged tag =
-  ( to (Map.filter (\VersionInfo {..} -> elem tag _viTags))
+  to (Map.filter (\VersionInfo {..} -> tag `elem` _viTags))
   % to Map.toDescList
   % _head
-  )
 
-getLatest :: GHCupDownloads -> Tool -> Maybe Version
-getLatest av tool = headOf (ix tool % getTagged Latest % to fst) $ av
+getLatest :: GHCupDownloads -> Tool -> Maybe (Version, VersionInfo)
+getLatest av tool = headOf (ix tool % getTagged Latest) av
 
-getRecommended :: GHCupDownloads -> Tool -> Maybe Version
-getRecommended av tool = headOf (ix tool % getTagged Recommended % to fst) $ av
+getRecommended :: GHCupDownloads -> Tool -> Maybe (Version, VersionInfo)
+getRecommended av tool = headOf (ix tool % getTagged Recommended) av
 
 
 -- | Gets the latest GHC with a given base version.
-getLatestBaseVersion :: GHCupDownloads -> PVP -> Maybe Version
+getLatestBaseVersion :: GHCupDownloads -> PVP -> Maybe (Version, VersionInfo)
 getLatestBaseVersion av pvpVer =
-  headOf (ix GHC % getTagged (Base pvpVer) % to fst) av
+  headOf (ix GHC % getTagged (Base pvpVer)) av
 
 
 
@@ -650,7 +640,7 @@ ghcToolFiles ver = do
 
   -- fail if ghc is not installed
   whenM (fmap not $ liftIO $ doesDirectoryExist ghcdir)
-        (throwE (NotInstalled GHC (prettyTVer ver)))
+        (throwE (NotInstalled GHC ver))
 
   files    <- liftIO $ getDirsFiles' bindir
   -- figure out the <ver> suffix, because this might not be `Version` for
@@ -671,10 +661,10 @@ ghcToolFiles ver = do
     then pure id
     else do
       (Just symver) <-
-        (B.stripPrefix (toFilePath ghcbin <> "-") . takeFileName)
-          <$> (liftIO $ readSymbolicLink $ toFilePath ghcbinPath)
+        B.stripPrefix (toFilePath ghcbin <> "-") . takeFileName
+          <$> liftIO (readSymbolicLink $ toFilePath ghcbinPath)
       when (B.null symver)
-           (throwIO $ userError $ "Fatal: ghc symlink target is broken")
+           (throwIO $ userError "Fatal: ghc symlink target is broken")
       pure $ filter (\x -> not $ symver `B.isSuffixOf` toFilePath x)
 
   pure $ onlyUnversioned files
@@ -699,8 +689,8 @@ make :: (MonadThrow m, MonadIO m, MonadReader AppState m)
      -> Maybe (Path Abs)
      -> m (Either ProcessError ())
 make args workdir = do
-  spaths    <- catMaybes . fmap parseAbs <$> (liftIO getSearchPath)
-  has_gmake <- isJust <$> (liftIO $ searchPath spaths [rel|gmake|])
+  spaths    <- catMaybes . fmap parseAbs <$> liftIO getSearchPath
+  has_gmake <- isJust <$> liftIO (searchPath spaths [rel|gmake|])
   let mymake = if has_gmake then "gmake" else "make"
   execLogged mymake True args [rel|ghc-make|] workdir Nothing
 
@@ -715,13 +705,13 @@ applyPatches pdir ddir = do
   patches <- liftIO $ getDirsFiles pdir
   forM_ (sort patches) $ \patch' -> do
     lift $ $(logInfo) [i|Applying patch #{patch'}|]
-    (fmap (either (const Nothing) Just) $ liftIO $ exec
-        "patch"
-        True
-        ["-p1", "-i", toFilePath patch']
-        (Just ddir)
-        Nothing
-      )
+    fmap (either (const Nothing) Just)
+         (liftIO $ exec
+           "patch"
+           True
+           ["-p1", "-i", toFilePath patch']
+           (Just ddir)
+           Nothing)
       !? PatchFailed
 
 
@@ -767,8 +757,7 @@ runBuildAction bdir instdir action = do
         (\es -> do
           exAction
           throwE (BuildFailed bdir es)
-        )
-    $ action
+        ) action
 
   when (keepDirs == Never || keepDirs == Errors) $ liftIO $ deleteDirRecursive
     bdir
@@ -795,3 +784,24 @@ createDirRecursive' p =
           _ -> throwIO e
       _ -> throwIO e
 
+
+getVersionInfo :: Version
+               -> Tool
+               -> GHCupDownloads
+               -> Maybe VersionInfo
+getVersionInfo v' tool =
+  headOf
+    ( ix tool
+    % to (Map.filterWithKey (\k _ -> k == v'))
+    % to Map.elems
+    % _head
+    )
+
+
+-- Gathering monoidal values
+traverseFold :: (Foldable t, Applicative m, Monoid b) => (a -> m b) -> t a -> m b
+traverseFold f = foldl (\mb a -> (<>) <$> mb <*> f a) (pure mempty)
+
+-- | Gathering monoidal values
+forFold :: (Foldable t, Applicative m, Monoid b) => t a -> (a -> m b) -> m b
+forFold = \t -> (`traverseFold` t)

lib/GHCup/Utils/Dirs.hs

@@ -185,12 +185,12 @@ getDirs = do
 ghcupConfigFile :: (MonadIO m)
                 => Excepts '[JSONError] m UserSettings
 ghcupConfigFile = do
-  confDir <- liftIO $ ghcupConfigDir
+  confDir <- liftIO ghcupConfigDir
   let file = confDir </> [rel|config.yaml|]
-  bs <- liftIO $ handleIO' NoSuchThing (\_ -> pure $ Nothing) $ fmap Just $ readFile file 
+  bs <- liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ Just <$> readFile file
   case bs of
       Nothing -> pure defaultUserSettings
-      Just bs' -> lE' JSONDecodeError . bimap show id . Y.decodeEither' . L.toStrict $ bs'
+      Just bs' -> lE' JSONDecodeError . first show . Y.decodeEither' . L.toStrict $ bs'
 
 
     -------------------------
@@ -214,7 +214,7 @@ ghcupGHCDir :: (MonadReader AppState m, MonadThrow m)
             -> m (Path Abs)
 ghcupGHCDir ver = do
   ghcbasedir    <- ghcupGHCBaseDir
-  verdir        <- parseRel $ E.encodeUtf8 (prettyTVer ver)
+  verdir        <- parseRel $ E.encodeUtf8 (tVerToText ver)
   pure (ghcbasedir </> verdir)
 
 
@@ -228,7 +228,7 @@ parseGHCupGHCDir (toFilePath -> f) = do
 mkGhcupTmpDir :: (MonadThrow m, MonadIO m) => m (Path Abs)
 mkGhcupTmpDir = do
   tmpdir <- liftIO $ getEnvDefault "TMPDIR" "/tmp"
-  tmp    <- liftIO $ mkdtemp $ (tmpdir FP.</> "ghcup-")
+  tmp    <- liftIO $ mkdtemp (tmpdir FP.</> "ghcup-")
   parseAbs tmp
 
 
@@ -266,7 +266,7 @@ relativeSymlink (toFilePath -> p1) (toFilePath -> p2) =
       common  = takeWhile (\(x, y) -> x == y) $ zip d1 d2
       cPrefix = drop (length common) d1
   in  joinPath (replicate (length cPrefix) "..")
-        <> joinPath ("/" : (drop (length common) d2))
+        <> joinPath ("/" : drop (length common) d2)
 
 
 

lib/GHCup/Utils/File.hs

@@ -43,7 +43,7 @@ import           GHC.IO.Exception
 import           HPath
 import           HPath.IO                hiding ( hideError )
 import           Optics                  hiding ((<|), (|>))
-import           System.Console.Pretty
+import           System.Console.Pretty   hiding ( Pretty )
 import           System.Console.Regions
 import           System.IO.Error
 import           System.Posix.Directory.ByteString
@@ -55,6 +55,7 @@ import "unix"    System.Posix.IO.ByteString
                                          hiding ( openFd )
 import           System.Posix.Process           ( ProcessStatus(..) )
 import           System.Posix.Types
+import           Text.PrettyPrint.HughesPJClass hiding ( (<>) )
 import           Text.Regex.Posix
 
 
@@ -79,6 +80,15 @@ data ProcessError = NonZeroExit Int ByteString [ByteString]
                   | NoSuchPid ByteString [ByteString]
                   deriving Show
 
+instance Pretty ProcessError where
+  pPrint (NonZeroExit e exe args) =
+    text [i|Process "#{decUTF8Safe exe}" with arguments #{fmap decUTF8Safe args} failed with exit code #{e}.|]
+  pPrint (PTerminated exe args) =
+    text [i|Process "#{decUTF8Safe exe}" with arguments #{fmap decUTF8Safe args} terminated.|]
+  pPrint (PStopped exe args) =
+    text [i|Process "#{decUTF8Safe exe}" with arguments #{fmap decUTF8Safe args} stopped.|]
+  pPrint (NoSuchPid exe args) =
+    text [i|Could not find PID for process running "#{decUTF8Safe exe}" with arguments #{fmap decUTF8Safe args}.|]
 
 data CapturedProcess = CapturedProcess
   { _exitCode :: ExitCode
@@ -97,12 +107,14 @@ makeLenses ''CapturedProcess
 -- PATH does.
 findExecutable :: Path Rel -> IO (Maybe (Path Abs))
 findExecutable ex = do
-  sPaths <- fmap catMaybes . (fmap . fmap) parseAbs $ getSearchPath
+  sPaths <- fmap (catMaybes . fmap parseAbs) getSearchPath
   -- We don't want exceptions to mess up our result. If we can't
   -- figure out if a file exists, then treat it as a negative result.
-  asum $ fmap (handleIO (\_ -> pure Nothing)) $ fmap
-    -- asum for short-circuiting behavior
-    (\s' -> (isExecutable (s' </> ex) >>= guard) $> (Just (s' </> ex)))
+  asum $ fmap
+    (handleIO (\_ -> pure Nothing)
+      -- asum for short-circuiting behavior
+      . (\s' -> (isExecutable (s' </> ex) >>= guard) $> Just (s' </> ex))
+    )
     sPaths
 
 
@@ -140,11 +152,12 @@ execLogged exe spath args lfile chdir env = do
       void
         $ forkIO
         $ EX.handle (\(_ :: IOException) -> pure ())
-        $ flip EX.finally (putMVar done ())
-        $ (if verbose
-            then tee fd stdoutRead
-            else printToRegion fd stdoutRead 6 pState
-          )
+        $ EX.finally
+            (if verbose
+              then tee fd stdoutRead
+              else printToRegion fd stdoutRead 6 pState
+            )
+            (putMVar done ())
 
       -- fork the subprocess
       pid <- SPPB.forkProcess $ do
@@ -193,7 +206,7 @@ execLogged exe spath args lfile chdir env = do
         $ handle
             (\(ex :: SomeException) -> do
               ps <- liftIO $ takeMVar pState
-              when (ps == True) (forM_ rs (liftIO . closeConsoleRegion))
+              when ps (forM_ rs (liftIO . closeConsoleRegion))
               throw ex
             )
         $ readTilEOF (lineAction rs) fdIn
@@ -237,7 +250,7 @@ execLogged exe spath args lfile chdir env = do
            => Fd          -- ^ input file descriptor
            -> ByteString  -- ^ rest buffer (read across newline)
            -> m (ByteString, ByteString, Bool) -- ^ (full line, rest, eof)
-  readLine fd = \inBs -> go inBs
+  readLine fd = go
    where
     go inBs = do
       -- if buffer is not empty, process it first
@@ -265,7 +278,7 @@ execLogged exe spath args lfile chdir env = do
       (bs, rest, eof) <- readLine fd' bs'
       if eof
          then liftIO $ ioError (mkIOError eofErrorType "" Nothing Nothing)
-         else (void $ action' bs) >> go rest
+         else void (action' bs) >> go rest
 
 
 -- | Capture the stdout and stderr of the given action, which
@@ -319,7 +332,7 @@ captureOutStreams action = do
                                  , _stdErr   = stderr'
                                  }
 
-        _ -> throwIO $ userError $ ("No such PID " ++ show pid)
+        _ -> throwIO $ userError ("No such PID " ++ show pid)
 
  where
   writeStds pout perr rout rerr = do
@@ -346,7 +359,7 @@ captureOutStreams action = do
 
 actionWithPipes :: ((Fd, Fd) -> IO b) -> IO b
 actionWithPipes a =
-  createPipe >>= \(p1, p2) -> (flip finally) (cleanup [p1, p2]) $ a (p1, p2)
+  createPipe >>= \(p1, p2) -> flip finally (cleanup [p1, p2]) $ a (p1, p2)
 
 cleanup :: [Fd] -> IO ()
 cleanup fds = for_ fds $ \fd -> handleIO (\_ -> pure ()) $ closeFd fd
@@ -407,6 +420,32 @@ searchPath paths needle = go paths
       else pure False
 
 
+-- | Check wether a binary is shadowed by another one that comes before
+-- it in PATH. Returns the path to said binary, if any.
+isShadowed :: Path Abs -> IO (Maybe (Path Abs))
+isShadowed p = do
+  let dir = dirname p
+  fn <- basename p
+  spaths <- catMaybes . fmap parseAbs <$> liftIO getSearchPath
+  if dir `elem` spaths
+  then do
+    let shadowPaths = takeWhile (/= dir) spaths
+    searchPath shadowPaths fn
+  else pure Nothing
+
+
+-- | Check whether the binary is in PATH. This returns only `True`
+-- if the directory containing the binary is part of PATH.
+isInPath :: Path Abs -> IO Bool
+isInPath p = do
+  let dir = dirname p
+  fn <- basename p
+  spaths <- catMaybes . fmap parseAbs <$> liftIO getSearchPath
+  if dir `elem` spaths
+  then isJust <$> searchPath [dir] fn
+  else pure False
+
+
 findFiles :: Path Abs -> Regex -> IO [Path Rel]
 findFiles path regex = do
   dirStream <- openDirStream (toFilePath path)
@@ -415,7 +454,7 @@ findFiles path regex = do
     . S.toList
     . S.filter (\(_, p) -> match regex p)
     $ dirContentsStream dirStream
-  pure $ join $ fmap parseRel f
+  pure $ parseRel =<< f
 
 
 findFiles' :: Path Abs -> MP.Parsec Void Text () -> IO [Path Rel]
@@ -428,7 +467,7 @@ findFiles' path parser = do
                              Left _ -> False
                              Right p' -> isJust $ MP.parseMaybe parser p')
     $ dirContentsStream dirStream
-  pure $ join $ fmap parseRel f
+  pure $ parseRel =<< f
 
 
 isBrokenSymlink :: Path Abs -> IO Bool

lib/GHCup/Utils/Logger.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE QuasiQuotes           #-}
 {-# LANGUAGE FlexibleContexts      #-}
 
 {-|
@@ -51,7 +50,7 @@ myLoggerT LoggerConfig {..} loggingt = runLoggingT loggingt mylogger
           LevelOther t -> toLogStr "[ " <> toLogStr t <> toLogStr " ]"
     let out = fromLogStr (l <> toLogStr " " <> str' <> toLogStr "\n")
 
-    when (lcPrintDebug || (lcPrintDebug == False && not (level == LevelDebug)))
+    when (lcPrintDebug || (not lcPrintDebug && (level /= LevelDebug)))
       $ colorOutter out
 
     -- raw output

lib/GHCup/Utils/MegaParsec.hs

@@ -15,7 +15,6 @@ module GHCup.Utils.MegaParsec where
 import           GHCup.Types
 
 import           Control.Applicative
-import           Control.Monad
 #if !MIN_VERSION_base(4,13,0)
 import           Control.Monad.Fail             ( MonadFail )
 #endif
@@ -61,9 +60,9 @@ ghcTargetBinP :: Text -> MP.Parsec Void Text (Maybe Text, Text)
 ghcTargetBinP t =
   (,)
     <$> (   MP.try
-            (Just <$> (parseUntil1 (MP.chunk "-" *> MP.chunk t)) <* MP.chunk "-"
+            (Just <$> parseUntil1 (MP.chunk "-" *> MP.chunk t) <* MP.chunk "-"
             )
-        <|> (flip const Nothing <$> mempty)
+        <|> ((\ _ x -> x) Nothing <$> mempty)
         )
     <*> (MP.chunk t <* MP.eof)
 
@@ -74,8 +73,8 @@ ghcTargetBinP t =
 ghcTargetVerP :: MP.Parsec Void Text GHCTargetVersion
 ghcTargetVerP =
   (\x y -> GHCTargetVersion x y)
-    <$> (MP.try (Just <$> (parseUntil1 (MP.chunk "-" *> verP')) <* MP.chunk "-")
-        <|> (flip const Nothing <$> mempty)
+    <$> (MP.try (Just <$> parseUntil1 (MP.chunk "-" *> verP') <* MP.chunk "-")
+        <|> ((\ _ x -> x) Nothing <$> mempty)
         )
     <*> (version' <* MP.eof)
  where
@@ -85,16 +84,15 @@ ghcTargetVerP =
     let startsWithDigists =
           and
             . take 3
-            . join
-            . (fmap . fmap)
+            . concatMap
+              (map
                 (\case
                   (Digits _) -> True
                   (Str    _) -> False
-                )
-            . fmap NE.toList
+                ) . NE.toList)
             . NE.toList
-            $ (_vChunks v)
-    if startsWithDigists && not (isJust (_vEpoch v))
+            $ _vChunks v
+    if startsWithDigists && isNothing (_vEpoch v)
       then pure $ prettyVer v
       else fail "Oh"
 

lib/GHCup/Utils/Prelude.hs

@@ -1,10 +1,7 @@
 {-# LANGUAGE DataKinds           #-}
-{-# LANGUAGE DeriveLift          #-}
 {-# LANGUAGE FlexibleContexts    #-}
 {-# LANGUAGE FlexibleInstances   #-}
-{-# LANGUAGE QuasiQuotes         #-}
 {-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeApplications    #-}
 {-# LANGUAGE TypeFamilies        #-}
 {-# LANGUAGE TypeOperators       #-}
 
@@ -131,7 +128,7 @@ lE' :: forall e' e es a m
     => (e' -> e)
     -> Either e' a
     -> Excepts es m a
-lE' f = liftE . veitherToExcepts . fromEither . bimap f id
+lE' f = liftE . veitherToExcepts . fromEither . first f
 
 lEM :: forall e es a m . (Monad m, e :< es) => m (Either e a) -> Excepts es m a
 lEM em = lift em >>= lE
@@ -141,7 +138,7 @@ lEM' :: forall e' e es a m
      => (e' -> e)
      -> m (Either e' a)
      -> Excepts es m a
-lEM' f em = lift em >>= lE . bimap f id
+lEM' f em = lift em >>= lE . first f
 
 fromEither :: Either a b -> VEither '[a] b
 fromEither = either (VLeft . V) VRight
@@ -200,8 +197,8 @@ hideExcept :: forall e es es' a m
            -> a
            -> Excepts es m a
            -> Excepts es' m a
-hideExcept _ a action =
-  catchLiftLeft ((\_ -> pure a) :: (e -> Excepts es' m a)) action
+hideExcept _ a =
+  catchLiftLeft ((\_ -> pure a) :: (e -> Excepts es' m a))
 
 
 hideExcept' :: forall e es es' m
@@ -209,8 +206,8 @@ hideExcept' :: forall e es es' m
             => e
             -> Excepts es m ()
             -> Excepts es' m ()
-hideExcept' _ action =
-  catchLiftLeft ((\_ -> pure ()) :: (e -> Excepts es' m ())) action
+hideExcept' _ =
+  catchLiftLeft ((\_ -> pure ()) :: (e -> Excepts es' m ()))
 
 
 reThrowAll :: forall e es es' a m
@@ -259,7 +256,7 @@ addToCurrentEnv :: MonadIO m
                 => [(ByteString, ByteString)]
                 -> m [(ByteString, ByteString)]
 addToCurrentEnv adds = do
-  cEnv <- liftIO $ getEnvironment
+  cEnv <- liftIO getEnvironment
   pure (adds ++ cEnv)
 
 

lib/GHCup/Utils/Version/QQ.hs

@@ -57,7 +57,7 @@ deriving instance Lift (NonEmpty Word)
 
 qq :: (Text -> Q Exp) -> QuasiQuoter
 qq quoteExp' = QuasiQuoter
-  { quoteExp  = (\s -> quoteExp' . T.pack $ s)
+  { quoteExp  = \s -> quoteExp' . T.pack $ s
   , quotePat  = \_ ->
     fail "illegal QuasiQuote (allowed as expression only, used as a pattern)"
   , quoteType = \_ ->
@@ -101,4 +101,4 @@ liftText :: T.Text -> Q Exp
 liftText txt = AppE (VarE 'T.pack) <$> TH.lift (T.unpack txt)
 
 liftDataWithText :: Data a => a -> Q Exp
-liftDataWithText = dataToExpQ (\a -> liftText <$> cast a)
+liftDataWithText = dataToExpQ (fmap liftText . cast)

lib/GHCup/Version.hs

@@ -12,13 +12,15 @@ Portability : POSIX
 -}
 module GHCup.Version where
 
-import           GHCup.Utils.Version.QQ
 import           GHCup.Types
+import           Paths_ghcup (version)
 
-import           Data.Versions
+import           Data.Version (Version(versionBranch))
+import           Data.Versions hiding (version)
 import           URI.ByteString
 import           URI.ByteString.QQ
 
+import qualified Data.List.NonEmpty            as NE
 import qualified Data.Text                     as T
 
 -- | This reflects the API version of the YAML.
@@ -27,7 +29,7 @@ ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.4.yaml|]
 
 -- | The current ghcup version.
 ghcUpVer :: PVP
-ghcUpVer = [pver|0.1.12|]
+ghcUpVer = PVP . NE.fromList . fmap fromIntegral $ versionBranch version
 
 -- | ghcup version as numeric string.
 numericVer :: String

stack.yaml

@@ -1,4 +1,4 @@
-resolver: lts-16.17
+resolver: lts-17.4
 
 packages:
   - .
@@ -6,49 +6,33 @@ packages:
 extra-deps:
   - 3rdparty/lzma
   - 3rdparty/lzma-clib
-  - 3rdparty/zlib
-
-  - git: https://github.com/haskus/packages.git
-    commit: 80a1c5fc07f7226c424250ec17f674cd4d618f42
-    subdirs:
-      - haskus-utils-types
-
-  - git: https://github.com/hasufell/hpath.git
-    commit: bf6d28cf989b70286e12fecc183d5bbf5454a1a2
-    subdirs:
-      - hpath-io
-      - hpath-directory
 
   - git: https://github.com/hasufell/text-conversions.git
     commit: 9abf0e5e5664a3178367597c32db19880477a53c
 
   - IfElse-0.85@sha256:6939b94acc6a55f545f63a168a349dd2fbe4b9a7cca73bf60282db5cc6aa47d2,445
-  - QuickCheck-2.14.1@sha256:01e46d7b0a8d3148288ec977625f62d5516ebb5031a50c63f0453863301b4a79,7736
   - ascii-string-1.0.1.4@sha256:fa34f1d9ba57e8e89c0d4c9cef5e01ba32cb2d4373d13f92dcc0b531a6c6749b,2582
-  - base64-bytestring-1.1.0.0@sha256:190264fef9e65d9085f00ccda419137096d1dc94777c58272bc96821dc7f37c3,2334
-  - brick-0.55@sha256:f98736eca0cd694837062e06da4655eed969d53b789dfd919716e9b6f5b4c5ce,15858
   - brotli-0.0.0.0@sha256:2bf383a4cd308745740986be0b18381c5a0784393fe69b91456aacb2d603de46,2964
   - brotli-streams-0.0.0.0@sha256:1af1e22f67b8bfd6ad0d05e61825e7a178d738f689ebbb21c1aab5f1bbcae176,2331
   - chs-cabal-0.1.1.0@sha256:20ec6a9fb5ab6991f1a4adf157c537bd5d3b98d08d3c09c387c954c7c50bd011,1153
   - chs-deps-0.1.0.0@sha256:0cdada6d2c682c41b20331b8c63c2ecfc7e806928585195fd544c9d41f3074fd,2496
-  - composition-prelude-3.0.0.0@sha256:7407835ce8c1e0e2fd6febd25391b12989b216773e685e3cf95bd89072af0ecc,1149
+  - composition-prelude-3.0.0.2@sha256:1ffed216bd28d810fce0b5be83a661e2a892696d73b3f8de5c0f5edb9b5f0090,1216
   - haskus-utils-data-1.3@sha256:f62c4e49021b463185d043f7b69c727b63af641a71d7edd582d9f4f98e80e500,1466
+  - haskus-utils-types-1.5.1@sha256:991c472f4e751e2f0d7aab6ad4220ef151d6160876dcf0511bbf876bbd432020,1298
   - haskus-utils-variant-3.0@sha256:8d51e45d3b664e61ccc25a58b37c0ccc4ee7537138b9fee21cd15c356906dd34,2159
   - hpath-0.11.0@sha256:12b8405bee13d0007d644a888ef8407069ce7bbbd76970f8746b801447124ade,1440
+  - hpath-directory-0.14.1@sha256:548ac1321222c34caa843a41a2379a77d961141082a4695bb37cc4731e91b2c7,5312
   - hpath-filepath-0.10.4@sha256:e9e44fb5fdbade7f30b5b5451257dbee15b6ef1aae4060034d73008bb3b5d878,1269
+  - hpath-io-0.14.1@sha256:d91373cd81483eb370a1c683e4add6182250dccce32f9b682bb1104f7765c750,1522
   - hpath-posix-0.13.2@sha256:eec4ff2b00dc86be847aca0f409fc8f6212ffd2170ec36a17dc9a52b46562392,1615
-  - http-io-streams-0.1.4.0@sha256:9a74a059daeddf7a41d361919190b9f4d4292f05e0e4bdf156e2098a116a8145,3582
-  - libarchive-3.0.0.0@sha256:e4157b307acf16cca0ec3d398ac5093cc06f092b33a9743be559ef0f6c6ae52f,11204
+  - http-io-streams-0.1.6.0@sha256:53f5bab177efb52cd65ec396fd04ed59b93e5f919fb3700cd7dacd6cfce6f06d,3582
+  - libarchive-3.0.2.1@sha256:40ebf2a278e585802427bc58826867208bb33822f63d56107a1fcc3ca04d691d,10990
   - os-release-1.0.1@sha256:1281c62081f438fc3f0874d3bae6a4887d5964ac25261ba06e29d368ab173467,2716
-  - primitive-extras-0.8@sha256:fca0310150496867f5b9421fe1541ecda87fae17eae44885a29f9c52dd00c8ff,2963
-  - primitive-unlifted-0.1.3.0@sha256:a98f827740f5dcf097d885b3a47c32f4462204449620abc9d51b8c4f8619f9e6,1427
-  - random-1.2.0@sha256:4321209c8faedc034810ea8ed0dbc4a36f1a1df97b75af024219f2f533da57de,6094
-  - splitmix-0.1.0.1@sha256:22f9662e7e8b173421872241edd39350078a9ed4bb9e9f503948c5b483c79276,5253
+  - primitive-0.7.0.1@sha256:a381571c36edc7dca28b77fe8159b43c14c640087ec5946adacf949feec64231,3433
+  - streamly-0.7.3@sha256:ad2a488fe802692ed47cab9fd0416c2904aac9e51cf2d8aafd1c3a40064c42f5,27421
+  - streamly-bytestring-0.1.2@sha256:cc828f41d1c714c711d38fb213b4ed186febabba598ab080e13255f69c20b13c,2469
   - streamly-posix-0.1.0.1@sha256:5d89b806281035d34020387ed99dde1ddab282c7ed66df3b7cd010b38fd3517b,2138
   - strict-base-0.4.0.0@sha256:2ff4e43cb95eedf2995558d7fc34d19362846413dd39e6aa6a5b3ea8228fef9f,1248
-  - tar-bytestring-0.6.3.2@sha256:88f29bed56b688c543a4cb3986402d64b360f76b3fd9b88ac618b8344f8da712,5715
-  - versions-4.0.1@sha256:0f644c1587d38f0eb3c3fe364bf1822424db43cbd4d618d0e21473b062c45239,1936
-  - vty-5.30@sha256:4af3938d7b9e6096e222bf52d0ea5d39873bc6fe19febd34106906306af13730,20857
   - xor-0.0.1.0@sha256:f8362b4a68562b9afbcd727ff64c1a303970df3a032e0033d2f4c094c3501df3,2243
 
 flags:
@@ -63,7 +47,7 @@ flags:
     internal-downloader: true
 
 system-ghc: true
-compiler: ghc-8.8.4
+compiler: ghc-8.10.4
 compiler-check: match-exact
 
 ghc-options:

test/GHCup/ArbitraryTypes.hs

@@ -1,10 +1,7 @@
 {-# OPTIONS_GHC -Wno-orphans #-}
 
 {-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE StandaloneDeriving #-}
-{-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE TypeApplications #-}
 
 module GHCup.ArbitraryTypes where
 
@@ -57,7 +54,7 @@ instance Arbitrary T.Text where
   shrink xs = T.pack <$> shrink (T.unpack xs)
 
 instance Arbitrary (NonEmpty Word) where
-  arbitrary = fmap fromList $ listOf1 $ arbitrary
+  arbitrary = fmap fromList $ listOf1 arbitrary
 
 -- utf8 encoded bytestring
 instance Arbitrary ByteString where
@@ -70,7 +67,7 @@ instance Arbitrary ByteString where
     ---------------------
 
 instance Arbitrary Scheme where
-  arbitrary = oneof [ Scheme <$> pure "http", Scheme <$> pure "https" ]
+  arbitrary = oneof [ pure (Scheme "http"), pure (Scheme "https") ]
 
 instance Arbitrary Host where
   arbitrary = genericArbitrary
@@ -82,7 +79,7 @@ instance Arbitrary Port where
 
 instance Arbitrary (URIRef Absolute) where
   arbitrary =
-    URI <$> arbitrary <*> pure Nothing <*> arbitrary <*> (Query <$> pure []) <*> pure Nothing
+    URI <$> arbitrary <*> pure Nothing <*> arbitrary <*> pure (Query []) <*> pure Nothing
 
 
 
@@ -95,32 +92,28 @@ instance Arbitrary Mess where
     (x, y, z) <- genVer
     pure
       $ either (error . show) id
-      $ mess
-      $ (intToText x <> "." <> intToText y <> "." <> intToText z)
+      $ mess (intToText x <> "." <> intToText y <> "." <> intToText z)
 
 instance Arbitrary Version where
   arbitrary = do
     (x, y, z) <- genVer
     pure
       $ either (error . show) id
-      $ version
-      $ (intToText x <> "." <> intToText y <> "." <> intToText z)
+      $ version (intToText x <> "." <> intToText y <> "." <> intToText z)
 
 instance Arbitrary SemVer where
   arbitrary = do
     (x, y, z) <- genVer
     pure
       $ either (error . show) id
-      $ semver
-      $ (intToText x <> "." <> intToText y <> "." <> intToText z)
+      $ semver (intToText x <> "." <> intToText y <> "." <> intToText z)
 
 instance Arbitrary PVP where
   arbitrary = do
     (x, y, z) <- genVer
     pure
       $ either (error . show) id
-      $ pvp
-      $ (intToText x <> "." <> intToText y <> "." <> intToText z)
+      $ pvp (intToText x <> "." <> intToText y <> "." <> intToText z)
 
 instance Arbitrary Versioning where
   arbitrary = Ideal <$> arbitrary
@@ -173,8 +166,8 @@ instance Arbitrary VersionCmp where
 
 instance Arbitrary (Path Rel) where
   arbitrary =
-    (either (error . show) id . parseRel . E.encodeUtf8 . T.pack)
-      <$> (listOf1 $ elements ['a' .. 'z'])
+    either (error . show) id . parseRel . E.encodeUtf8 . T.pack
+      <$> listOf1 (elements ['a' .. 'z'])
 
 instance Arbitrary TarDir where
   arbitrary = genericArbitrary

test/GHCup/Types/JSONSpec.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE TypeApplications #-}
 
 module GHCup.Types.JSONSpec where