gentoo-x86/eclass/haskell-cabal.eclass

# Copyright 1999-2006 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/eclass/haskell-cabal.eclass,v 1.17 2009/10/28 23:46:16 kolmodin Exp $
#
# Original authors: Andres Loeh <kosmikus@gentoo.org>
#                   Duncan Coutts <dcoutts@gentoo.org>
# Maintained by: Haskell herd <haskell@gentoo.org>
#
# This eclass is for packages that make use of the
# Haskell Common Architecture for Building Applications
# and Libraries (cabal).
#
# Basic instructions:
#
# Before inheriting the eclass, set CABAL_FEATURES to
# reflect the tools and features that the package makes
# use of.
#
# Currently supported features:
#   haddock    --  for documentation generation
#   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


for feature in ${CABAL_FEATURES}; do
        case ${feature} in
                haddock)    CABAL_USE_HADDOCK=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_ALEX}" ]]; then
        DEPEND="${DEPEND} dev-haskell/alex"
        cabalconf="${cabalconf} --with-alex=/usr/bin/alex"
fi

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

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

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

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

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

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

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

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

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

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

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

cabal-mksetup() {
        local setupdir

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

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

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

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

cabal-configure() {
        if [[ -n "${CABAL_USE_HADDOCK}" ]] && use doc; then
                cabalconf="${cabalconf} --with-haddock=/usr/bin/haddock"
        fi
        if [[ -n "${CABAL_USE_PROFILE}" ]] && use profile; then
                cabalconf="${cabalconf} --enable-library-profiling"
        fi
        # Building GHCi libs on ppc64 causes "TOC overflow".
        if use ppc64; then
                cabalconf="${cabalconf} --disable-library-for-ghci"
        fi

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

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

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

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

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

        # cabal is a bit eager about creating dirs,
        # so remove them if they are empty
        rmdir "${D}/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 "${D}/usr/bin" ]] ; then
                chmod +x "${D}/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
}

# exported function: cabal-style bootstrap configure and compile
cabal_src_compile() {
        if ! cabal-is-dummy-lib; then
                cabal-bootstrap
                cabal-configure
                cabal-build

                if [[ -n "${CABAL_USE_HADDOCK}" ]] && use doc; then
                        cabal-haddock
                fi
        fi
}

haskell-cabal_src_compile() {
        cabal_src_compile
}

# exported function: cabal-style copy and register
cabal_src_install() {
        if cabal-is-dummy-lib; then
                # create a dummy local package conf file for the sake of ghc-updater
                dodir "$(ghc-confdir)"
                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() {
        cabal_src_install
}

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