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.32 2012/04/19 17:33:19 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).
#   test-suite --  add support for cabal test-suites (introduced in Cabal-1.8)

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: CABAL_EXTRA_BUILD_FLAGS
# @DESCRIPTION:
# User-specified additional parameters passed to 'setup build'.
# example: /etc/make.conf: CABAL_EXTRA_BUILD_FLAGS=-v
: ${CABAL_EXTRA_BUILD_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;;
                test-suite) CABAL_TEST_SUITE=yes;;
                *) CABAL_UNKNOWN="${CABAL_UNKNOWN} ${feature}";;
        esac
done

if [[ -n "${CABAL_USE_HADDOCK}" ]]; then
        IUSE="${IUSE} doc"
        # don't require depend on itself to build docs.
        # ebuild bootstraps docs from just built binary
        [[ ${CATEGORY}/${PN} = "dev-haskell/haddock" ]] || 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

if [[ -n "${CABAL_TEST_SUITE}" ]]; then
        IUSE="${IUSE} test"
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"
        elif [[ -f "${S}/Setup.hs" ]]; then
                setupmodule="${S}/Setup.hs"
        else
                die "No Setup.lhs or Setup.hs found"
        fi

        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 haskell-updater or re-build dev-haskell/cabal."
                die "cabal is not correctly installed"
        fi

        # We build the setup program using the latest version of
        # cabal that we have installed
        cabalpackage=Cabal-$(cabal-version)
        einfo "Using cabal-$(cabal-version)."

        make_setup() {
                set -- -package "${cabalpackage}" --make "${setupmodule}" \
                        ${GHC_BOOTSTRAP_FLAGS} \
                        "$@" \
                        -o setup
                echo $(ghc-getghc) ${HCFLAGS} "$@"
                $(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
                # Disabled '-dynamic' as ghc does not embed RPATH to used extra-libraries:
                # bug #411789, http://hackage.haskell.org/trac/ghc/ticket/5743#comment:3
                # 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 || die "failed to create default 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
        if [[ -n "${CABAL_TEST_SUITE}" ]]; then
                cabalconf="${cabalconf} $(use_enable test tests)"
        fi

        local option
        for option in ${HCFLAGS}
        do
                cabalconf+=" --ghc-option=$option"
        done

        # 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

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

        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"

        # 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 ${CABAL_EXTRA_BUILD_FLAGS} "$@"
        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
}

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

        if [[ -n ${CABAL_HAS_LIBRARIES} ]]; 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
        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() {
        if [[ -z "${CABAL_HAS_BINARIES}" ]] && [[ -z "${CABAL_HAS_LIBRARIES}" ]]; then
                eqawarn "QA Notice: Neither bin nor lib are in CABAL_FEATURES."
        fi
        if [[ -n "${CABAL_UNKNOWN}" ]]; then
                eqawarn "QA Notice: 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() {
        cabal-is-dummy-lib && return

        pushd "${S}" > /dev/null

        cabal-bootstrap

        cabal-configure "$@"

        popd > /dev/null
}

# 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 "QA Notice: Cabal option '${passed_flag}' has effect only in src_configure()"
                done
        fi

        cabal-is-dummy-lib && return

        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
}

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
                cabal-copy
                cabal-pkg
        fi

        # create a dummy local package conf file for haskell-updater
        # if it does not exist (dummy libraries and binaries w/o libraries)
        local ghc_confdir_with_prefix="$(ghc-confdir)"
        # remove EPREFIX
        dodir ${ghc_confdir_with_prefix#${EPREFIX}}
        local conf_file="${D}/$(ghc-confdir)/$(ghc-localpkgconf)"
        [[ -e $conf_file ]] || echo '[]' > "$conf_file" || die

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