gentoo-x86/eclass/haskell-cabal.eclass

# Copyright 1999-2011 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/eclass/haskell-cabal.eclass,v 1.20 2010/03/30 22:18:37 kolmodin Exp $
#
# Original authors: Andres Loeh <kosmikus@gentoo.org>
#                   Duncan Coutts <dcoutts@gentoo.org>
# Maintained by: Haskell herd <haskell@gentoo.org>
#
# This eclass is for packages that make use of the
# Haskell Common Architecture for Building Applications
# and Libraries (cabal).
#
# Basic instructions:
#
# Before inheriting the eclass, set CABAL_FEATURES to
# reflect the tools and features that the package makes
# use of.
#
# Currently supported features:
#   haddock    --  for documentation generation
#   hscolour   --  generation of colourised sources
#   alex       --  lexer/scanner generator
#   happy      --  parser generator
#   c2hs       --  C interface generator
#   cpphs      --  C preprocessor clone written in Haskell
#   profile    --  if package supports to build profiling-enabled libraries
#   bootstrap  --  only used for the cabal package itself
#   bin        --  the package installs binaries
#   lib        --  the package installs libraries
#   nocabaldep --  don't add dependency on cabal.
#                  only used for packages that _must_ not pull the dependency
#                  on cabal, but still use this eclass (e.g. haskell-updater).
#
# Dependencies on other cabal packages have to be specified
# correctly.
#
# Cabal libraries should usually be SLOTted with "${PV}".
#
# Many Cabal packages require S to be manually set.
#
# Conforming Cabal packages don't require any function definitions
# in the ebuild.
#
# Special flags to Cabal Configure can now be set by using
# CABAL_CONFIGURE_FLAGS

inherit ghc-package multilib

HASKELL_CABAL_EXPF="pkg_setup src_compile src_test src_install"

case "${EAPI:-0}" in
        2|3|4) HASKELL_CABAL_EXPF+=" src_configure" ;;
        *) ;;
esac

EXPORT_FUNCTIONS ${HASKELL_CABAL_EXPF}

for feature in ${CABAL_FEATURES}; do
        case ${feature} in
                haddock)    CABAL_USE_HADDOCK=yes;;
                hscolour)   CABAL_USE_HSCOLOUR=yes;;
                alex)       CABAL_USE_ALEX=yes;;
                happy)      CABAL_USE_HAPPY=yes;;
                c2hs)       CABAL_USE_C2HS=yes;;
                cpphs)      CABAL_USE_CPPHS=yes;;
                profile)    CABAL_USE_PROFILE=yes;;
                bootstrap)  CABAL_BOOTSTRAP=yes;;
                bin)        CABAL_HAS_BINARIES=yes;;
                lib)        CABAL_HAS_LIBRARIES=yes;;
                nocabaldep) CABAL_FROM_GHC=yes;;
                *) CABAL_UNKNOWN="${CABAL_UNKNOWN} ${feature}";;
        esac
done

if [[ -n "${CABAL_USE_HADDOCK}" ]]; then
        IUSE="${IUSE} doc"
        DEPEND="${DEPEND} doc? ( dev-haskell/haddock )"
fi

if [[ -n "${CABAL_USE_HSCOLOUR}" ]]; then
        IUSE="${IUSE} hscolour"
        DEPEND="${DEPEND} hscolour? ( dev-haskell/hscolour )"
fi

if [[ -n "${CABAL_USE_ALEX}" ]]; then
        DEPEND="${DEPEND} dev-haskell/alex"
fi

if [[ -n "${CABAL_USE_HAPPY}" ]]; then
        DEPEND="${DEPEND} dev-haskell/happy"
fi

if [[ -n "${CABAL_USE_C2HS}" ]]; then
        DEPEND="${DEPEND} dev-haskell/c2hs"
fi

if [[ -n "${CABAL_USE_CPPHS}" ]]; then
        DEPEND="${DEPEND} dev-haskell/cpphs"
fi

if [[ -n "${CABAL_USE_PROFILE}" ]]; then
        IUSE="${IUSE} profile"
fi

# We always use a standalone version of Cabal, rather than the one that comes
# with GHC. But of course we can't depend on cabal when building cabal itself.
if [[ -z ${CABAL_MIN_VERSION} ]]; then
        CABAL_MIN_VERSION=1.1.4
fi
if [[ -z "${CABAL_BOOTSTRAP}" && -z "${CABAL_FROM_GHC}" ]]; then
        DEPEND="${DEPEND} >=dev-haskell/cabal-${CABAL_MIN_VERSION}"
fi

# Libraries require GHC to be installed.
if [[ -n "${CABAL_HAS_LIBRARIES}" ]]; then
        RDEPEND="${RDEPEND} dev-lang/ghc"
fi

