gentoo-x86/eclass/ghc-package.eclass

# Copyright 1999-2004 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/eclass/ghc-package.eclass,v 1.9 2005/04/08 01:13:39 araujo Exp $
#
# Author: Andres Loeh <kosmikus@gentoo.org>
# Maintained by: Haskell herd <haskell@gentoo.org>
#
# This eclass helps with the Glasgow Haskell Compiler's package
# configuration utility.

inherit versionator

# promote /opt/ghc/bin to a better position in the search path
PATH="/usr/bin:/opt/ghc/bin:${PATH}"

# for later configuration using environment variables/
# returns the name of the ghc executable
ghc-getghc() {
        type -P ghc
}

# returns the name of the ghc-pkg executable
ghc-getghcpkg() {
        type -P ghc-pkg
}

# returns the name of the ghc-pkg binary (ghc-pkg
# itself usually is a shell script, and we have to
# bypass the script under certain circumstances);
# for Cabal, we add an empty global package config file,
# because for some reason the global package file
# must be specified
ghc-getghcpkgbin() {
        if ghc-cabal; then
                echo '[]' > "${T}/empty.conf"
                echo "$(ghc-libdir)/ghc-pkg.bin" "--global-conf=${T}/empty.conf"
        else
                echo "$(ghc-libdir)/ghc-pkg.bin"
        fi
}

# returns the version of ghc
_GHC_VERSION_CACHE=""
ghc-version() {
        if [[ -z "${_GHC_VERSION_CACHE}" ]]; then
                _GHC_VERSION_CACHE="$($(ghc-getghc) --numeric-version)"
        fi
        echo "${_GHC_VERSION_CACHE}"
}

# this function can be used to determine if ghc itself
# uses the Cabal package format; it has nothing to do
# with the Cabal libraries ... ghc uses the Cabal package
# format since version 6.4
ghc-cabal() {
        version_is_at_least "6.4" "$(ghc-version)"
}

# return the best version of the Cabal library that is available
ghc-bestcabalversion() {
        local cabalversion
        if ghc-cabal; then
                # We ask portage, not ghc, so that we only pick up
                # portage-installed cabal versions.
                cabalversion="$(ghc-extractportageversion dev-haskell/cabal)"
                echo "Cabal-${cabalversion}"
        else
                # older ghc's don't support package versioning
                echo Cabal
        fi
}

# check if a standalone Cabal version is available for the
# currently used ghc; takes minimal version of Cabal as
# an optional argument
ghc-sanecabal() {
        local f
        local version
        if [[ -z "$1" ]]; then version="1.0.1"; else version="$1"; fi
        for f in $(ghc-confdir)/cabal-*; do
                [[ -f "${f}" ]] && version_is_at_least "${version}" "${f#*cabal-}" && return
        done
        return 1
}

# checks if ghc and ghc-bin are installed in the same version
# (if they're both installed); if this is not the case, we 
# unfortunately cannot trust portage's dependency resolution
ghc-saneghc() {
        local ghcversion
        local ghcbinversion
        if [[ "${PN}" == "ghc" || "${PN}" == "ghc-bin" ]]; then
                return
        fi
        if has_version dev-lang/ghc && has_version dev-lang/ghc-bin; then
                ghcversion="$(ghc-extractportageversion dev-lang/ghc)"
                ghcbinversion="$(ghc-extractportageversion dev-lang/ghc-bin)"
                if [[ "${ghcversion}" != "${ghcbinversion}" ]]; then
                        return 1
                fi
        fi
        return
}

# extract the version of a portage-installed package
ghc-extractportageversion() {
        local pkg
        local version
        pkg="$(best_version $1)"
        version="${pkg#$1-}"
        version="${version%-r*}"
        version="${version%_pre*}"
        echo "${version}"
}

# returns the library directory
_GHC_LIBDIR_CACHE=""
ghc-libdir() {
        if [[ -z "${_GHC_LIBDIR_CACHE}" ]]; then
                _GHC_LIBDIR_CACHE="$($(ghc-getghc) --print-libdir)"
        fi
        echo "${_GHC_LIBDIR_CACHE}"
}

# returns the (Gentoo) library configuration directory
ghc-confdir() {
        echo "$(ghc-libdir)/gentoo"
}

# returns the name of the local (package-specific)
# package configuration file
ghc-localpkgconf() {
        echo "${PF}.conf"
}

