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.26 2008/01/06 19:30:24 swegener 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 version_is_at_least "6.10" "$(ghc-version)"; then
                # the ghc-pkg executable changed name in ghc 6.10, as it no longer needs
                # the wrapper script with the static flags
                echo '[]' > "${T}/empty.conf"
                echo "$(ghc-libdir)/ghc-pkg" "--global-conf=${T}/empty.conf"
        elif 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() {
        local describe_flag
        if version_is_at_least "6.4" "$(ghc-version)"; then
                describe_flag="describe"
        else
                describe_flag="--show-package"
        fi

        $(ghc-getghcpkg) "${describe_flag}" "$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}"
        local update_flag
        if version_is_at_least "6.4" "$(ghc-version)"; then
                update_flag="update -"
        else
                update_flag="--update-package"
        fi
        for pkg in $*; do
                $(ghc-getghcpkgbin) -f "${localpkgconf}" ${update_flag} --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"
        local update_flag
        local describe_flag
        if version_is_at_least "6.4" "$(ghc-version)"; then
                update_flag="update -"
                describe_flag="describe"
        else
                update_flag="--update-package"
                describe_flag="--show-package"
        fi
        if [[ -f "${localpkgconf}" ]]; then
                for pkg in $(ghc-listpkg "${localpkgconf}"); do
                        ebegin "Registering ${pkg} "
                        $(ghc-getghcpkgbin) -f "${localpkgconf}" "${describe_flag}" "${pkg}" \
                                | $(ghc-getghcpkg) ${update_flag} --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) ..."
        PATH="/usr/bin:${PATH}" CONFDIR="$(ghc-confdir)"
        if [ -d "${CONFDIR}" ]; then
                pushd "${CONFDIR}" > /dev/null
                for conf in *.conf; do
                        PATH="/usr/bin:${PATH}" 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
        local unregister_flag
        localpkgconf="$(ghc-confdir)/$1"

        if version_is_at_least "6.4" "$(ghc-version)"; then
                unregister_flag="unregister"
        else
                unregister_flag="--remove-package"
        fi

        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) "${unregister_flag}" "${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.26 2008/01/06 19:30:24 swegener 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 version_is_at_least "6.10" "$(ghc-version)"; then