# returns the version of cabal currently in use
_CABAL_VERSION_CACHE=""
cabal-version() {
        if [[ -z "${_CABAL_VERSION_CACHE}" ]]; then
                if [[ "${CABAL_BOOTSTRAP}" ]]; then
                        # We're bootstrapping cabal, so the cabal version is the version
                        # of this package itself.
                        _CABAL_VERSION_CACHE="${PV}"
                elif [[ "${CABAL_FROM_GHC}" ]]; then
                        # We can't assume there's a version of Cabal installed by ebuild as
                        # this might be a first time install of GHC (for packages that
                        # use the shipped Cabal like haskell-updater).

                        # The user is likely to only have one version of Cabal, provided
                        # by GHC. Note that dev-haskell/cabal can be a dummy package, only
                        # using the version provided by GHC. If the user has another version
                        # of Cabal too (more recent than the one GHC provides through
                        # dev-haskell/cabal, or possibly older if he used an old
                        # Cabal package) the most recent is used (expected to be the last
                        # one in the ghc-pkg output).
                        _CABAL_VERSION_CACHE="$(ghc-pkg field Cabal version | tail -n 1)"

                        # Strip out the "version: " prefix
                        _CABAL_VERSION_CACHE="${_CABAL_VERSION_CACHE#"version: "}"
                else
                        # We ask portage, not ghc, so that we only pick up
                        # portage-installed cabal versions.
                        _CABAL_VERSION_CACHE="$(ghc-extractportageversion dev-haskell/cabal)"
                fi
        fi
        echo "${_CABAL_VERSION_CACHE}"
}

cabal-bootstrap() {
        local setupmodule
        local cabalpackage
        if [[ -f "${S}/Setup.lhs" ]]; then
                setupmodule="${S}/Setup.lhs"
        else
                if [[ -f "${S}/Setup.hs" ]]; then
                        setupmodule="${S}/Setup.hs"
                else
                        die "No Setup.lhs or Setup.hs found"
                fi
        fi

        # We build the setup program using the latest version of
        # cabal that we have installed
        if version_is_at_least "6.4" "$(ghc-version)"; then
                cabalpackage=Cabal-$(cabal-version)
        else
                # older ghc's don't support package versioning
                cabalpackage=Cabal
        fi
        einfo "Using cabal-$(cabal-version)."
        $(ghc-getghc) -package "${cabalpackage}" --make "${setupmodule}" -o setup \
                || die "compiling ${setupmodule} failed"
}

cabal-mksetup() {
        local setupdir

        if [[ -n $1 ]]; then
                setupdir=$1
        else
                setupdir=${S}
        fi

        rm -f "${setupdir}"/Setup.{lhs,hs}

        echo 'import Distribution.Simple; main = defaultMainWithHooks defaultUserHooks' \
                > $setupdir/Setup.hs
}

cabal-hscolour() {
        ./setup hscolour || die "setup hscolour failed"
}

cabal-haddock() {
        ./setup haddock || die "setup haddock failed"
}

cabal-hscolour-haddock() {
        # --hyperlink-source implies calling 'setup hscolour'
        ./setup haddock --hyperlink-source || die "setup haddock failed"
}

cabal-configure() {
        has "${EAPI:-0}" 0 1 2 && ! use prefix && EPREFIX=

        if [[ -n "${CABAL_USE_HADDOCK}" ]] && use doc; then
                cabalconf="${cabalconf} --with-haddock=${EPREFIX}/usr/bin/haddock"
        fi
        if [[ -n "${CABAL_USE_PROFILE}" ]] && use profile; then
                cabalconf="${cabalconf} --enable-library-profiling"
        fi
        if [[ -n "${CABAL_USE_ALEX}" ]]; then
                cabalconf="${cabalconf} --with-alex=${EPREFIX}/usr/bin/alex"
        fi

        if [[ -n "${CABAL_USE_HAPPY}" ]]; then
                cabalconf="${cabalconf} --with-happy=${EPREFIX}/usr/bin/happy"
        fi

        if [[ -n "${CABAL_USE_C2HS}" ]]; then
                cabalconf="${cabalconf} --with-c2hs=${EPREFIX}/usr/bin/c2hs"
        fi
        if [[ -n "${CABAL_USE_CPPHS}" ]]; then
                cabalconf="${cabalconf} --with-cpphs=${EPREFIX}/usr/bin/cpphs"
        fi

        # Building GHCi libs on ppc64 causes "TOC overflow".
        if use ppc64; then
                cabalconf="${cabalconf} --disable-library-for-ghci"
        fi

        if version_is_at_least "1.4" "$(cabal-version)"; then
                # disable executable stripping for the executables, as portage will
                # strip by itself, and pre-stripping gives a QA warning.
                # cabal versions previous to 1.4 does not strip executables, and does
                # not accept the flag.
                # this fixes numerous bugs, amongst them;
                # bug #251881, bug #251882, bug #251884, bug #251886, bug #299494
                cabalconf="${cabalconf} --disable-executable-stripping"
        fi

        if version_is_at_least "1.2.0" "$(cabal-version)"; then
                cabalconf="${cabalconf} --docdir=${EPREFIX}/usr/share/doc/${PF}"
                # As of Cabal 1.2, configure is quite quiet. For diagnostic purposes
                # it's better if the configure chatter is in the build logs:
                cabalconf="${cabalconf} --verbose"
        fi
        # Note: with Cabal-1.1.6.x we do not have enough control
        # to put the docs into the right place. They're currently going
        # into                  /usr/share/${P}/ghc-x.y/doc/
        # rather than   /usr/share/doc/${PF}/
        # Because we can only set the datadir, not the docdir.

        ./setup configure \
                --ghc --prefix="${EPREFIX}"/usr \
                --with-compiler="$(ghc-getghc)" \
                --with-hc-pkg="$(ghc-getghcpkg)" \
                --prefix="${EPREFIX}"/usr \
                --libdir="${EPREFIX}"/usr/$(get_libdir) \
                --libsubdir=${P}/ghc-$(ghc-version) \
                --datadir="${EPREFIX}"/usr/share/ \
                --datasubdir=${P}/ghc-$(ghc-version) \
                ${cabalconf} \
                ${CABAL_CONFIGURE_FLAGS} \
                "$@" || die "setup configure failed"
}

