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.24 2011/05/08 15:13:10 slyfox 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;;
                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() {
                $(ghc-getghc) -package "${cabalpackage}" --make "${setupmodule}" \
                        ${GHC_BOOTSTRAP_FLAGS} \
                        "$@" \
                        -o setup
        }
        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() {
        ./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

        # 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"

        ./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} \
                ${CABAL_EXTRA_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

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