35	# the ghc-pkg executable changed name in ghc 6.10, as it no longer needs
36	# the wrapper script with the static flags
37	echo '[]' > "${T}/empty.conf"
38	echo "$(ghc-libdir)/ghc-pkg" "--global-conf=${T}/empty.conf"
39	elif ghc-cabal; then
40	echo '[]' > "${T}/empty.conf"
41	echo "$(ghc-libdir)/ghc-pkg.bin" "--global-conf=${T}/empty.conf"
42	else
43	echo "$(ghc-libdir)/ghc-pkg.bin"
44	fi
45	}
46
47	# returns the version of ghc
48	_GHC_VERSION_CACHE=""
49	ghc-version() {
50	if [[ -z "${_GHC_VERSION_CACHE}" ]]; then
51	_GHC_VERSION_CACHE="$($(ghc-getghc) --numeric-version)"
52	fi
53	echo "${_GHC_VERSION_CACHE}"
54	}
55
56	# this function can be used to determine if ghc itself
57	# uses the Cabal package format; it has nothing to do
58	# with the Cabal libraries ... ghc uses the Cabal package
59	# format since version 6.4
60	ghc-cabal() {
61	version_is_at_least "6.4" "$(ghc-version)"
62	}
63
64	# return the best version of the Cabal library that is available
65	ghc-bestcabalversion() {
66	local cabalversion
67	if ghc-cabal; then
68	# We ask portage, not ghc, so that we only pick up
69	# portage-installed cabal versions.
70	cabalversion="$(ghc-extractportageversion dev-haskell/cabal)"
71	echo "Cabal-${cabalversion}"
72	else
73	# older ghc's don't support package versioning
74	echo Cabal
75	fi
76	}
77
78	# check if a standalone Cabal version is available for the
79	# currently used ghc; takes minimal version of Cabal as
80	# an optional argument
81	ghc-sanecabal() {
82	local f
83	local version
84	if [[ -z "$1" ]]; then version="1.0.1"; else version="$1"; fi
85	for f in $(ghc-confdir)/cabal-*; do
86	[[ -f "${f}" ]] && version_is_at_least "${version}" "${f#*cabal-}" && return
87	done
88	return 1
89	}
90
91	# checks if ghc and ghc-bin are installed in the same version
92	# (if they're both installed); if this is not the case, we
93	# unfortunately cannot trust portage's dependency resolution
94	ghc-saneghc() {
95	local ghcversion
96	local ghcbinversion
97	if [[ "${PN}" == "ghc" \|\| "${PN}" == "ghc-bin" ]]; then
98	return
99	fi
100	if has_version dev-lang/ghc && has_version dev-lang/ghc-bin; then
101	ghcversion="$(ghc-extractportageversion dev-lang/ghc)"
102	ghcbinversion="$(ghc-extractportageversion dev-lang/ghc-bin)"
103	if [[ "${ghcversion}" != "${ghcbinversion}" ]]; then
104	return 1
105	fi
106	fi
107	return
108	}
109
110	# extract the version of a portage-installed package
111	ghc-extractportageversion() {
112	local pkg
113	local version
114	pkg="$(best_version $1)"
115	version="${pkg#$1-}"
116	version="${version%-r*}"
117	version="${version%_pre*}"
118	echo "${version}"
119	}
120
121	# returns the library directory
122	_GHC_LIBDIR_CACHE=""
123	ghc-libdir() {
124	if [[ -z "${_GHC_LIBDIR_CACHE}" ]]; then
125	_GHC_LIBDIR_CACHE="$($(ghc-getghc) --print-libdir)"
126	fi
127	echo "${_GHC_LIBDIR_CACHE}"
128	}
129
130	# returns the (Gentoo) library configuration directory
131	ghc-confdir() {
132	echo "$(ghc-libdir)/gentoo"
133	}
134
135	# returns the name of the local (package-specific)
136	# package configuration file
137	ghc-localpkgconf() {
138	echo "${PF}.conf"
139	}
140
141	# make a ghci foo.o file from a libfoo.a file
142	ghc-makeghcilib() {
143	local outfile
144	outfile="$(dirname $1)/$(basename $1 \| sed 's:^lib\?\(.*\)\.a$:\1.o:')"
145	ld --relocatable --discard-all --output="${outfile}" --whole-archive "$1"
146	}
147
148	# tests if a ghc package exists
149	ghc-package-exists() {
150	local describe_flag
151	if version_is_at_least "6.4" "$(ghc-version)"; then
152	describe_flag="describe"
153	else
154	describe_flag="--show-package"
155	fi
156
157	$(ghc-getghcpkg) "${describe_flag}" "$1" > /dev/null 2>&1
158	}
159
160	# creates a local (package-specific) package
161	# configuration file; the arguments should be
162	# uninstalled package description files, each
163	# containing a single package description; if
164	# no arguments are given, the resulting file is
165	# empty
166	ghc-setup-pkg() {
167	local localpkgconf
168	localpkgconf="${S}/$(ghc-localpkgconf)"
169	echo '[]' > "${localpkgconf}"
170	local update_flag
171	if version_is_at_least "6.4" "$(ghc-version)"; then
172	update_flag="update -"
173	else
174	update_flag="--update-package"
175	fi
176	for pkg in $*; do
177	$(ghc-getghcpkgbin) -f "${localpkgconf}" ${update_flag} --force \
178	< "${pkg}" \|\| die "failed to register ${pkg}"
179	done
180	}
181
182	# fixes the library and import directories path
183	# of the package configuration file
184	ghc-fixlibpath() {
185	sed -i "s\|$1\|$(ghc-libdir)\|g" "${S}/$(ghc-localpkgconf)"
186	if [[ -n "$2" ]]; then
187	sed -i "s\|$2\|$(ghc-libdir)/imports\|g" "${S}/$(ghc-localpkgconf)"
188	fi
189	}
190
191	# moves the local (package-specific) package configuration
192	# file to its final destination
193	ghc-install-pkg() {
194	mkdir -p "${D}/$(ghc-confdir)"
195	cat "${S}/$(ghc-localpkgconf)" \| sed "s\|${D}\|\|g" \
196	> "${D}/$(ghc-confdir)/$(ghc-localpkgconf)"
197	}
198
199	# registers all packages in the local (package-specific)
200	# package configuration file
201	ghc-register-pkg() {
202	local localpkgconf
203	localpkgconf="$(ghc-confdir)/$1"
204	local update_flag
205	local describe_flag
206	if version_is_at_least "6.4" "$(ghc-version)"; then
207	update_flag="update -"
208	describe_flag="describe"
209	else
210	update_flag="--update-package"
211	describe_flag="--show-package"
212	fi
213	if [[ -f "${localpkgconf}" ]]; then
214	for pkg in $(ghc-listpkg "${localpkgconf}"); do
215	ebegin "Registering ${pkg} "
216	$(ghc-getghcpkgbin) -f "${localpkgconf}" "${describe_flag}" "${pkg}" \
217	\| $(ghc-getghcpkg) ${update_flag} --force > /dev/null
218	eend $?
219	done
220	fi
221	}
222
223	# re-adds all available .conf files to the global
224	# package conf file, to be used on a ghc reinstallation
225	ghc-reregister() {
226	einfo "Re-adding packages (may cause several harmless warnings) ..."
227	PATH="/usr/bin:${PATH}" CONFDIR="$(ghc-confdir)"
228	if [ -d "${CONFDIR}" ]; then
229	pushd "${CONFDIR}" > /dev/null
230	for conf in *.conf; do
231	PATH="/usr/bin:${PATH}" ghc-register-pkg "${conf}"
232	done
233	popd > /dev/null
234	fi
235	}
236
237	# unregisters a package configuration file
238	# protected are all packages that are still contained in
239	# another package configuration file
240	ghc-unregister-pkg() {
241	local localpkgconf
242	local i
243	local pkg
244	local protected
245	local unregister_flag
246	localpkgconf="$(ghc-confdir)/$1"
247
248	if version_is_at_least "6.4" "$(ghc-version)"; then
249	unregister_flag="unregister"
250	else
251	unregister_flag="--remove-package"
252	fi
253
254	for i in $(ghc-confdir)/*.conf; do
255	[[ "${i}" != "${localpkgconf}" ]] && protected="${protected} $(ghc-listpkg ${i})"
256	done
257	# protected now contains the packages that cannot be unregistered yet
258
259	if [[ -f "${localpkgconf}" ]]; then
260	for pkg in $(ghc-reverse "$(ghc-listpkg ${localpkgconf})"); do
261	if $(ghc-elem "${pkg}" "${protected}"); then
262	einfo "Package ${pkg} is protected."
263	elif ! ghc-package-exists "${pkg}"; then
264	:
265	# einfo "Package ${pkg} is not installed for ghc-$(ghc-version)."
266	else
267	ebegin "Unregistering ${pkg} "
268	$(ghc-getghcpkg) "${unregister_flag}" "${pkg}" --force > /dev/null
269	eend $?
270	fi
271	done
272	fi
273	}
274
275	# help-function: reverse a list
276	ghc-reverse() {
277	local result
278	local i
279	for i in $1; do
280	result="${i} ${result}"
281	done
282	echo "${result}"
283	}
284
285	# help-function: element-check
286	ghc-elem() {
287	local i
288	for i in $2; do
289	[[ "$1" == "${i}" ]] && return 0
290	done
291	return 1
292	}
293
294	# show the packages in a package configuration file
295	ghc-listpkg() {
296	local ghcpkgcall
297	local i
298	for i in $*; do
299	if ghc-cabal; then
300	echo $($(ghc-getghcpkg) list -f "${i}") \
301	\| sed \
302	-e "s\|^.${i}:\([^:]\).*$\|\1\|" \
303	-e "s\|/.*$\|\|" \
304	-e "s\|,\| \|g" -e "s\|[(){}]\|\|g"
305	else
306	echo $($(ghc-getghcpkgbin) -l -f "${i}") \
307	\| cut -f2 -d':' \
308	\| sed 's:,: :g'
309	fi
310	done
311	}
312
313	# exported function: check if we have a consistent ghc installation
314	ghc-package_pkg_setup() {
315	if ! ghc-saneghc; then
316	eerror "You have inconsistent versions of dev-lang/ghc and dev-lang/ghc-bin"
317	eerror "installed. Portage currently cannot work correctly with this setup."
318	eerror "There are several possibilities to work around this problem:"
319	eerror "(1) Up/downgrade ghc-bin to the same version as ghc."
320	eerror "(2) Unmerge ghc-bin."
321	eerror "(3) Unmerge ghc."
322	eerror "You probably want option 1 or 2."
323	die "Inconsistent versions of ghc and ghc-bin."
324	fi
325	}
326
327	# exported function: registers the package-specific package
328	# configuration file
329	ghc-package_pkg_postinst() {
330	ghc-register-pkg "$(ghc-localpkgconf)"
331	}
332
333	# exported function: unregisters the package-specific package
334	# configuration file; a package contained therein is unregistered
335	# only if it the same package is not also contained in another
336	# package configuration file ...
337	ghc-package_pkg_prerm() {
338	ghc-unregister-pkg "$(ghc-localpkgconf)"
339	}
340
341	EXPORT_FUNCTIONS pkg_setup pkg_postinst pkg_prerm