cabal-build() {
        unset LANG LC_ALL LC_MESSAGES
        ./setup build \
                || die "setup build failed"
}

cabal-copy() {
        has "${EAPI:-0}" 0 1 2 && ! use prefix && ED=${D}

        ./setup copy \
                --destdir="${D}" \
                || die "setup copy failed"

        # cabal is a bit eager about creating dirs,
        # so remove them if they are empty
        rmdir "${ED}/usr/bin" 2> /dev/null

        # GHC 6.4 has a bug in get/setPermission and Cabal 1.1.1 has
        # no workaround.
        # set the +x permission on executables
        if [[ -d "${ED}/usr/bin" ]] ; then
                chmod +x "${ED}/usr/bin/"*
        fi
        # TODO: do we still need this?
}

cabal-pkg() {
        # This does not actually register since we're using true instead
        # of ghc-pkg. So it just leaves the .installed-pkg-config and we can
        # register that ourselves (if it exists).
        local result
        local err

        if [[ -n ${CABAL_HAS_LIBRARIES} ]]; then
                if version_is_at_least "1.2.0" "$(cabal-version)"; then
                        # Newer cabal can generate a package conf for us:
                        ./setup register --gen-pkg-config="${T}/${P}.conf"
                        ghc-setup-pkg "${T}/${P}.conf"
                        ghc-install-pkg
                else
                        # With older cabal we have to hack it by replacing its ghc-pkg
                        # with true and then just picking up the .installed-pkg-config
                        # file and registering that ourselves (if it exists).
                        sed -i "s|$(ghc-getghcpkg)|$(type -P true)|" .setup-config
                        ./setup register || die "setup register failed"
                        if [[ -f .installed-pkg-config ]]; then
                                ghc-setup-pkg .installed-pkg-config
                                ghc-install-pkg
                        else
                                die "setup register has not generated a package configuration file"
                        fi
                fi
        fi
}

# Some cabal libs are bundled along with some versions of ghc
# eg filepath-1.0 comes with ghc-6.6.1
# by putting CABAL_CORE_LIB_GHC_PV="6.6.1" in an ebuild we are declaring that
# when building with this version of ghc, the ebuild is a dummy that is it will
# install no files since the package is already included with ghc.
# However portage still records the dependency and we can upgrade the package
# to a later one that's not included with ghc.
# You can also put a space separated list, eg CABAL_CORE_LIB_GHC_PV="6.6 6.6.1".
cabal-is-dummy-lib() {
        for version in ${CABAL_CORE_LIB_GHC_PV[*]}; do
                [[ "$(ghc-version)" == "$version" ]] && return 0
        done
        return 1
}

# exported function: check if cabal is correctly installed for
# the currently active ghc (we cannot guarantee this with portage)
haskell-cabal_pkg_setup() {
        ghc-package_pkg_setup
        if [[ -z "${CABAL_BOOTSTRAP}" && -z "${CABAL_FROM_GHC}" ]] && ! ghc-sanecabal "${CABAL_MIN_VERSION}"; then
                eerror "The package dev-haskell/cabal is not correctly installed for"
                eerror "the currently active version of ghc ($(ghc-version)). Please"
                eerror "run ghc-updater or haskell-updater or re-build dev-haskell/cabal."
                die "cabal is not correctly installed"
        fi
        if [[ -z "${CABAL_HAS_BINARIES}" ]] && [[ -z "${CABAL_HAS_LIBRARIES}" ]]; then
                eerror "QA: Neither bin nor lib are in CABAL_FEATURES."
        fi
        if [[ -n "${CABAL_UNKNOWN}" ]]; then
                ewarn "Unknown entry in CABAL_FEATURES: ${CABAL_UNKNOWN}"
        fi
        if cabal-is-dummy-lib; then
                einfo "${P} is included in ghc-${CABAL_CORE_LIB_GHC_PV}, nothing to install."
        fi
}

haskell-cabal_src_configure() {
        if ! cabal-is-dummy-lib; then
                pushd "${S}" > /dev/null

                cabal-bootstrap

                ghc_flags=""
                # currently cabal does not respect CFLAGS and LDFLAGS on it's own (bug #333217)
                # so translate LDFLAGS to ghc parameters (without filtering)
                for flag in $LDFLAGS; do ghc_flags="${ghc_flags} --ghc-option=-optl$flag"; done

                cabal-configure $ghc_flags "$@"

                popd > /dev/null
        fi
}

# exported function: nice alias
cabal_src_configure() {
        haskell-cabal_src_configure "$@"
}

# exported function: cabal-style bootstrap configure and compile
cabal_src_compile() {
        if ! cabal-is-dummy-lib; then
                has src_configure ${HASKELL_CABAL_EXPF} || haskell-cabal_src_configure "$@"
                cabal-build

                if [[ -n "${CABAL_USE_HADDOCK}" ]] && use doc; then
                        if [[ -n "${CABAL_USE_HSCOLOUR}" ]] && use hscolour; then
                                # hscolour and haddock
                                cabal-hscolour-haddock
                        else
                                # just haddock
                                cabal-haddock
                        fi
                else
                        if [[ -n "${CABAL_USE_HSCOLOUR}" ]] && use hscolour; then
                                # just hscolour
                                cabal-hscolour
                        fi
                fi
        fi
}

