gentoo-x86/eclass/haskell-cabal.eclass

# Copyright 1999-2012 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/eclass/haskell-cabal.eclass,v 1.25 2011/08/22 04:46:32 vapier Exp $

# @ECLASS: haskell-cabal.eclass
# @MAINTAINER:
# Haskell herd <haskell@gentoo.org>
# @AUTHOR:
# Original author: Andres Loeh <kosmikus@gentoo.org>
# Original author: Duncan Coutts <dcoutts@gentoo.org>
# @BLURB: for packages that make use of the Haskell Common Architecture for Building Applications and Libraries (cabal)
# @DESCRIPTION:
# 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

# @ECLASS-VARIABLE: CABAL_EXTRA_CONFIGURE_FLAGS
# @DESCRIPTION:
# User-specified additional parameters passed to 'setup configure'.
# example: /etc/make.conf: CABAL_EXTRA_CONFIGURE_FLAGS=--enable-shared
: ${CABAL_EXTRA_CONFIGURE_FLAGS:=}

# @ECLASS-VARIABLE: GHC_BOOTSTRAP_FLAGS
# @DESCRIPTION:
# User-specified additional parameters for ghc when building
# _only_ 'setup' binary bootstrap.
# example: /etc/make.conf: GHC_BOOTSTRAP_FLAGS=-dynamic to make
# linking 'setup' faster.
: ${GHC_BOOTSTRAP_FLAGS:=}

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;;
                hoogle)     CABAL_USE_HOOGLE=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
                        local cabal_package=$(echo "$(ghc-libdir)"/Cabal-*)
                        # /path/to/ghc/Cabal-${VER} -> ${VER}
                        _CABAL_VERSION_CACHE="${cabal_package/*Cabal-/}"
                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)."

        make_setup() {
                set -- -package "${cabalpackage}" --make "${setupmodule}" \
                        ${GHC_BOOTSTRAP_FLAGS} \
                        "$@" \
                        -o setup
                echo $(ghc-getghc) "$@"
                $(ghc-getghc) "$@"
        }
        if $(ghc-supports-shared-libraries); then
                # some custom build systems might use external libraries,
                # for which we don't have shared libs, so keep static fallback
                make_setup -dynamic "$@" || make_setup "$@" || die "compiling ${setupmodule} failed"
        else
                make_setup "$@" || die "compiling ${setupmodule} failed"
        fi
}

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() {
        set -- hscolour "$@"
        echo ./setup "$@"
        ./setup "$@" || die "setup hscolour failed"
}

cabal-haddock() {
        set -- haddock "$@"
        echo ./setup "$@"
        ./setup "$@" || die "setup haddock failed"
}

cabal-hscolour-haddock() {
        # --hyperlink-source implies calling 'setup hscolour'
        set -- haddock --hyperlink-source
        echo ./setup "$@"
        ./setup "$@" --hyperlink-source || die "setup haddock --hyperlink-source 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

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

        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.

        # We build shared version of our Cabal where ghc ships it's shared
        # version of it. We will link ./setup as dynamic binary againt Cabal later.
        [[ ${CATEGORY}/${PN} == "dev-haskell/cabal" ]] && \
                $(ghc-supports-shared-libraries) && \
                        cabalconf="${cabalconf} --enable-shared"

        set -- 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} \
                ${CABAL_EXTRA_CONFIGURE_FLAGS} \
                "$@"
        echo ./setup "$@"
        ./setup "$@" || die "setup configure failed"
}

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

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

        set -- copy --destdir="${D}" "$@"
        echo ./setup "$@"
        ./setup "$@" || 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

                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() {
        # it's a common mistake when one bumps ebuild to EAPI="2" (and upper)
        # and forgets to separate src_compile() to src_configure()/src_compile().
        # Such error leads to default src_configure and we lose all passed flags.
        if ! has "${EAPI:-0}" 0 1; then
                local passed_flag
                for passed_flag in "$@"; do
                        [[ ${passed_flag} == --flags=* ]] && \
                                eqawarn "Cabal option '${passed_flag}' has effect only in src_configure()"
                done
        fi

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