# make a ghci foo.o file from a libfoo.a file
ghc-makeghcilib() {
        local outfile
        outfile="$(dirname $1)/$(basename $1 | sed 's:^lib\?\(.*\)\.a$:\1.o:')"
        ld --relocatable --discard-all --output="${outfile}" --whole-archive "$1"
}

# tests if a ghc package exists
ghc-package-exists() {
        $(ghc-getghcpkg) -s "$1" > /dev/null 2>&1
}

# creates a local (package-specific) package
# configuration file; the arguments should be
# uninstalled package description files, each
# containing a single package description; if
# no arguments are given, the resulting file is
# empty
ghc-setup-pkg() {
        local localpkgconf
        localpkgconf="${S}/$(ghc-localpkgconf)"
        echo '[]' > "${localpkgconf}"
        for pkg in $*; do
                $(ghc-getghcpkgbin) -f "${localpkgconf}" -u --force \
                        < "${pkg}" || die "failed to register ${pkg}"
        done
}

# fixes the library and import directories path
# of the package configuration file
ghc-fixlibpath() {
        sed -i "s|$1|$(ghc-libdir)|g" "${S}/$(ghc-localpkgconf)"
        if [[ -n "$2" ]]; then
                sed -i "s|$2|$(ghc-libdir)/imports|g" "${S}/$(ghc-localpkgconf)"
        fi
}

# moves the local (package-specific) package configuration
# file to its final destination
ghc-install-pkg() {
        mkdir -p "${D}/$(ghc-confdir)"
        cat "${S}/$(ghc-localpkgconf)" | sed "s|${D}||g" \
                > "${D}/$(ghc-confdir)/$(ghc-localpkgconf)"
}

# registers all packages in the local (package-specific)
# package configuration file
ghc-register-pkg() {
        local localpkgconf
        localpkgconf="$(ghc-confdir)/$1"
        if [[ -f "${localpkgconf}" ]]; then
                for pkg in $(ghc-listpkg "${localpkgconf}"); do
                        ebegin "Registering ${pkg} "
                        $(ghc-getghcpkgbin) -f "${localpkgconf}" -s "${pkg}" \
                                | $(ghc-getghcpkg) -u --force > /dev/null
                        eend $?
                done
        fi
}

# re-adds all available .conf files to the global
# package conf file, to be used on a ghc reinstallation
ghc-reregister() {
        einfo "Re-adding packages (may cause several harmless warnings) ..."
        if [ -d "$(ghc-confdir)" ]; then
                pushd "$(ghc-confdir)" > /dev/null
                for conf in *.conf; do
#                       einfo "Processing ${conf} ..."
                        ghc-register-pkg "${conf}"
                done
                popd > /dev/null
        fi
}