haskell-cabal_src_compile() {
        pushd "${S}" > /dev/null

        cabal_src_compile "$@"

        popd > /dev/null
}

haskell-cabal_src_test() {
        pushd "${S}" > /dev/null

        if cabal-is-dummy-lib; then
                einfo ">>> No tests for dummy library: ${CATEGORY}/${PF}"
        else
                einfo ">>> Test phase [cabal test]: ${CATEGORY}/${PF}"
                ./setup test || die "cabal test failed"
        fi

        popd > /dev/null
}

# exported function: cabal-style copy and register
cabal_src_install() {
        has "${EAPI:-0}" 0 1 2 && ! use prefix && EPREFIX=

        if cabal-is-dummy-lib; then
                # create a dummy local package conf file for the sake of ghc-updater
                local ghc_confdir_with_prefix="$(ghc-confdir)"
                # remove EPREFIX
                dodir ${ghc_confdir_with_prefix#${EPREFIX}}
                echo '[]' > "${D}/$(ghc-confdir)/$(ghc-localpkgconf)"
        else
                cabal-copy
                cabal-pkg

                if [[ -n "${CABAL_USE_HADDOCK}" ]] && use doc; then
                        if ! version_is_at_least "1.1.6" "$(cabal-version)"; then
                                dohtml -r dist/doc/html/*
                        fi
                fi
        fi
}

haskell-cabal_src_install() {
        pushd "${S}" > /dev/null

        cabal_src_install

        popd > /dev/null
}

# ebuild.sh:use_enable() taken as base
#
# Usage examples:
#
#     CABAL_CONFIGURE_FLAGS=$(cabal_flag gui)
#  leads to "--flags=gui" or "--flags=-gui" (useflag 'gui')
#
#     CABAL_CONFIGURE_FLAGS=$(cabal_flag gtk gui)
#  also leads to "--flags=gui" or " --flags=-gui" (useflag 'gtk')
#
cabal_flag() {
        if [[ -z "$1" ]]; then
                echo "!!! cabal_flag() called without a parameter." >&2
                echo "!!! cabal_flag() <USEFLAG> [<cabal_flagname>]" >&2
                return 1
        fi

        local UWORD=${2:-$1}

        if use "$1"; then
                echo "--flags=${UWORD}"
        else
                echo "--flags=-${UWORD}"
        fi

        return 0
}
1	slyfox	1.23	# Copyright 1999-2011 Gentoo Foundation
2	kosmikus	1.1	# Distributed under the terms of the GNU General Public License v2
3	slyfox	1.23	# $Header: /var/cvsroot/gentoo-x86/eclass/haskell-cabal.eclass,v 1.20 2010/03/30 22:18:37 kolmodin Exp $
4	kosmikus	1.1	#
5			# Original authors: Andres Loeh <kosmikus@gentoo.org>
6			# Duncan Coutts <dcoutts@gentoo.org>
7			# Maintained by: Haskell herd <haskell@gentoo.org>
8			#
9			# This eclass is for packages that make use of the
10			# Haskell Common Architecture for Building Applications
11			# and Libraries (cabal).
12			#
13			# Basic instructions:
14			#
15			# Before inheriting the eclass, set CABAL_FEATURES to
16			# reflect the tools and features that the package makes
17			# use of.
18			#
19			# Currently supported features:
20			# haddock -- for documentation generation
21	kolmodin	1.21	# hscolour -- generation of colourised sources
22	kosmikus	1.1	# alex -- lexer/scanner generator
23			# happy -- parser generator
24			# c2hs -- C interface generator
25			# cpphs -- C preprocessor clone written in Haskell
26			# profile -- if package supports to build profiling-enabled libraries
27			# bootstrap -- only used for the cabal package itself
28	dcoutts	1.3	# bin -- the package installs binaries
29			# lib -- the package installs libraries
30	kolmodin	1.16	# nocabaldep -- don't add dependency on cabal.
31	slyfox	1.23	# only used for packages that _must_ not pull the dependency
32			# on cabal, but still use this eclass (e.g. haskell-updater).
33	kosmikus	1.1	#
34			# Dependencies on other cabal packages have to be specified
35			# correctly.
36			#
37			# Cabal libraries should usually be SLOTted with "${PV}".
38			#
39			# Many Cabal packages require S to be manually set.
40			#
41			# Conforming Cabal packages don't require any function definitions
42			# in the ebuild.
43	kosmikus	1.8	#
44			# Special flags to Cabal Configure can now be set by using
45			# CABAL_CONFIGURE_FLAGS
46	kosmikus	1.1
47	dcoutts	1.11	inherit ghc-package multilib
48	kosmikus	1.1
49	kolmodin	1.19	HASKELL_CABAL_EXPF="pkg_setup src_compile src_test src_install"
50
51			case "${EAPI:-0}" in
52			2\|3\|4) HASKELL_CABAL_EXPF+=" src_configure" ;;
53			*) ;;
54			esac
55
56			EXPORT_FUNCTIONS ${HASKELL_CABAL_EXPF}
57	kosmikus	1.1
58			for feature in ${CABAL_FEATURES}; do
59			case ${feature} in
60	kolmodin	1.16	haddock) CABAL_USE_HADDOCK=yes;;
61	kolmodin	1.21	hscolour) CABAL_USE_HSCOLOUR=yes;;
62	kolmodin	1.16	alex) CABAL_USE_ALEX=yes;;
63			happy) CABAL_USE_HAPPY=yes;;
64			c2hs) CABAL_USE_C2HS=yes;;
65			cpphs) CABAL_USE_CPPHS=yes;;
66			profile) CABAL_USE_PROFILE=yes;;
67			bootstrap) CABAL_BOOTSTRAP=yes;;
68			bin) CABAL_HAS_BINARIES=yes;;
69			lib) CABAL_HAS_LIBRARIES=yes;;
70			nocabaldep) CABAL_FROM_GHC=yes;;
71	dcoutts	1.3	*) CABAL_UNKNOWN="${CABAL_UNKNOWN} ${feature}";;
72	kosmikus	1.1	esac
73			done
74
75			if [[ -n "${CABAL_USE_HADDOCK}" ]]; then
76			IUSE="${IUSE} doc"
77			DEPEND="${DEPEND} doc? ( dev-haskell/haddock )"
78			fi
79
80	kolmodin	1.21	if [[ -n "${CABAL_USE_HSCOLOUR}" ]]; then
81			IUSE="${IUSE} hscolour"
82			DEPEND="${DEPEND} hscolour? ( dev-haskell/hscolour )"
83			fi
84
85	kosmikus	1.1	if [[ -n "${CABAL_USE_ALEX}" ]]; then
86			DEPEND="${DEPEND} dev-haskell/alex"
87			fi
88
89			if [[ -n "${CABAL_USE_HAPPY}" ]]; then
90			DEPEND="${DEPEND} dev-haskell/happy"
91			fi
92
93			if [[ -n "${CABAL_USE_C2HS}" ]]; then
94			DEPEND="${DEPEND} dev-haskell/c2hs"
95			fi
96
97			if [[ -n "${CABAL_USE_CPPHS}" ]]; then
98			DEPEND="${DEPEND} dev-haskell/cpphs"
99			fi
100
101			if [[ -n "${CABAL_USE_PROFILE}" ]]; then
102			IUSE="${IUSE} profile"
103			fi
104
105			# We always use a standalone version of Cabal, rather than the one that comes
106			# with GHC. But of course we can't depend on cabal when building cabal itself.
107	dcoutts	1.14	if [[ -z ${CABAL_MIN_VERSION} ]]; then
108			CABAL_MIN_VERSION=1.1.4
109			fi
110	kolmodin	1.16	if [[ -z "${CABAL_BOOTSTRAP}" && -z "${CABAL_FROM_GHC}" ]]; then
111	dcoutts	1.11	DEPEND="${DEPEND} >=dev-haskell/cabal-${CABAL_MIN_VERSION}"
112	kosmikus	1.1	fi
113
114	dcoutts	1.3	# Libraries require GHC to be installed.
115			if [[ -n "${CABAL_HAS_LIBRARIES}" ]]; then
116	dcoutts	1.11	RDEPEND="${RDEPEND} dev-lang/ghc"
117	dcoutts	1.3	fi
118	kosmikus	1.1
119	dcoutts	1.14	# returns the version of cabal currently in use
120			_CABAL_VERSION_CACHE=""
121			cabal-version() {
122			if [[ -z "${_CABAL_VERSION_CACHE}" ]]; then
123			if [[ "${CABAL_BOOTSTRAP}" ]]; then
124			# We're bootstrapping cabal, so the cabal version is the version
125			# of this package itself.
126			_CABAL_VERSION_CACHE="${PV}"
127	kolmodin	1.17	elif [[ "${CABAL_FROM_GHC}" ]]; then
128			# We can't assume there's a version of Cabal installed by ebuild as
129			# this might be a first time install of GHC (for packages that
130			# use the shipped Cabal like haskell-updater).
131
132			# The user is likely to only have one version of Cabal, provided
133			# by GHC. Note that dev-haskell/cabal can be a dummy package, only
134			# using the version provided by GHC. If the user has another version
135			# of Cabal too (more recent than the one GHC provides through
136			# dev-haskell/cabal, or possibly older if he used an old
137			# Cabal package) the most recent is used (expected to be the last
138			# one in the ghc-pkg output).
139			_CABAL_VERSION_CACHE="$(ghc-pkg field Cabal version \| tail -n 1)"
140
141			# Strip out the "version: " prefix
142			_CABAL_VERSION_CACHE="${_CABAL_VERSION_CACHE#"version: "}"
143	dcoutts	1.14	else
144			# We ask portage, not ghc, so that we only pick up
145			# portage-installed cabal versions.
146			_CABAL_VERSION_CACHE="$(ghc-extractportageversion dev-haskell/cabal)"
147			fi
148			fi
149			echo "${_CABAL_VERSION_CACHE}"
150			}
151
152	kosmikus	1.1	cabal-bootstrap() {
153			local setupmodule
154	dcoutts	1.14	local cabalpackage
155	kosmikus	1.1	if [[ -f "${S}/Setup.lhs" ]]; then
156			setupmodule="${S}/Setup.lhs"
157			else
158			if [[ -f "${S}/Setup.hs" ]]; then
159			setupmodule="${S}/Setup.hs"
160			else
161			die "No Setup.lhs or Setup.hs found"
162			fi
163			fi
164
165			# We build the setup program using the latest version of
166			# cabal that we have installed
167	dcoutts	1.14	if version_is_at_least "6.4" "$(ghc-version)"; then
168			cabalpackage=Cabal-$(cabal-version)
169			else
170			# older ghc's don't support package versioning
171			cabalpackage=Cabal
172			fi
173			einfo "Using cabal-$(cabal-version)."
174			$(ghc-getghc) -package "${cabalpackage}" --make "${setupmodule}" -o setup \
175	kosmikus	1.1	\|\| die "compiling ${setupmodule} failed"
176			}
177
178	dcoutts	1.14	cabal-mksetup() {
179			local setupdir
180
181			if [[ -n $1 ]]; then
182			setupdir=$1
183			else
184			setupdir=${S}
185			fi
186
187			rm -f "${setupdir}"/Setup.{lhs,hs}
188
189			echo 'import Distribution.Simple; main = defaultMainWithHooks defaultUserHooks' \
190			> $setupdir/Setup.hs
191			}
192
193	kolmodin	1.21	cabal-hscolour() {
194			./setup hscolour \|\| die "setup hscolour failed"
195			}
196
197	kosmikus	1.1	cabal-haddock() {
198			./setup haddock \|\| die "setup haddock failed"
199			}
200
201	kolmodin	1.21	cabal-hscolour-haddock() {
202			# --hyperlink-source implies calling 'setup hscolour'
203			./setup haddock --hyperlink-source \|\| die "setup haddock failed"
204			}
205
206	kosmikus	1.1	cabal-configure() {
207	slyfox	1.23	has "${EAPI:-0}" 0 1 2 && ! use prefix && EPREFIX=
208
209	dcoutts	1.14	if [[ -n "${CABAL_USE_HADDOCK}" ]] && use doc; then
210	slyfox	1.23	cabalconf="${cabalconf} --with-haddock=${EPREFIX}/usr/bin/haddock"
211	dcoutts	1.14	fi
212	kosmikus	1.1	if [[ -n "${CABAL_USE_PROFILE}" ]] && use profile; then
213	dcoutts	1.2	cabalconf="${cabalconf} --enable-library-profiling"
214	kosmikus	1.1	fi
215	slyfox	1.23	if [[ -n "${CABAL_USE_ALEX}" ]]; then
216			cabalconf="${cabalconf} --with-alex=${EPREFIX}/usr/bin/alex"
217			fi
218
219			if [[ -n "${CABAL_USE_HAPPY}" ]]; then
220			cabalconf="${cabalconf} --with-happy=${EPREFIX}/usr/bin/happy"
221			fi
222
223			if [[ -n "${CABAL_USE_C2HS}" ]]; then
224			cabalconf="${cabalconf} --with-c2hs=${EPREFIX}/usr/bin/c2hs"
225			fi
226			if [[ -n "${CABAL_USE_CPPHS}" ]]; then
227			cabalconf="${cabalconf} --with-cpphs=${EPREFIX}/usr/bin/cpphs"
228			fi
229
230	dcoutts	1.6	# Building GHCi libs on ppc64 causes "TOC overflow".
231			if use ppc64; then
232	dcoutts	1.5	cabalconf="${cabalconf} --disable-library-for-ghci"
233			fi
234	kosmikus	1.1
235	kolmodin	1.18	if version_is_at_least "1.4" "$(cabal-version)"; then
236			# disable executable stripping for the executables, as portage will
237			# strip by itself, and pre-stripping gives a QA warning.
238			# cabal versions previous to 1.4 does not strip executables, and does
239			# not accept the flag.
240			# this fixes numerous bugs, amongst them;
241			# bug #251881, bug #251882, bug #251884, bug #251886, bug #299494
242			cabalconf="${cabalconf} --disable-executable-stripping"
243			fi
244
245	dcoutts	1.14	if version_is_at_least "1.2.0" "$(cabal-version)"; then
246	slyfox	1.23	cabalconf="${cabalconf} --docdir=${EPREFIX}/usr/share/doc/${PF}"
247	dcoutts	1.14	# As of Cabal 1.2, configure is quite quiet. For diagnostic purposes
248			# it's better if the configure chatter is in the build logs:
249			cabalconf="${cabalconf} --verbose"
250			fi
251			# Note: with Cabal-1.1.6.x we do not have enough control
252	dcoutts	1.11	# to put the docs into the right place. They're currently going
253			# into /usr/share/${P}/ghc-x.y/doc/
254			# rather than /usr/share/doc/${PF}/
255			# Because we can only set the datadir, not the docdir.
256
257	kosmikus	1.1	./setup configure \
258	slyfox	1.23	--ghc --prefix="${EPREFIX}"/usr \
259	kosmikus	1.1	--with-compiler="$(ghc-getghc)" \
260			--with-hc-pkg="$(ghc-getghcpkg)" \
261	slyfox	1.23	--prefix="${EPREFIX}"/usr \
262			--libdir="${EPREFIX}"/usr/$(get_libdir) \
263	dcoutts	1.11	--libsubdir=${P}/ghc-$(ghc-version) \
264	slyfox	1.23	--datadir="${EPREFIX}"/usr/share/ \
265	dcoutts	1.11	--datasubdir=${P}/ghc-$(ghc-version) \
266	kosmikus	1.1	${cabalconf} \
267	kosmikus	1.8	${CABAL_CONFIGURE_FLAGS} \
268	kosmikus	1.1	"$@" \|\| die "setup configure failed"
269			}
270
271			cabal-build() {
272	dcoutts	1.14	unset LANG LC_ALL LC_MESSAGES
273	kosmikus	1.1	./setup build \
274			\|\| die "setup build failed"
275			}
276
277			cabal-copy() {
278	slyfox	1.23	has "${EAPI:-0}" 0 1 2 && ! use prefix && ED=${D}
279
280	kosmikus	1.1	./setup copy \
281	dcoutts	1.11	--destdir="${D}" \
282	kosmikus	1.1	\|\| die "setup copy failed"
283
284			# cabal is a bit eager about creating dirs,
285			# so remove them if they are empty
286	slyfox	1.23	rmdir "${ED}/usr/bin" 2> /dev/null
287	kosmikus	1.1
288			# GHC 6.4 has a bug in get/setPermission and Cabal 1.1.1 has
289			# no workaround.
290			# set the +x permission on executables
291	slyfox	1.23	if [[ -d "${ED}/usr/bin" ]] ; then
292			chmod +x "${ED}/usr/bin/"*
293	kosmikus	1.1	fi
294	dcoutts	1.11	# TODO: do we still need this?
295	kosmikus	1.1	}
296
297			cabal-pkg() {
298	kosmikus	1.9	# This does not actually register since we're using true instead
299	kosmikus	1.1	# of ghc-pkg. So it just leaves the .installed-pkg-config and we can
300			# register that ourselves (if it exists).
301	dcoutts	1.2	local result
302			local err
303
304	dcoutts	1.4	if [[ -n ${CABAL_HAS_LIBRARIES} ]]; then
305	dcoutts	1.14	if version_is_at_least "1.2.0" "$(cabal-version)"; then
306			# Newer cabal can generate a package conf for us:
307			./setup register --gen-pkg-config="${T}/${P}.conf"
308			ghc-setup-pkg "${T}/${P}.conf"
309	dcoutts	1.4	ghc-install-pkg
310			else
311	dcoutts	1.14	# With older cabal we have to hack it by replacing its ghc-pkg
312			# with true and then just picking up the .installed-pkg-config
313			# file and registering that ourselves (if it exists).
314			sed -i "s\|$(ghc-getghcpkg)\|$(type -P true)\|" .setup-config
315			./setup register \|\| die "setup register failed"
316			if [[ -f .installed-pkg-config ]]; then
317			ghc-setup-pkg .installed-pkg-config
318			ghc-install-pkg
319			else
320			die "setup register has not generated a package configuration file"
321			fi
322	dcoutts	1.4	fi
323	kosmikus	1.1	fi
324			}
325
326	kolmodin	1.13	# Some cabal libs are bundled along with some versions of ghc
327			# eg filepath-1.0 comes with ghc-6.6.1
328			# by putting CABAL_CORE_LIB_GHC_PV="6.6.1" in an ebuild we are declaring that
329			# when building with this version of ghc, the ebuild is a dummy that is it will
330			# install no files since the package is already included with ghc.
331			# However portage still records the dependency and we can upgrade the package
332			# to a later one that's not included with ghc.
333			# You can also put a space separated list, eg CABAL_CORE_LIB_GHC_PV="6.6 6.6.1".
334			cabal-is-dummy-lib() {
335			for version in ${CABAL_CORE_LIB_GHC_PV[*]}; do
336			[[ "$(ghc-version)" == "$version" ]] && return 0
337			done
338			return 1
339			}
340
341	kosmikus	1.1	# exported function: check if cabal is correctly installed for
342			# the currently active ghc (we cannot guarantee this with portage)
343			haskell-cabal_pkg_setup() {
344	dcoutts	1.11	ghc-package_pkg_setup
345	kolmodin	1.16	if [[ -z "${CABAL_BOOTSTRAP}" && -z "${CABAL_FROM_GHC}" ]] && ! ghc-sanecabal "${CABAL_MIN_VERSION}"; then
346	kosmikus	1.1	eerror "The package dev-haskell/cabal is not correctly installed for"
347			eerror "the currently active version of ghc ($(ghc-version)). Please"
348	kolmodin	1.16	eerror "run ghc-updater or haskell-updater or re-build dev-haskell/cabal."
349	kosmikus	1.1	die "cabal is not correctly installed"
350			fi
351	dcoutts	1.4	if [[ -z "${CABAL_HAS_BINARIES}" ]] && [[ -z "${CABAL_HAS_LIBRARIES}" ]]; then
352			eerror "QA: Neither bin nor lib are in CABAL_FEATURES."
353			fi
354	dcoutts	1.3	if [[ -n "${CABAL_UNKNOWN}" ]]; then
355	kolmodin	1.15	ewarn "Unknown entry in CABAL_FEATURES: ${CABAL_UNKNOWN}"
356	dcoutts	1.3	fi
357	kolmodin	1.13	if cabal-is-dummy-lib; then
358			einfo "${P} is included in ghc-${CABAL_CORE_LIB_GHC_PV}, nothing to install."
359			fi
360	kosmikus	1.1	}
361
362	kolmodin	1.19	haskell-cabal_src_configure() {
363	slyfox	1.23	if ! cabal-is-dummy-lib; then
364			pushd "${S}" > /dev/null
365	kolmodin	1.19
366	slyfox	1.23	cabal-bootstrap
367	slyfox	1.22
368	slyfox	1.23	ghc_flags=""
369			# currently cabal does not respect CFLAGS and LDFLAGS on it's own (bug #333217)
370			# so translate LDFLAGS to ghc parameters (without filtering)
371			for flag in $LDFLAGS; do ghc_flags="${ghc_flags} --ghc-option=-optl$flag"; done
372	slyfox	1.22
373	slyfox	1.23	cabal-configure $ghc_flags "$@"
374	kolmodin	1.19
375	slyfox	1.23	popd > /dev/null
376			fi
377	kolmodin	1.19	}
378
379			# exported function: nice alias
380			cabal_src_configure() {
381			haskell-cabal_src_configure "$@"
382			}
383
384	kosmikus	1.1	# exported function: cabal-style bootstrap configure and compile
385			cabal_src_compile() {
386	kolmodin	1.13	if ! cabal-is-dummy-lib; then
387	kolmodin	1.19	has src_configure ${HASKELL_CABAL_EXPF} \|\| haskell-cabal_src_configure "$@"
388	kolmodin	1.13	cabal-build
389	kosmikus	1.1
390	kolmodin	1.13	if [[ -n "${CABAL_USE_HADDOCK}" ]] && use doc; then
391	kolmodin	1.21	if [[ -n "${CABAL_USE_HSCOLOUR}" ]] && use hscolour; then
392			# hscolour and haddock
393			cabal-hscolour-haddock
394			else
395			# just haddock
396			cabal-haddock
397			fi
398			else
399			if [[ -n "${CABAL_USE_HSCOLOUR}" ]] && use hscolour; then
400			# just hscolour
401			cabal-hscolour
402			fi
403	kolmodin	1.13	fi
404	kosmikus	1.1	fi
405			}
406	kolmodin	1.16
407	kosmikus	1.1	haskell-cabal_src_compile() {
408	kolmodin	1.19	pushd "${S}" > /dev/null
409
410			cabal_src_compile "$@"
411
412			popd > /dev/null
413			}
414
415			haskell-cabal_src_test() {
416			pushd "${S}" > /dev/null
417
418	kolmodin	1.20	if cabal-is-dummy-lib; then
419			einfo ">>> No tests for dummy library: ${CATEGORY}/${PF}"
420			else
421			einfo ">>> Test phase [cabal test]: ${CATEGORY}/${PF}"
422			./setup test \|\| die "cabal test failed"
423			fi
424	kolmodin	1.19
425			popd > /dev/null
426	kosmikus	1.1	}
427
428			# exported function: cabal-style copy and register
429			cabal_src_install() {
430	slyfox	1.23	has "${EAPI:-0}" 0 1 2 && ! use prefix && EPREFIX=
431
432	kolmodin	1.13	if cabal-is-dummy-lib; then
433			# create a dummy local package conf file for the sake of ghc-updater
434	slyfox	1.23	local ghc_confdir_with_prefix="$(ghc-confdir)"
435			# remove EPREFIX
436			dodir ${ghc_confdir_with_prefix#${EPREFIX}}
437	kolmodin	1.13	echo '[]' > "${D}/$(ghc-confdir)/$(ghc-localpkgconf)"
438			else
439			cabal-copy
440			cabal-pkg
441	kosmikus	1.1
442	kolmodin	1.13	if [[ -n "${CABAL_USE_HADDOCK}" ]] && use doc; then
443	dcoutts	1.14	if ! version_is_at_least "1.1.6" "$(cabal-version)"; then
444	kolmodin	1.13	dohtml -r dist/doc/html/*
445			fi
446	dcoutts	1.11	fi
447	kosmikus	1.1	fi
448			}
449	kolmodin	1.19
450	kosmikus	1.1	haskell-cabal_src_install() {
451	kolmodin	1.19	pushd "${S}" > /dev/null
452
453	kosmikus	1.1	cabal_src_install
454	kolmodin	1.19
455			popd > /dev/null
456	kosmikus	1.1	}
457
458	kolmodin	1.19	# ebuild.sh:use_enable() taken as base
459			#
460			# Usage examples:
461			#
462			# CABAL_CONFIGURE_FLAGS=$(cabal_flag gui)
463			# leads to "--flags=gui" or "--flags=-gui" (useflag 'gui')
464			#
465			# CABAL_CONFIGURE_FLAGS=$(cabal_flag gtk gui)
466			# also leads to "--flags=gui" or " --flags=-gui" (useflag 'gtk')
467			#
468			cabal_flag() {
469			if [[ -z "$1" ]]; then
470			echo "!!! cabal_flag() called without a parameter." >&2
471			echo "!!! cabal_flag() <USEFLAG> [<cabal_flagname>]" >&2
472			return 1
473			fi
474
475			local UWORD=${2:-$1}
476
477			if use "$1"; then
478			echo "--flags=${UWORD}"
479			else
480			echo "--flags=-${UWORD}"
481			fi
482
483			return 0
484			}