# unregisters a package configuration file
# protected are all packages that are still contained in
# another package configuration file
ghc-unregister-pkg() {
        local localpkgconf
        local i
        local pkg
        local protected
        localpkgconf="$(ghc-confdir)/$1"

        for i in $(ghc-confdir)/*.conf; do
                [[ "${i}" != "${localpkgconf}" ]] && protected="${protected} $(ghc-listpkg ${i})"
        done
        # protected now contains the packages that cannot be unregistered yet

        if [[ -f "${localpkgconf}" ]]; then
                for pkg in $(ghc-reverse "$(ghc-listpkg ${localpkgconf})"); do
                        if $(ghc-elem "${pkg}" "${protected}"); then
                                einfo "Package ${pkg} is protected."
                        elif ! ghc-package-exists "${pkg}"; then
                                :
                                # einfo "Package ${pkg} is not installed for ghc-$(ghc-version)."
                        else
                                ebegin "Unregistering ${pkg} "
                                $(ghc-getghcpkg) -r "${pkg}" --force > /dev/null
                                eend $?
                        fi
                done
        fi
}

# help-function: reverse a list
ghc-reverse() {
        local result
        local i
        for i in $1; do
                result="${i} ${result}"
        done
        echo "${result}"
}

# help-function: element-check
ghc-elem() {
        local i
        for i in $2; do
                [[ "$1" == "${i}" ]] && return 0
        done
        return 1
}

# show the packages in a package configuration file
ghc-listpkg() {
        local ghcpkgcall
        local i
        for i in $*; do
                if ghc-cabal; then
                        echo $($(ghc-getghcpkg) list -f "${i}") \
                                | sed \
                                        -e "s|^.*${i}:\([^:]*\).*$|\1|" \
                                        -e "s|/.*$||" \
                                        -e "s|,| |g" -e "s|[()]||g"
                else
                        echo $($(ghc-getghcpkgbin) -l -f "${i}") \
                                | cut -f2 -d':' \
                                | sed 's:,: :g'
                fi
        done
}

# exported function: check if we have a consistent ghc installation
ghc-package_pkg_setup() {
        if ! ghc-saneghc; then
                eerror "You have inconsistent versions of dev-lang/ghc and dev-lang/ghc-bin"
                eerror "installed. Portage currently cannot work correctly with this setup."
                eerror "There are several possibilities to work around this problem:"
                eerror "(1) Up/downgrade ghc-bin to the same version as ghc."
                eerror "(2) Unmerge ghc-bin."
                eerror "(3) Unmerge ghc."
                eerror "You probably want option 1 or 2."
                die "Inconsistent versions of ghc and ghc-bin."
        fi
}

# exported function: registers the package-specific package
# configuration file
ghc-package_pkg_postinst() {
        ghc-register-pkg "$(ghc-localpkgconf)"
}

# exported function: unregisters the package-specific package
# configuration file; a package contained therein is unregistered
# only if it the same package is not also contained in another
# package configuration file ...
ghc-package_pkg_prerm() {
        ghc-unregister-pkg "$(ghc-localpkgconf)"
}

EXPORT_FUNCTIONS pkg_setup pkg_postinst pkg_prerm
1	# Copyright 1999-2004 Gentoo Foundation
2	# Distributed under the terms of the GNU General Public License v2
3	# $Header: /var/cvsroot/gentoo-x86/eclass/ghc-package.eclass,v 1.9 2005/04/08 01:13:39 araujo Exp $
4	#
5	# Author: Andres Loeh <kosmikus@gentoo.org>
6	# Maintained by: Haskell herd <haskell@gentoo.org>
7	#
8	# This eclass helps with the Glasgow Haskell Compiler's package
9	# configuration utility.
10
11	inherit versionator
12
13	# promote /opt/ghc/bin to a better position in the search path
14	PATH="/usr/bin:/opt/ghc/bin:${PATH}"
15
16	# for later configuration using environment variables/
17	# returns the name of the ghc executable
18	ghc-getghc() {
19	type -P ghc
20	}
21
22	# returns the name of the ghc-pkg executable
23	ghc-getghcpkg() {
24	type -P ghc-pkg
25	}
26
27	# returns the name of the ghc-pkg binary (ghc-pkg
28	# itself usually is a shell script, and we have to
29	# bypass the script under certain circumstances);
30	# for Cabal, we add an empty global package config file,
31	# because for some reason the global package file
32	# must be specified
33	ghc-getghcpkgbin() {
34	if ghc-cabal; then
35	echo '[]' > "${T}/empty.conf"
36	echo "$(ghc-libdir)/ghc-pkg.bin" "--global-conf=${T}/empty.conf"
37	else
38	echo "$(ghc-libdir)/ghc-pkg.bin"
39	fi
40	}
41
42	# returns the version of ghc
43	_GHC_VERSION_CACHE=""
44	ghc-version() {
45	if [[ -z "${_GHC_VERSION_CACHE}" ]]; then
46	_GHC_VERSION_CACHE="$($(ghc-getghc) --numeric-version)"
47	fi
48	echo "${_GHC_VERSION_CACHE}"
49	}
50
51	# this function can be used to determine if ghc itself
52	# uses the Cabal package format; it has nothing to do
53	# with the Cabal libraries ... ghc uses the Cabal package
54	# format since version 6.4
55	ghc-cabal() {
56	version_is_at_least "6.4" "$(ghc-version)"
57	}
58
59	# return the best version of the Cabal library that is available
60	ghc-bestcabalversion() {
61	local cabalversion
62	if ghc-cabal; then
63	# We ask portage, not ghc, so that we only pick up
64	# portage-installed cabal versions.
65	cabalversion="$(ghc-extractportageversion dev-haskell/cabal)"
66	echo "Cabal-${cabalversion}"
67	else
68	# older ghc's don't support package versioning
69	echo Cabal
70	fi
71	}
72
73	# check if a standalone Cabal version is available for the
74	# currently used ghc; takes minimal version of Cabal as
75	# an optional argument
76	ghc-sanecabal() {
77	local f
78	local version
79	if [[ -z "$1" ]]; then version="1.0.1"; else version="$1"; fi
80	for f in $(ghc-confdir)/cabal-*; do
81	[[ -f "${f}" ]] && version_is_at_least "${version}" "${f#*cabal-}" && return
82	done
83	return 1
84	}
85
86	# checks if ghc and ghc-bin are installed in the same version
87	# (if they're both installed); if this is not the case, we
88	# unfortunately cannot trust portage's dependency resolution
89	ghc-saneghc() {
90	local ghcversion
91	local ghcbinversion
92	if [[ "${PN}" == "ghc" \|\| "${PN}" == "ghc-bin" ]]; then
93	return
94	fi
95	if has_version dev-lang/ghc && has_version dev-lang/ghc-bin; then
96	ghcversion="$(ghc-extractportageversion dev-lang/ghc)"
97	ghcbinversion="$(ghc-extractportageversion dev-lang/ghc-bin)"
98	if [[ "${ghcversion}" != "${ghcbinversion}" ]]; then
99	return 1
100	fi
101	fi
102	return
103	}
104
105	# extract the version of a portage-installed package
106	ghc-extractportageversion() {
107	local pkg
108	local version
109	pkg="$(best_version $1)"
110	version="${pkg#$1-}"
111	version="${version%-r*}"
112	version="${version%_pre*}"
113	echo "${version}"
114	}
115
116	# returns the library directory
117	_GHC_LIBDIR_CACHE=""
118	ghc-libdir() {
119	if [[ -z "${_GHC_LIBDIR_CACHE}" ]]; then
120	_GHC_LIBDIR_CACHE="$($(ghc-getghc) --print-libdir)"
121	fi
122	echo "${_GHC_LIBDIR_CACHE}"
123	}
124
125	# returns the (Gentoo) library configuration directory
126	ghc-confdir() {
127	echo "$(ghc-libdir)/gentoo"
128	}
129
130	# returns the name of the local (package-specific)
131	# package configuration file
132	ghc-localpkgconf() {
133	echo "${PF}.conf"
134	}
135
136	# make a ghci foo.o file from a libfoo.a file
137	ghc-makeghcilib() {
138	local outfile
139	outfile="$(dirname $1)/$(basename $1 \| sed 's:^lib\?\(.*\)\.a$:\1.o:')"
140	ld --relocatable --discard-all --output="${outfile}" --whole-archive "$1"
141	}
142
143	# tests if a ghc package exists
144	ghc-package-exists() {
145	$(ghc-getghcpkg) -s "$1" > /dev/null 2>&1
146	}
147
148	# creates a local (package-specific) package
149	# configuration file; the arguments should be
150	# uninstalled package description files, each
151	# containing a single package description; if
152	# no arguments are given, the resulting file is
153	# empty
154	ghc-setup-pkg() {
155	local localpkgconf
156	localpkgconf="${S}/$(ghc-localpkgconf)"
157	echo '[]' > "${localpkgconf}"
158	for pkg in $*; do
159	$(ghc-getghcpkgbin) -f "${localpkgconf}" -u --force \
160	< "${pkg}" \|\| die "failed to register ${pkg}"
161	done
162	}
163
164	# fixes the library and import directories path
165	# of the package configuration file
166	ghc-fixlibpath() {
167	sed -i "s\|$1\|$(ghc-libdir)\|g" "${S}/$(ghc-localpkgconf)"
168	if [[ -n "$2" ]]; then
169	sed -i "s\|$2\|$(ghc-libdir)/imports\|g" "${S}/$(ghc-localpkgconf)"
170	fi
171	}
172
173	# moves the local (package-specific) package configuration
174	# file to its final destination
175	ghc-install-pkg() {
176	mkdir -p "${D}/$(ghc-confdir)"
177	cat "${S}/$(ghc-localpkgconf)" \| sed "s\|${D}\|\|g" \
178	> "${D}/$(ghc-confdir)/$(ghc-localpkgconf)"
179	}
180
181	# registers all packages in the local (package-specific)
182	# package configuration file
183	ghc-register-pkg() {
184	local localpkgconf
185	localpkgconf="$(ghc-confdir)/$1"
186	if [[ -f "${localpkgconf}" ]]; then
187	for pkg in $(ghc-listpkg "${localpkgconf}"); do
188	ebegin "Registering ${pkg} "
189	$(ghc-getghcpkgbin) -f "${localpkgconf}" -s "${pkg}" \
190	\| $(ghc-getghcpkg) -u --force > /dev/null
191	eend $?
192	done
193	fi
194	}
195
196	# re-adds all available .conf files to the global
197	# package conf file, to be used on a ghc reinstallation
198	ghc-reregister() {
199	einfo "Re-adding packages (may cause several harmless warnings) ..."
200	if [ -d "$(ghc-confdir)" ]; then
201	pushd "$(ghc-confdir)" > /dev/null
202	for conf in *.conf; do
203	# einfo "Processing ${conf} ..."
204	ghc-register-pkg "${conf}"
205	done
206	popd > /dev/null
207	fi
208	}
209
210	# unregisters a package configuration file
211	# protected are all packages that are still contained in
212	# another package configuration file
213	ghc-unregister-pkg() {
214	local localpkgconf
215	local i
216	local pkg
217	local protected
218	localpkgconf="$(ghc-confdir)/$1"
219
220	for i in $(ghc-confdir)/*.conf; do
221	[[ "${i}" != "${localpkgconf}" ]] && protected="${protected} $(ghc-listpkg ${i})"
222	done
223	# protected now contains the packages that cannot be unregistered yet
224
225	if [[ -f "${localpkgconf}" ]]; then
226	for pkg in $(ghc-reverse "$(ghc-listpkg ${localpkgconf})"); do
227	if $(ghc-elem "${pkg}" "${protected}"); then
228	einfo "Package ${pkg} is protected."
229	elif ! ghc-package-exists "${pkg}"; then
230	:
231	# einfo "Package ${pkg} is not installed for ghc-$(ghc-version)."
232	else
233	ebegin "Unregistering ${pkg} "
234	$(ghc-getghcpkg) -r "${pkg}" --force > /dev/null
235	eend $?
236	fi
237	done
238	fi
239	}
240
241	# help-function: reverse a list
242	ghc-reverse() {
243	local result
244	local i
245	for i in $1; do
246	result="${i} ${result}"
247	done
248	echo "${result}"
249	}
250
251	# help-function: element-check
252	ghc-elem() {
253	local i
254	for i in $2; do
255	[[ "$1" == "${i}" ]] && return 0
256	done
257	return 1
258	}
259
260	# show the packages in a package configuration file
261	ghc-listpkg() {
262	local ghcpkgcall
263	local i
264	for i in $*; do
265	if ghc-cabal; then
266	echo $($(ghc-getghcpkg) list -f "${i}") \
267	\| sed \
268	-e "s\|^.${i}:\([^:]\).*$\|\1\|" \
269	-e "s\|/.*$\|\|" \
270	-e "s\|,\| \|g" -e "s\|[()]\|\|g"
271	else
272	echo $($(ghc-getghcpkgbin) -l -f "${i}") \
273	\| cut -f2 -d':' \
274	\| sed 's:,: :g'
275	fi
276	done
277	}
278
279	# exported function: check if we have a consistent ghc installation
280	ghc-package_pkg_setup() {
281	if ! ghc-saneghc; then
282	eerror "You have inconsistent versions of dev-lang/ghc and dev-lang/ghc-bin"
283	eerror "installed. Portage currently cannot work correctly with this setup."
284	eerror "There are several possibilities to work around this problem:"
285	eerror "(1) Up/downgrade ghc-bin to the same version as ghc."
286	eerror "(2) Unmerge ghc-bin."
287	eerror "(3) Unmerge ghc."
288	eerror "You probably want option 1 or 2."
289	die "Inconsistent versions of ghc and ghc-bin."
290	fi
291	}
292
293	# exported function: registers the package-specific package
294	# configuration file
295	ghc-package_pkg_postinst() {
296	ghc-register-pkg "$(ghc-localpkgconf)"
297	}
298
299	# exported function: unregisters the package-specific package
300	# configuration file; a package contained therein is unregistered
301	# only if it the same package is not also contained in another
302	# package configuration file ...
303	ghc-package_pkg_prerm() {
304	ghc-unregister-pkg "$(ghc-localpkgconf)"
305	}
306
307	EXPORT_FUNCTIONS pkg_setup pkg_postinst pkg_prerm