/[gentoo-x86]/eclass/eutils.eclass

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

Revision 1.41		Revision 1.182
1	# Copyright 1999-2003 Gentoo Technologies, Inc.	1	# Copyright 1999-2005 Gentoo Foundation
2	# Distributed under the terms of the GNU General Public License v2	2	# Distributed under the terms of the GNU General Public License v2
3	# $Header: /var/cvsroot/gentoo-x86/eclass/eutils.eclass,v 1.41 2003/07/14 04:47:17 vapier Exp $	3	# $Header: /var/cvsroot/gentoo-x86/eclass/eutils.eclass,v 1.182 2005/06/11 00:02:26 vapier Exp $
4	#	4	#
5	# Author: Martin Schlemmer <azarah@gentoo.org>	5	# Author: Martin Schlemmer <azarah@gentoo.org>
6	#	6	#
7	# This eclass is for general purpose functions that most ebuilds	7	# This eclass is for general purpose functions that most ebuilds
8	# have to implement themselves.	8	# have to implement themselves.
9	#	9	#
10	# NB: If you add anything, please comment it!	10	# NB: If you add anything, please comment it!
11		11
		12	inherit multilib
12	ECLASS=eutils	13	ECLASS=eutils
13	INHERITED="$INHERITED $ECLASS"	14	INHERITED="$INHERITED $ECLASS"
14		15
15	DEPEND="$DEPEND !bootstrap? ( sys-devel/patch )"	16	DEPEND="!bootstrap? ( sys-devel/patch userland_GNU? ( sys-apps/shadow ) )"
		17	# sys-apps/shadow is needed for useradd, etc, bug #94745.
16		18
17	DESCRIPTION="Based on the ${ECLASS} eclass"	19	DESCRIPTION="Based on the ${ECLASS} eclass"
		20
		21	# Wait for the supplied number of seconds. If no argument is supplied, defaults
		22	# to five seconds. If the EPAUSE_IGNORE env var is set, don't wait. If we're not
		23	# outputting to a terminal, don't wait. For compatability purposes, the argument
		24	# must be an integer greater than zero.
		25	# Bug 62950, Ciaran McCreesh <ciaranm@gentoo.org> (05 Sep 2004)
		26	epause() {
		27	if [ -z "$EPAUSE_IGNORE" ] && [ -t 1 ] ; then
		28	sleep ${1:-5}
		29	fi
		30	}
		31
		32	# Beep the specified number of times (defaults to five). If our output
		33	# is not a terminal, don't beep. If the EBEEP_IGNORE env var is set,
		34	# don't beep.
		35	# Bug 62950, Ciaran McCreesh <ciaranm@gentoo.org> (05 Sep 2004)
		36	ebeep() {
		37	local n
		38	if [ -z "$EBEEP_IGNORE" ] && [ -t 1 ] ; then
		39	for ((n=1 ; n <= ${1:-5} ; n++)) ; do
		40	echo -ne "\a"
		41	sleep 0.1 &>/dev/null ; sleep 0,1 &>/dev/null
		42	echo -ne "\a"
		43	sleep 1
		44	done
		45	fi
		46	}
18		47
19	# This function generate linker scripts in /usr/lib for dynamic	48	# This function generate linker scripts in /usr/lib for dynamic
20	# libs in /lib. This is to fix linking problems when you have	49	# libs in /lib. This is to fix linking problems when you have
21	# the .so in /lib, and the .a in /usr/lib. What happens is that	50	# the .so in /lib, and the .a in /usr/lib. What happens is that
22	# in some cases when linking dynamic, the .a in /usr/lib is used	51	# in some cases when linking dynamic, the .a in /usr/lib is used
…		…
33	# to point to the latest version of the library present.	62	# to point to the latest version of the library present.
34	#	63	#
35	# <azarah@gentoo.org> (26 Oct 2002)	64	# <azarah@gentoo.org> (26 Oct 2002)
36	#	65	#
37	gen_usr_ldscript() {	66	gen_usr_ldscript() {
38		67	local libdir="$(get_libdir)"
39	# Just make sure it exists	68	# Just make sure it exists
40	dodir /usr/lib	69	dodir /usr/${libdir}
41		70
		71	for lib in "${@}" ; do
42	cat > ${D}/usr/lib/$1 <<"END_LDSCRIPT"	72	cat > "${D}/usr/${libdir}/${lib}" <<-END_LDSCRIPT
43	/* GNU ld script	73	/* GNU ld script
44	Because Gentoo have critical dynamic libraries	74	Since Gentoo has critical dynamic libraries
45	in /lib, and the static versions in /usr/lib, we	75	in /lib, and the static versions in /usr/lib,
46	need to have a "fake" dynamic lib in /usr/lib,	76	we need to have a "fake" dynamic lib in /usr/lib,
47	otherwise we run into linking problems.	77	otherwise we run into linking problems.
48	See bug #4411 on http://bugs.gentoo.org/ for	78
49	more info. */	79	See bug http://bugs.gentoo.org/4411 for more info.
50	GROUP ( /lib/libxxx )	80	*/
		81	GROUP ( /${libdir}/${lib} )
51	END_LDSCRIPT	82	END_LDSCRIPT
52		83	fperms a+x "/usr/${libdir}/${lib}"
53	dosed "s:libxxx:$1:" /usr/lib/$1	84	done
54
55	return 0
56	}	85	}
57		86
58	# Simple function to draw a line consisting of '=' the same length as $*	87	# Simple function to draw a line consisting of '=' the same length as $*
		88	# - only to be used by epatch()
59	#	89	#
60	# <azarah@gentoo.org> (11 Nov 2002)	90	# <azarah@gentoo.org> (11 Nov 2002)
61	#	91	#
62	draw_line() {	92	draw_line() {
63	local i=0	93	local i=0
…		…
88	# Default directory where patches are located	118	# Default directory where patches are located
89	EPATCH_SOURCE="${WORKDIR}/patch"	119	EPATCH_SOURCE="${WORKDIR}/patch"
90	# Default extension for patches	120	# Default extension for patches
91	EPATCH_SUFFIX="patch.bz2"	121	EPATCH_SUFFIX="patch.bz2"
92	# Default options for patch	122	# Default options for patch
93	EPATCH_OPTS=""	123	# Set -g0 to keep RCS, ClearCase, Perforce and SCCS happy. Bug #24571
		124	# Set --no-backup-if-mismatch so we don't leave '.orig' files behind.
		125	EPATCH_OPTS="-g0 --no-backup-if-mismatch"
94	# List of patches not to apply. Not this is only file names,	126	# List of patches not to apply. Not this is only file names,
95	# and not the full path ..	127	# and not the full path ..
96	EPATCH_EXCLUDE=""	128	EPATCH_EXCLUDE=""
97	# Change the printed message for a single patch.	129	# Change the printed message for a single patch.
98	EPATCH_SINGLE_MSG=""	130	EPATCH_SINGLE_MSG=""
		131	# Change the printed message for multiple patches.
		132	EPATCH_MULTI_MSG="Applying various patches (bugfixes/updates) ..."
99	# Force applying bulk patches even if not following the style:	133	# Force applying bulk patches even if not following the style:
100	#	134	#
101	# ??_${ARCH}_foo.${EPATCH_SUFFIX}	135	# ??_${ARCH}_foo.${EPATCH_SUFFIX}
102	#	136	#
103	EPATCH_FORCE="no"	137	EPATCH_FORCE="no"
…		…
143	local SINGLE_PATCH="no"	177	local SINGLE_PATCH="no"
144	local x=""	178	local x=""
145		179
146	if [ "$#" -gt 1 ]	180	if [ "$#" -gt 1 ]
147	then	181	then
148	eerror "Invalid arguments to epatch()"	182	local m=""
149	die "Invalid arguments to epatch()"	183	for m in "$@" ; do
		184	epatch "${m}"
		185	done
		186	return 0
150	fi	187	fi
151		188
152	if [ -n "$1" -a -f "$1" ]	189	if [ -n "$1" -a -f "$1" ]
153	then	190	then
154	SINGLE_PATCH="yes"	191	SINGLE_PATCH="yes"
…		…
164	local EPATCH_SOURCE="$1/*"	201	local EPATCH_SOURCE="$1/*"
165	else	202	else
166	local EPATCH_SOURCE="$1/*.${EPATCH_SUFFIX}"	203	local EPATCH_SOURCE="$1/*.${EPATCH_SUFFIX}"
167	fi	204	fi
168	else	205	else
169	if [ ! -d ${EPATCH_SOURCE} ]	206	if [ ! -d ${EPATCH_SOURCE} ] \|\| [ -n "$1" ]
170	then	207	then
171	if [ -n "$1" -a "${EPATCH_SOURCE}" = "${WORKDIR}/patch" ]	208	if [ -n "$1" -a "${EPATCH_SOURCE}" = "${WORKDIR}/patch" ]
172	then	209	then
173	EPATCH_SOURCE="$1"	210	EPATCH_SOURCE="$1"
174	fi	211	fi
175		212
176	echo	213	echo
177	eerror "Cannot find \$EPATCH_SOURCE! Value for \$EPATCH_SOURCE is:"	214	eerror "Cannot find \$EPATCH_SOURCE! Value for \$EPATCH_SOURCE is:"
178	eerror	215	eerror
179	eerror " ${EPATCH_SOURCE}"	216	eerror " ${EPATCH_SOURCE}"
		217	eerror " ( ${EPATCH_SOURCE##*/} )"
180	echo	218	echo
181	die "Cannot find \$EPATCH_SOURCE!"	219	die "Cannot find \$EPATCH_SOURCE!"
182	fi	220	fi
183		221
184	local EPATCH_SOURCE="${EPATCH_SOURCE}/*.${EPATCH_SUFFIX}"	222	local EPATCH_SOURCE="${EPATCH_SOURCE}/*.${EPATCH_SUFFIX}"
…		…
203	;;	241	;;
204	esac	242	esac
205		243
206	if [ "${SINGLE_PATCH}" = "no" ]	244	if [ "${SINGLE_PATCH}" = "no" ]
207	then	245	then
208	einfo "Applying various patches (bugfixes/updates)..."	246	einfo "${EPATCH_MULTI_MSG}"
209	fi	247	fi
210	for x in ${EPATCH_SOURCE}	248	for x in ${EPATCH_SOURCE}
211	do	249	do
212	# New ARCH dependant patch naming scheme...	250	# New ARCH dependant patch naming scheme ...
213	#	251	#
214	# ???_arch_foo.patch	252	# ???_arch_foo.patch
215	#	253	#
216	if [ -f ${x} ] && \	254	if [ -f ${x} ] && \
217	([ "${SINGLE_PATCH}" = "yes" -o "${x/_all_}" != "${x}" -o "`eval echo \$\{x/_${ARCH}_\}`" != "${x}" ] \|\| \	255	([ "${SINGLE_PATCH}" = "yes" -o "${x/_all_}" != "${x}" -o "${x/_${ARCH}_}" != "${x}" ] \|\| \
218	[ "${EPATCH_FORCE}" = "yes" ])	256	[ "${EPATCH_FORCE}" = "yes" ])
219	then	257	then
220	local count=0	258	local count=0
221	local popts="${EPATCH_OPTS}"	259	local popts="${EPATCH_OPTS}"
		260	local patchname=${x##*/}
222		261
223	if [ -n "${EPATCH_EXCLUDE}" ]	262	if [ -n "${EPATCH_EXCLUDE}" ]
224	then	263	then
225	if [ "`eval echo \$\{EPATCH_EXCLUDE/${x##*/}\}`" != "${EPATCH_EXCLUDE}" ]	264	if [ "${EPATCH_EXCLUDE/${patchname}}" != "${EPATCH_EXCLUDE}" ]
226	then	265	then
227	continue	266	continue
228	fi	267	fi
229	fi	268	fi
230		269
…		…
232	then	271	then
233	if [ -n "${EPATCH_SINGLE_MSG}" ]	272	if [ -n "${EPATCH_SINGLE_MSG}" ]
234	then	273	then
235	einfo "${EPATCH_SINGLE_MSG}"	274	einfo "${EPATCH_SINGLE_MSG}"
236	else	275	else
237	einfo "Applying ${x##*/}..."	276	einfo "Applying ${patchname} ..."
238	fi	277	fi
239	else	278	else
240	einfo " ${x##*/}..."	279	einfo " ${patchname} ..."
241	fi	280	fi
242		281
243	echo "***** ${x##/} ***" > ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}	282	echo "*** ${patchname} **" > ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##*/}
244	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}	283	echo >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}
245		284
246	# Allow for prefix to differ ... im lazy, so shoot me :/	285	# Allow for prefix to differ ... im lazy, so shoot me :/
247	while [ "${count}" -lt 5 ]	286	while [ "${count}" -lt 5 ]
248	do	287	do
249	# Generate some useful debug info ...	288	# Generate some useful debug info ...
250	draw_line "***** ${x##/} ***" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}	289	draw_line "*** ${patchname} **" >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##*/}
251	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}	290	echo >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}
252		291
253	if [ "${PATCH_SUFFIX}" != "patch" ]	292	if [ "${PATCH_SUFFIX}" != "patch" ]
254	then	293	then
255	echo -n "PIPE_COMMAND: " >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}	294	echo -n "PIPE_COMMAND: " >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}
256	echo "${PIPE_CMD} ${x} > ${PATCH_TARGET}" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}	295	echo "${PIPE_CMD} ${x} > ${PATCH_TARGET}" >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}
257	else	296	else
258	PATCH_TARGET="${x}"	297	PATCH_TARGET="${x}"
259	fi	298	fi
260		299
261	echo -n "PATCH COMMAND: " >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}	300	echo -n "PATCH COMMAND: " >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}
262	echo "patch ${popts} -p${count} < ${PATCH_TARGET}" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}	301	echo "patch -p${count} ${popts} < ${PATCH_TARGET}" >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}
263		302
264	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}	303	echo >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}
265	draw_line "***** ${x##/} ***" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}	304	draw_line "*** ${patchname} **" >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##*/}
266		305
267	if [ "${PATCH_SUFFIX}" != "patch" ]	306	if [ "${PATCH_SUFFIX}" != "patch" ]
268	then	307	then
269	if ! (${PIPE_CMD} ${x} > ${PATCH_TARGET}) >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/} 2>&1	308	if ! (${PIPE_CMD} ${x} > ${PATCH_TARGET}) >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/} 2>&1
270	then	309	then
271	echo	310	echo
272	eerror "Could not extract patch!"	311	eerror "Could not extract patch!"
273	#die "Could not extract patch!"	312	#die "Could not extract patch!"
274	count=5	313	count=5
275	break	314	break
276	fi	315	fi
277	fi	316	fi
278		317
279	if (cat ${PATCH_TARGET} \| patch ${popts} --dry-run -f -p${count}) >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/} 2>&1	318	if (cat ${PATCH_TARGET} \| patch -p${count} ${popts} --dry-run -f) >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/} 2>&1
280	then	319	then
281	draw_line "***** ${x##/} ***" > ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}.real	320	draw_line "*** ${patchname} **" > ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##*/}.real
282	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}.real	321	echo >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}.real
283	echo "ACTUALLY APPLYING ${x##/}..." >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}.real	322	echo "ACTUALLY APPLYING ${patchname} ..." >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}.real
284	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}.real	323	echo >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}.real
285	draw_line "***** ${x##/} ***" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}.real	324	draw_line "*** ${patchname} **" >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##*/}.real
286		325
287	cat ${PATCH_TARGET} \| patch ${popts} -p${count} >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}.real 2>&1	326	cat ${PATCH_TARGET} \| patch -p${count} ${popts} >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}.real 2>&1
288		327
289	if [ "$?" -ne 0 ]	328	if [ "$?" -ne 0 ]
290	then	329	then
291	cat ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}.real >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}	330	cat ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}.real >> ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}
292	echo	331	echo
293	eerror "A dry-run of patch command succeeded, but actually"	332	eerror "A dry-run of patch command succeeded, but actually"
294	eerror "applying the patch failed!"	333	eerror "applying the patch failed!"
295	#die "Real world sux compared to the dreamworld!"	334	#die "Real world sux compared to the dreamworld!"
296	count=5	335	count=5
297	fi	336	fi
298		337
299	rm -f ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}.real	338	rm -f ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}.real
300		339
301	break	340	break
302	fi	341	fi
303		342
304	count=$((count + 1))	343	count=$((count + 1))
…		…
310	fi	349	fi
311		350
312	if [ "${count}" -eq 5 ]	351	if [ "${count}" -eq 5 ]
313	then	352	then
314	echo	353	echo
315	eerror "Failed Patch: ${x##*/}!"	354	eerror "Failed Patch: ${patchname} !"
		355	eerror " ( ${PATCH_TARGET} )"
316	eerror	356	eerror
317	eerror "Include in your bugreport the contents of:"	357	eerror "Include in your bugreport the contents of:"
318	eerror	358	eerror
319	eerror " ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}"	359	eerror " ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}"
320	echo	360	echo
321	die "Failed Patch: ${x##*/}!"	361	die "Failed Patch: ${patchname}!"
322	fi	362	fi
323		363
324	rm -f ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}	364	rm -f ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}
325		365
326	eend 0	366	eend 0
327	fi	367	fi
328	done	368	done
329	if [ "${SINGLE_PATCH}" = "no" ]	369	if [ "${SINGLE_PATCH}" = "no" ]
330	then	370	then
331	einfo "Done with patching"	371	einfo "Done with patching"
332	fi	372	fi
333	}	373	}
334		374
335	# This function return true if we are using the NPTL pthreads	375	# Cheap replacement for when debianutils (and thus mktemp)
336	# implementation.	376	# does not exist on the users system
		377	# vapier@gentoo.org
337	#	378	#
338	# <azarah@gentoo.org> (06 March 2003)	379	# Takes just 1 optional parameter (the directory to create tmpfile in)
339	#	380	emktemp() {
		381	local exe="touch"
		382	[ "$1" == "-d" ] && exe="mkdir" && shift
		383	local topdir="$1"
340		384
341	have_NPTL() {	385	if [ -z "${topdir}" ]
342
343	cat > ${T}/test-nptl.c <<-"END"
344	#define _XOPEN_SOURCE
345	#include <unistd.h>
346	#include <stdio.h>
347
348	int main()
349	{
350	char buf[255];
351	char *str = buf;
352
353	confstr(_CS_GNU_LIBPTHREAD_VERSION, str, 255);
354	if (NULL != str) {
355	printf("%s\n", str);
356	if (NULL != strstr(str, "NPTL"))
357	return 0;
358	}
359
360	return 1;
361	}
362	END
363
364	einfon "Checking for _CS_GNU_LIBPTHREAD_VERSION support in glibc ... "
365	if gcc -o ${T}/nptl ${T}/test-nptl.c &> /dev/null
366	then	386	then
367	echo "yes"	387	[ -z "${T}" ] \
368	einfon "Checking what PTHREADS implementation we have ... "	388	&& topdir="/tmp" \
369	if ${T}/nptl	389	\|\| topdir="${T}"
		390	fi
		391
		392	if [ -z "$(type -p mktemp)" ]
		393	then
		394	local tmp=/
		395	while [ -e "${tmp}" ] ; do
		396	tmp="${topdir}/tmp.${RANDOM}.${RANDOM}.${RANDOM}"
		397	done
		398	${exe} "${tmp}"
		399	echo "${tmp}"
		400	else
		401	[ "${exe}" == "touch" ] \
		402	&& exe="-p" \
		403	\|\| exe="-d"
		404	mktemp ${exe} "${topdir}"
		405	fi
		406	}
		407
		408	# Small wrapper for getent (Linux), nidump (Mac OS X),
		409	# and pw (FreeBSD) used in enewuser()/enewgroup()
		410	# Joe Jezak <josejx@gmail.com> and usata@gentoo.org
		411	# FBSD stuff: Aaron Walker <ka0ttic@gentoo.org>
		412	#
		413	# egetent(database, key)
		414	egetent() {
		415	if [[ "${USERLAND}" == "Darwin" ]] ; then
		416	case "$2" in
		417	[!0-9]) # Non numeric
		418	nidump $1 . \| awk -F":" "{ if (\$1 ~ /^$2$/) {print \$0;exit;} }"
		419	;;
		420	*) # Numeric
		421	nidump $1 . \| awk -F":" "{ if (\$3 == $2) {print \$0;exit;} }"
		422	;;
		423	esac
		424	elif [[ "${USERLAND}" == "BSD" ]] ; then
		425	local action
		426	if [ "$1" == "passwd" ]
370	then	427	then
371	return 0	428	action="user"
372	else	429	else
373	return 1	430	action="group"
374	fi
375	else
376	echo "no"
377	fi	431	fi
378		432	pw show "${action}" "$2" -q
379	return 1
380	}
381
382	# This function check how many cpu's are present, and then set
383	# -j in MAKEOPTS accordingly.
384	#
385	# Thanks to nall <nall@gentoo.org> for this.
386	#
387	get_number_of_jobs() {
388	local jobs=0
389
390	if [ ! -r /proc/cpuinfo ]
391	then
392	return 1
393	fi
394
395	# This bit is from H?kan Wessberg <nacka-gentoo@refug.org>, bug #13565.
396	if [ "`egrep "^[[:space:]]*MAKEOPTS=" /etc/make.conf \| wc -l`" -gt 0 ]
397	then
398	ADMINOPTS="`egrep "^[[:space:]]*MAKEOPTS=" /etc/make.conf \| cut -d= -f2 \| sed 's/\"//g'`"
399	ADMINPARAM="`echo ${ADMINOPTS} \| gawk '{match($0, /-j [0-9]/, opt); print opt[0]}'`"
400	ADMINPARAM="${ADMINPARAM/-j}"
401	fi
402
403	export MAKEOPTS="`echo ${MAKEOPTS} \| sed -e 's:-j [0-9]::g'`"
404
405	if [ "${ARCH}" = "amd64" -o "${ARCH}" = "x86" -o "${ARCH}" = "hppa" -o \
406	"${ARCH}" = "arm" -o "${ARCH}" = "mips" ]
407	then
408	# these archs will always have "[Pp]rocessor"
409	jobs="$((`grep -c ^[Pp]rocessor /proc/cpuinfo` * 2))"
410
411	elif [ "${ARCH}" = "sparc" -o "${ARCH}" = "sparc64" ]
412	then
413	# sparc always has "ncpus active"
414	jobs="$((`grep "^ncpus active" /proc/cpuinfo \| sed -e "s/^.: //"` 2))"
415
416	elif [ "${ARCH}" = "alpha" ]
417	then
418	# alpha has "cpus active", but only when compiled with SMP
419	if [ "`grep -c "^cpus active" /proc/cpuinfo`" -eq 1 ]
420	then
421	jobs="$((`grep "^cpus active" /proc/cpuinfo \| sed -e "s/^.: //"` 2))"
422	else	433	else
423	jobs=2	434	which nscd >& /dev/null && nscd -i "$1"
424	fi	435	getent "$1" "$2"
425
426	elif [ "${ARCH}" = "ppc" ]
427	then
428	# ppc has "processor", but only when compiled with SMP
429	if [ "`grep -c "^processor" /proc/cpuinfo`" -eq 1 ]
430	then
431	jobs="$((`grep -c ^processor /proc/cpuinfo` * 2))"
432	else
433	jobs=2
434	fi
435	else
436	jobs="$((`grep -c ^cpu /proc/cpuinfo` * 2))"
437	die "Unknown ARCH -- ${ARCH}!"
438	fi
439
440	# Make sure the number is valid ...
441	if [ "${jobs}" -lt 1 ]
442	then
443	jobs=1
444	fi
445
446	if [ -n "${ADMINPARAM}" ]
447	then
448	if [ "${jobs}" -gt "${ADMINPARAM}" ]
449	then
450	einfo "Setting make jobs to \"-j${ADMINPARAM}\" to ensure successful merge..."
451	export MAKEOPTS="${MAKEOPTS} -j${ADMINPARAM}"
452	else
453	einfo "Setting make jobs to \"-j${jobs}\" to ensure successful merge..."
454	export MAKEOPTS="${MAKEOPTS} -j${jobs}"
455	fi
456	fi	436	fi
457	}	437	}
458		438
459	# Simplify/standardize adding users to the system	439	# Simplify/standardize adding users to the system
460	# vapier@gentoo.org	440	# vapier@gentoo.org
…		…
469	# homedir: /dev/null	449	# homedir: /dev/null
470	# groups: none	450	# groups: none
471	# extra: comment of 'added by portage for ${PN}'	451	# extra: comment of 'added by portage for ${PN}'
472	enewuser() {	452	enewuser() {
473	# get the username	453	# get the username
474	local euser="$1"; shift	454	local euser=$1; shift
475	if [ -z "${euser}" ] ; then	455	if [[ -z ${euser} ]] ; then
476	eerror "No username specified !"	456	eerror "No username specified !"
477	die "Cannot call enewuser without a username"	457	die "Cannot call enewuser without a username"
478	fi	458	fi
		459
		460	# lets see if the username already exists
		461	if [[ ${euser} == $(egetent passwd "${euser}" \| cut -d: -f1) ]] ; then
		462	return 0
		463	fi
479	einfo "Adding user '${euser}' to your system ..."	464	einfo "Adding user '${euser}' to your system ..."
480		465
481	# setup a file for testing usernames/groups
482	local tmpfile="`mktemp -p ${T}`"
483	touch ${tmpfile}
484	chown ${euser} ${tmpfile} >& /dev/null
485	local realuser="`ls -l ${tmpfile} \| awk '{print $3}'`"
486
487	# see if user already exists
488	if [ "${euser}" == "${realuser}" ] ; then
489	einfo "${euser} already exists on your system :)"
490	return 0
491	fi
492
493	# options to pass to useradd	466	# options to pass to useradd
494	local opts=""	467	local opts=
495		468
496	# handle uid	469	# handle uid
497	local euid="$1"; shift	470	local euid=$1; shift
498	if [ ! -z "${euid}" ] && [ "${euid}" != "-1" ] ; then	471	if [[ ! -z ${euid} ]] && [[ ${euid} != "-1" ]] ; then
499	if [ ${euid} -gt 0 ] ; then	472	if [[ ${euid} -gt 0 ]] ; then
500	opts="${opts} -u ${euid}"	473	if [[ ! -z $(egetent passwd ${euid}) ]] ; then
		474	euid="next"
		475	fi
501	else	476	else
502	eerror "Userid given but is not greater than 0 !"	477	eerror "Userid given but is not greater than 0 !"
503	die "${euid} is not a valid UID"	478	die "${euid} is not a valid UID"
504	fi	479	fi
505	else	480	else
506	euid="next available"	481	euid="next"
		482	fi
		483	if [[ ${euid} == "next" ]] ; then
		484	local pwrange
		485	if [[ ${USERLAND} == "BSD" ]] ; then
		486	pwrange=$(jot 898 101)
		487	else
		488	pwrange=$(seq 101 999)
507	fi	489	fi
		490	for euid in ${pwrange} ; do
		491	[[ -z $(egetent passwd ${euid}) ]] && break
		492	done
		493	fi
		494	opts="${opts} -u ${euid}"
508	einfo " - Userid: ${euid}"	495	einfo " - Userid: ${euid}"
509		496
510	# handle shell	497	# handle shell
511	local eshell="$1"; shift	498	local eshell=$1; shift
512	if [ ! -z "${eshell}" ] ; then	499	if [[ ! -z ${eshell} ]] && [[ ${eshell} != "-1" ]] ; then
513	if [ ! -e ${eshell} ] ; then	500	if [[ ! -e ${eshell} ]] ; then
514	eerror "A shell was specified but it does not exist !"	501	eerror "A shell was specified but it does not exist !"
515	die "${eshell} does not exist"	502	die "${eshell} does not exist"
516	fi	503	fi
517	else	504	else
518	eshell=/bin/false	505	case ${USERLAND} in
		506	Darwin) eshell="/usr/bin/false";;
		507	BSD) eshell="/usr/sbin/nologin";;
		508	*) eshell="/bin/false";;
		509	esac
519	fi	510	fi
520	einfo " - Shell: ${eshell}"	511	einfo " - Shell: ${eshell}"
521	opts="${opts} -s ${eshell}"	512	opts="${opts} -s ${eshell}"
522		513
523	# handle homedir	514	# handle homedir
524	local ehome="$1"; shift	515	local ehome=$1; shift
525	if [ -z "${ehome}" ] ; then	516	if [[ -z ${ehome} ]] \|\| [[ ${ehome} == "-1" ]] ; then
526	ehome=/dev/null	517	ehome="/dev/null"
527	fi	518	fi
528	einfo " - Home: ${ehome}"	519	einfo " - Home: ${ehome}"
529	opts="${opts} -d ${ehome}"	520	opts="${opts} -d ${ehome}"
530		521
531	# handle groups	522	# handle groups
532	local egroups="$1"; shift	523	local egroups=$1; shift
533	if [ ! -z "${egroups}" ] ; then	524	if [[ ! -z ${egroups} ]] ; then
534	local realgroup
535	local oldifs="${IFS}"	525	local oldifs=${IFS}
		526	local defgroup="" exgroups=""
		527
536	export IFS=","	528	export IFS=","
537	for g in ${egroups} ; do	529	for g in ${egroups} ; do
538	chgrp ${g} ${tmpfile} >& /dev/null	530	export IFS=${oldifs}
539	realgroup="`ls -l ${tmpfile} \| awk '{print $4}'`"	531	if [[ -z $(egetent group "${g}") ]] ; then
540	if [ "${g}" != "${realgroup}" ] ; then
541	eerror "You must add ${g} to the system first"	532	eerror "You must add group ${g} to the system first"
542	die "${g} is not a valid GID"	533	die "${g} is not a valid GID"
543	fi	534	fi
		535	if [[ -z ${defgroup} ]] ; then
		536	defgroup=${g}
		537	else
		538	exgroups="${exgroups},${g}"
		539	fi
		540	export IFS=","
544	done	541	done
545	export IFS="${oldifs}"	542	export IFS=${oldifs}
		543
546	opts="${opts} -g ${egroups}"	544	opts="${opts} -g ${defgroup}"
		545	if [[ ! -z ${exgroups} ]] ; then
		546	opts="${opts} -G ${exgroups:1}"
		547	fi
547	else	548	else
548	egroups="(none)"	549	egroups="(none)"
549	fi	550	fi
550	einfo " - Groups: ${egroups}"	551	einfo " - Groups: ${egroups}"
551		552
552	# handle extra and add the user	553	# handle extra and add the user
553	local eextra="$@"
554	local oldsandbox=${SANDBOX_ON}	554	local oldsandbox=${SANDBOX_ON}
555	export SANDBOX_ON="0"	555	export SANDBOX_ON="0"
556	if [ -z "${eextra}" ] ; then	556	case ${USERLAND} in
557	useradd ${opts} ${euser} \	557	Darwin)
		558	### Make the user
		559	if [[ -z $@ ]] ; then
		560	dscl . create /users/${euser} uid ${euid}
		561	dscl . create /users/${euser} shell ${eshell}
		562	dscl . create /users/${euser} home ${ehome}
		563	dscl . create /users/${euser} realname "added by portage for ${PN}"
		564	### Add the user to the groups specified
		565	local oldifs=${IFS}
		566	export IFS=","
		567	for g in ${egroups} ; do
		568	dscl . merge /groups/${g} users ${euser}
		569	done
		570	export IFS=${oldifs}
		571	else
		572	einfo "Extra options are not supported on Darwin yet"
		573	einfo "Please report the ebuild along with the info below"
		574	einfo "eextra: $@"
		575	die "Required function missing"
		576	fi
		577	;;
		578	BSD)
		579	if [[ -z $@ ]] ; then
		580	pw useradd ${euser} ${opts} \
558	-c "added by portage for ${PN}" \	581	-c "added by portage for ${PN}" \
		582	die "enewuser failed"
		583	else
		584	einfo " - Extra: $@"
		585	pw useradd ${euser} ${opts} \
		586	"$@" \|\| die "enewuser failed"
		587	fi
		588	;;
		589	*)
		590	if [[ -z $@ ]] ; then
		591	useradd ${opts} ${euser} \
		592	-c "added by portage for ${PN}" \
559	\|\| die "enewuser failed"	593	\|\| die "enewuser failed"
560	else	594	else
561	einfo " - Extra: ${eextra}"	595	einfo " - Extra: $@"
562	useradd ${opts} ${euser} ${eextra} \	596	useradd ${opts} ${euser} "$@" \
563	\|\| die "enewuser failed"	597	\|\| die "enewuser failed"
564	fi	598	fi
		599	;;
		600	esac
565	export SANDBOX_ON="${oldsandbox}"	601	export SANDBOX_ON=${oldsandbox}
566		602
567	if [ ! -e ${ehome} ] && [ ! -e ${D}/${ehome} ] ; then	603	if [ ! -e "${ehome}" ] && [ ! -e "${D}/${ehome}" ]
		604	then
568	einfo " - Creating ${ehome} in ${D}"	605	einfo " - Creating ${ehome} in ${D}"
569	dodir ${ehome}	606	dodir ${ehome}
570	fowners ${euser} ${ehome}	607	fowners ${euser} ${ehome}
571	fperms 755 ${ehome}	608	fperms 755 ${ehome}
572	fi	609	fi
…		…
582	# gid: next available (see groupadd(8))	619	# gid: next available (see groupadd(8))
583	# extra: none	620	# extra: none
584	enewgroup() {	621	enewgroup() {
585	# get the group	622	# get the group
586	local egroup="$1"; shift	623	local egroup="$1"; shift
587	if [ -z "${egroup}" ] ; then	624	if [ -z "${egroup}" ]
		625	then
588	eerror "No group specified !"	626	eerror "No group specified !"
589	die "Cannot call enewgroup without a group"	627	die "Cannot call enewgroup without a group"
590	fi	628	fi
		629
		630	# see if group already exists
		631	if [ "${egroup}" == "`egetent group \"${egroup}\" \| cut -d: -f1`" ]
		632	then
		633	return 0
		634	fi
591	einfo "Adding group '${egroup}' to your system ..."	635	einfo "Adding group '${egroup}' to your system ..."
592		636
593	# setup a file for testing groupname
594	local tmpfile="`mktemp -p ${T}`"
595	touch ${tmpfile}
596	chgrp ${egroup} ${tmpfile} >& /dev/null
597	local realgroup="`ls -l ${tmpfile} \| awk '{print $4}'`"
598
599	# see if group already exists
600	if [ "${egroup}" == "${realgroup}" ] ; then
601	einfo "${egroup} already exists on your system :)"
602	return 0
603	fi
604
605	# options to pass to useradd	637	# options to pass to useradd
606	local opts=""	638	local opts=
607		639
608	# handle gid	640	# handle gid
609	local egid="$1"; shift	641	local egid="$1"; shift
610	if [ ! -z "${egid}" ] ; then	642	if [ ! -z "${egid}" ]
		643	then
611	if [ ${egid} -gt 0 ] ; then	644	if [ "${egid}" -gt 0 ]
		645	then
		646	if [ -z "`egetent group ${egid}`" ]
		647	then
		648	if [[ "${USERLAND}" == "Darwin" ]]; then
		649	opts="${opts} ${egid}"
		650	else
612	opts="${opts} -g ${egid}"	651	opts="${opts} -g ${egid}"
		652	fi
		653	else
		654	egid="next available; requested gid taken"
		655	fi
613	else	656	else
614	eerror "Groupid given but is not greater than 0 !"	657	eerror "Groupid given but is not greater than 0 !"
615	die "${egid} is not a valid GID"	658	die "${egid} is not a valid GID"
616	fi	659	fi
617	else	660	else
…		…
622	# handle extra	665	# handle extra
623	local eextra="$@"	666	local eextra="$@"
624	opts="${opts} ${eextra}"	667	opts="${opts} ${eextra}"
625		668
626	# add the group	669	# add the group
627	local oldsandbox=${SANDBOX_ON}	670	local oldsandbox="${SANDBOX_ON}"
628	export SANDBOX_ON="0"	671	export SANDBOX_ON="0"
		672	if [[ "${USERLAND}" == "Darwin" ]]; then
		673	if [ ! -z "${eextra}" ];
		674	then
		675	einfo "Extra options are not supported on Darwin/OS X yet"
		676	einfo "Please report the ebuild along with the info below"
		677	einfo "eextra: ${eextra}"
		678	die "Required function missing"
		679	fi
		680
		681	# If we need the next available
		682	case ${egid} in
		683	[!0-9]) # Non numeric
		684	for egid in `jot 898 101`; do
		685	[ -z "`egetent group ${egid}`" ] && break
		686	done
		687	esac
		688	dscl . create /groups/${egroup} gid ${egid}
		689	dscl . create /groups/${egroup} passwd '*'
		690	elif [[ "${USERLAND}" == "BSD" ]] ; then
		691	case ${egid} in
		692	[!0-9]) # Non numeric
		693	for egid in `jot 898 101`; do
		694	[ -z "`egetent group ${egid}`" ] && break
		695	done
		696	esac
		697	pw groupadd ${egroup} -g ${egid} \|\| die "enewgroup failed"
		698	else
629	groupadd ${opts} ${egroup} \|\| die "enewgroup failed"	699	groupadd ${opts} ${egroup} \|\| die "enewgroup failed"
		700	fi
630	export SANDBOX_ON="${oldsandbox}"	701	export SANDBOX_ON="${oldsandbox}"
631	}	702	}
632		703
633	# Simple script to replace 'dos2unix' binaries	704	# Simple script to replace 'dos2unix' binaries
634	# vapier@gentoo.org	705	# vapier@gentoo.org
635	#	706	#
636	# edos2unix(file, <more files>...)	707	# edos2unix(file, <more files> ...)
637	edos2unix() {	708	edos2unix() {
638	for f in $@ ; do	709	for f in "$@"
		710	do
639	cp ${f} ${T}/edos2unix	711	cp "${f}" ${T}/edos2unix
640	sed 's/\r$//' ${T}/edos2unix > ${f}	712	sed 's/\r$//' ${T}/edos2unix > "${f}"
641	done	713	done
642	}	714	}
		715
		716
		717	##############################################################
		718	# START: Handle .desktop files and menu entries #
		719	# maybe this should be separated into a new eclass some time #
		720	# lanius@gentoo.org #
		721	##############################################################
643		722
644	# Make a desktop file !	723	# Make a desktop file !
645	# Great for making those icons in kde/gnome startmenu !	724	# Great for making those icons in kde/gnome startmenu !
646	# Amaze your friends ! Get the women ! Join today !	725	# Amaze your friends ! Get the women ! Join today !
647	# gnome2 /usr/share/applications
648	# gnome1 /usr/share/gnome/apps/
649	# KDE ${KDEDIR}/share/applnk /usr/share/applnk
650	#	726	#
651	# make_desktop_entry(<binary>, [name], [icon], [type], [path])	727	# make_desktop_entry(<binary>, [name], [icon], [type], [path])
652	#	728	#
653	# binary: what binary does the app run with ?	729	# binary: what binary does the app run with ?
654	# name: the name that will show up in the menu	730	# name: the name that will show up in the menu
655	# icon: give your little like a pretty little icon ...	731	# icon: give your little like a pretty little icon ...
656	# this can be relative (to /usr/share/pixmaps) or	732	# this can be relative (to /usr/share/pixmaps) or
657	# a full path to an icon	733	# a full path to an icon
658	# type: what kind of application is this ? for categories:	734	# type: what kind of application is this ? for categories:
659	# http://www.freedesktop.org/standards/menu/draft/menu-spec/menu-spec.html	735	# http://www.freedesktop.org/wiki/Standards_2fmenu_2dspec
660	# path: if your app needs to startup in a specific dir	736	# path: if your app needs to startup in a specific dir
661	make_desktop_entry() {	737	make_desktop_entry() {
662	[ -z "$1" ] && eerror "You must specify the executable" && return 1	738	[[ -z $1 ]] && eerror "make_desktop_entry: You must specify the executable" && return 1
663		739
664	local exec=${1}	740	local exec=${1}
665	local name=${2:-${PN}}	741	local name=${2:-${PN}}
666	local icon=${3:-${PN}.png}	742	local icon=${3:-${PN}.png}
667	local type=${4}	743	local type=${4}
668	local path=${5:-${GAMES_PREFIX}}	744	local path=${5}
		745
669	if [ -z "${type}" ] ; then	746	if [[ -z ${type} ]] ; then
670	case ${CATEGORY} in	747	local catmaj=${CATEGORY%%-*}
		748	local catmin=${CATEGORY##*-}
		749	case ${catmaj} in
		750	app)
		751	case ${catmin} in
		752	admin) type=System;;
		753	cdr) type=DiscBurning;;
		754	dicts) type=Dictionary;;
		755	editors) type=TextEditor;;
		756	emacs) type=TextEditor;;
671	app-emulation) type=Emulator ;;	757	emulation) type=Emulator;;
672	app-games) type=Game ;;	758	laptop) type=HardwareSettings;;
673	*) type="" ;;	759	office) type=Office;;
		760	vim) type=TextEditor;;
		761	xemacs) type=TextEditor;;
		762	*) type=;;
		763	esac
		764	;;
		765
		766	dev)
		767	type="Development"
		768	;;
		769
		770	games)
		771	[[ -z ${path} ]] && path=${GAMES_BINDIR}
		772
		773	case ${catmin} in
		774	action) type=ActionGame;;
		775	arcade) type=ArcadeGame;;
		776	board) type=BoardGame;;
		777	kid) type=KidsGame;;
		778	emulation) type=Emulator;;
		779	puzzle) type=LogicGame;;
		780	rpg) type=RolePlaying;;
		781	roguelike) type=RolePlaying;;
		782	simulation) type=Simulation;;
		783	sports) type=SportsGame;;
		784	strategy) type=StrategyGame;;
		785	*) type=;;
		786	esac
		787	type="Game;${type}"
		788	;;
		789
		790	mail)
		791	type="Network;Email"
		792	;;
		793
		794	media)
		795	case ${catmin} in
		796	gfx) type=Graphics;;
		797	radio) type=Tuner;;
		798	sound) type=Audio;;
		799	tv) type=TV;;
		800	video) type=Video;;
		801	*) type=;;
		802	esac
		803	type="AudioVideo;${type}"
		804	;;
		805
		806	net)
		807	case ${catmin} in
		808	dialup) type=Dialup;;
		809	ftp) type=FileTransfer;;
		810	im) type=InstantMessaging;;
		811	irc) type=IRCClient;;
		812	mail) type=Email;;
		813	news) type=News;;
		814	nntp) type=News;;
		815	p2p) type=FileTransfer;;
		816	*) type=;;
		817	esac
		818	type="Network;${type}"
		819	;;
		820
		821	sci)
		822	case ${catmin} in
		823	astro*) type=Astronomoy;;
		824	bio*) type=Biology;;
		825	calc*) type=Calculator;;
		826	chem*) type=Chemistry;;
		827	geo*) type=Geology;;
		828	math*) type=Math;;
		829	*) type=;;
		830	esac
		831	type="Science;${type}"
		832	;;
		833
		834	www)
		835	case ${catmin} in
		836	client) type=WebBrowser;;
		837	*) type=;;
		838	esac
		839	type="Network"
		840	;;
		841
		842	*)
		843	type=
		844	;;
674	esac	845	esac
675	fi	846	fi
		847	if [ "${SLOT}" == "0" ] ; then
		848	local desktop_name="${PN}"
		849	else
		850	local desktop_name="${PN}-${SLOT}"
		851	fi
676	local desktop=${T}/${exec}.desktop	852	local desktop=${T}/${exec%% *}-${desktop_name}.desktop
677		853
678	echo "[Desktop Entry]	854	echo "[Desktop Entry]
679	Encoding=UTF-8	855	Encoding=UTF-8
680	Version=0.9.2	856	Version=0.9.2
681	Name=${name}	857	Name=${name}
682	Type=Application	858	Type=Application
683	Comment=${DESCRIPTION}	859	Comment=${DESCRIPTION}
684	Exec=${exec}	860	Exec=${exec}
685	Path=${path}	861	Path=${path}
686	Icon=${icon}	862	Icon=${icon}
687	Categories=Application;${type};" > ${desktop}	863	Categories=Application;${type};" > "${desktop}"
688		864
689	if [ -d /usr/share/applications ] ; then
690	insinto /usr/share/applications	865	insinto /usr/share/applications
691	doins ${desktop}	866	doins "${desktop}"
692	fi
693
694	#if [ -d /usr/share/gnome/apps ] ; then
695	# insinto /usr/share/gnome/apps/Games
696	# doins ${desktop}
697	#fi
698
699	#if [ ! -z "`ls /usr/kde/* 2>/dev/null`" ] ; then
700	# for ver in /usr/kde/* ; do
701	# insinto ${ver}/share/applnk/Games
702	# doins ${desktop}
703	# done
704	#fi
705
706	if [ -d /usr/share/applnk ] ; then
707	insinto /usr/share/applnk/${type}
708	doins ${desktop}
709	fi
710		867
711	return 0	868	return 0
712	}	869	}
713		870
714	# new convenience patch wrapper function to eventually replace epatch(),	871	# Make a GDM/KDM Session file
715	# $PATCHES, $PATCHES1, src_unpack:patch, src_unpack:autopatch and	872	#
716	# /usr/bin/patch	873	# make_desktop_entry(<title>, <command>)
717	# Features:	874	# title: File to execute to start the Window Manager
718	# - bulk patch handling similar to epatch()'s	875	# command: Name of the Window Manager
719	# - automatic patch level detection like epatch()'s
720	# - automatic patch uncompression like epatch()'s
721	# - doesn't have the --dry-run overhead of epatch() - inspects patchfiles
722	# manually instead
723	# - once I decide it's production-ready, it'll be called from base_src_unpack
724	# to handle $PATCHES to avoid defining src_unpack just to use xpatch
725		876
726	# accepts zero or more parameters specifying patchfiles and/or patchdirs	877	make_session_desktop() {
		878	[[ -z $1 ]] && eerror "make_session_desktop: You must specify the title" && return 1
		879	[[ -z $2 ]] && eerror "make_session_desktop: You must specify the command" && return 1
727		880
728	# known issues:	881	local title=$1
729	# - only supports unified style patches (does anyone _really_ use anything	882	local command=$2
730	# else?)	883	local desktop=${T}/${wm}.desktop
731	# - because it doesn't use --dry-run there is a risk of it failing
732	# to find the files to patch, ie detect the patchlevel, properly. It doesn't use
733	# any of the backup heuristics that patch employs to discover a filename.
734	# however, this isn't dangerous because if it works for the developer who's
735	# writing the ebuild, it'll always work for the users, and if it doesn't,
736	# then we'll fix it :-)
737	# - no support as yet for patches applying outside $S (and not directly in $WORKDIR).
738	xpatch() {
739		884
740	debug-print-function $FUNCNAME $*	885	echo "[Desktop Entry]
		886	Encoding=UTF-8
		887	Name=${title}
		888	Comment=This session logs you into ${title}
		889	Exec=${command}
		890	TryExec=${command}
		891	Type=Application" > "${desktop}"
741		892
742	local list=""	893	insinto /usr/share/xsessions
743	local list2=""	894	doins "${desktop}"
744	declare -i plevel	895	}
745		896
746	# parse patch sources	897	domenu() {
		898	local i j
		899	insinto /usr/share/applications
747	for x in $*; do	900	for i in "$@" ; do
748	debug-print "$FUNCNAME: parsing parameter $x"
749	if [ -f "$x" ]; then	901	if [[ -f ${i} ]] ; then
750	list="$list $x"	902	doins "${i}"
751	elif [ -d "$x" ]; then	903	elif [[ -d ${i} ]] ; then
752	# handles patchdirs like epatch() for now: no recursion.	904	for j in "${i}"/*.desktop ; do
753	# patches are sorted by filename, so with an xy_foo naming scheme you'll get the right order.	905	doins "${j}"
754	# only patches with _$ARCH_ or _all_ in their filenames are applied.
755	for file in `ls -A $x`; do
756	debug-print "$FUNCNAME: parsing in subdir: file $file"
757	if [ -f "$x/$file" ] && [ "${file}" != "${file/_all_}" -o "${file}" != "${file/_$ARCH_}" ]; then
758	list2="$list2 $x/$file"
759	fi
760	done	906	done
761	list="`echo $list2 \| sort` $list"	907	fi
		908	done
		909	}
		910	newmenu() {
		911	insinto /usr/share/applications
		912	newins "$1" "$2"
		913	}
		914
		915	doicon() {
		916	local i j
		917	insinto /usr/share/pixmaps
		918	for i in "$@" ; do
		919	if [[ -f ${i} ]] ; then
		920	doins "${i}"
		921	elif [[ -d ${i} ]] ; then
		922	for j in "${i}"/*.png ; do
		923	doins "${j}"
		924	done
		925	fi
		926	done
		927	}
		928	newicon() {
		929	insinto /usr/share/pixmaps
		930	newins "$1" "$2"
		931	}
		932
		933	##############################################################
		934	# END: Handle .desktop files and menu entries #
		935	##############################################################
		936
		937
		938	# for internal use only (unpack_pdv and unpack_makeself)
		939	find_unpackable_file() {
		940	local src="$1"
		941	if [ -z "${src}" ]
		942	then
		943	src="${DISTDIR}/${A}"
		944	else
		945	if [ -e "${DISTDIR}/${src}" ]
		946	then
		947	src="${DISTDIR}/${src}"
		948	elif [ -e "${PWD}/${src}" ]
		949	then
		950	src="${PWD}/${src}"
		951	elif [ -e "${src}" ]
		952	then
		953	src="${src}"
		954	fi
		955	fi
		956	[ ! -e "${src}" ] && die "Could not find requested archive ${src}"
		957	echo "${src}"
		958	}
		959
		960	# Unpack those pesky pdv generated files ...
		961	# They're self-unpacking programs with the binary package stuffed in
		962	# the middle of the archive. Valve seems to use it a lot ... too bad
		963	# it seems to like to segfault a lot :(. So lets take it apart ourselves.
		964	#
		965	# Usage: unpack_pdv [file to unpack] [size of off_t]
		966	# - you have to specify the off_t size ... i have no idea how to extract that
		967	# information out of the binary executable myself. basically you pass in
		968	# the size of the off_t type (in bytes) on the machine that built the pdv
		969	# archive. one way to determine this is by running the following commands:
		970	# strings <pdv archive> \| grep lseek
		971	# strace -elseek <pdv archive>
		972	# basically look for the first lseek command (we do the strings/grep because
		973	# sometimes the function call is _llseek or something) and steal the 2nd
		974	# parameter. here is an example:
		975	# root@vapier 0 pdv_unpack # strings hldsupdatetool.bin \| grep lseek
		976	# lseek
		977	# root@vapier 0 pdv_unpack # strace -elseek ./hldsupdatetool.bin
		978	# lseek(3, -4, SEEK_END) = 2981250
		979	# thus we would pass in the value of '4' as the second parameter.
		980	unpack_pdv() {
		981	local src="`find_unpackable_file $1`"
		982	local sizeoff_t="$2"
		983
		984	[ -z "${sizeoff_t}" ] && die "No idea what off_t size was used for this pdv :("
		985
		986	local shrtsrc="`basename ${src}`"
		987	echo ">>> Unpacking ${shrtsrc} to ${PWD}"
		988	local metaskip=`tail -c ${sizeoff_t} ${src} \| hexdump -e \"%i\"`
		989	local tailskip=`tail -c $((${sizeoff_t}*2)) ${src} \| head -c ${sizeoff_t} \| hexdump -e \"%i\"`
		990
		991	# grab metadata for debug reasons
		992	local metafile="$(emktemp)"
		993	tail -c +$((${metaskip}+1)) ${src} > ${metafile}
		994
		995	# rip out the final file name from the metadata
		996	local datafile="`tail -c +$((${metaskip}+1)) ${src} \| strings \| head -n 1`"
		997	datafile="`basename ${datafile}`"
		998
		999	# now lets uncompress/untar the file if need be
		1000	local tmpfile="$(emktemp)"
		1001	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \| head -c 512 > ${tmpfile}
		1002
		1003	local iscompressed="`file -b ${tmpfile}`"
		1004	if [ "${iscompressed:0:8}" == "compress" ] ; then
		1005	iscompressed=1
		1006	mv ${tmpfile}{,.Z}
		1007	gunzip ${tmpfile}
		1008	else
		1009	iscompressed=0
		1010	fi
		1011	local istar="`file -b ${tmpfile}`"
		1012	if [ "${istar:0:9}" == "POSIX tar" ] ; then
		1013	istar=1
		1014	else
		1015	istar=0
		1016	fi
		1017
		1018	#for some reason gzip dies with this ... dd cant provide buffer fast enough ?
		1019	#dd if=${src} ibs=${metaskip} count=1 \
		1020	# \| dd ibs=${tailskip} skip=1 \
		1021	# \| gzip -dc \
		1022	# > ${datafile}
		1023	if [ ${iscompressed} -eq 1 ] ; then
		1024	if [ ${istar} -eq 1 ] ; then
		1025	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
		1026	\| head -c $((${metaskip}-${tailskip})) \
		1027	\| tar -xzf -
762	else	1028	else
763	die "Couldn't find $x"	1029	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
		1030	\| head -c $((${metaskip}-${tailskip})) \
		1031	\| gzip -dc \
		1032	> ${datafile}
		1033	fi
		1034	else
		1035	if [ ${istar} -eq 1 ] ; then
		1036	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
		1037	\| head -c $((${metaskip}-${tailskip})) \
		1038	\| tar --no-same-owner -xf -
		1039	else
		1040	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
		1041	\| head -c $((${metaskip}-${tailskip})) \
		1042	> ${datafile}
		1043	fi
764	fi	1044	fi
765	done	1045	true
766		1046	#[ -s "${datafile}" ] \|\| die "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"
767	debug-print "$FUNCNAME: final list of patches: $list"	1047	#assert "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"
768
769	for x in $list; do
770	debug-print "$FUNCNAME: processing $x"
771	# deal with compressed files. /usr/bin/file is in the system profile, or should be.
772	case "`/usr/bin/file -b $x`" in
773	gzip) patchfile="${T}/current.patch"; ungzip -c "$x" > "${patchfile}";;
774	bzip2) patchfile="${T}/current.patch"; bunzip2 -c "$x" > "${patchfile}";;
775	text) patchfile="$x";;
776	*) die "Could not determine filetype of patch $x";;
777	esac
778	debug-print "$FUNCNAME: patchfile=$patchfile"
779
780	# determine patchlevel. supports p0 and higher with either $S or $WORKDIR as base.
781	target="`/bin/grep -m 1 '^+++ ' $patchfile`"
782	debug-print "$FUNCNAME: raw target=$target"
783	# strip target down to the path/filename, remove leading +++
784	target="${target/+++ }"; target="${target%% *}"
785	# duplicate slashes are discarded by patch wrt the patchlevel. therefore we need
786	# to discard them as well to calculate the correct patchlevel.
787	target="${target//\/\//\/}"
788	debug-print "$FUNCNAME: stripped target=$target"
789
790	# look for target
791	for basedir in "$S" "$WORKDIR" "${PWD}"; do
792	debug-print "$FUNCNAME: looking in basedir=$basedir"
793	cd "$basedir"
794
795	# try stripping leading directories
796	target2="$target"
797	plevel=0
798	debug-print "$FUNCNAME: trying target2=$target2, plevel=$plevel"
799	while [ ! -f "$target2" ]; do
800	target2="${target2#*/}" # removes piece of target2 upto the first occurence of /
801	plevel=plevel+1
802	debug-print "$FUNCNAME: trying target2=$target2, plevel=$plevel"
803	[ "$target2" == "${target2/\/}" ] && break
804	done
805	test -f "$target2" && break
806
807	# try stripping filename - needed to support patches creating new files
808	target2="${target%/*}"
809	plevel=0
810	debug-print "$FUNCNAME: trying target2=$target2, plevel=$plevel"
811	while [ ! -d "$target2" ]; do
812	target2="${target2#*/}" # removes piece of target2 upto the first occurence of /
813	plevel=plevel+1
814	debug-print "$FUNCNAME: trying target2=$target2, plevel=$plevel"
815	[ "$target2" == "${target2/\/}" ] && break
816	done
817	test -d "$target2" && break
818
819	done
820
821	test -f "${basedir}/${target2}" \|\| test -d "${basedir}/${target2}" \|\| die "Could not determine patchlevel for $x"
822	debug-print "$FUNCNAME: determined plevel=$plevel"
823	# do the patching
824	ebegin "Applying patch ${x##*/}..."
825	/usr/bin/patch -p$plevel < "$patchfile" > /dev/null \|\| die "Failed to apply patch $x"
826	eend $?
827
828	done
829
830	}	1048	}
831		1049
832	# Unpack those pesky makeself generated files ...	1050	# Unpack those pesky makeself generated files ...
833	# They're shell scripts with the binary package tagged onto	1051	# They're shell scripts with the binary package tagged onto
834	# the end of the archive. Loki utilized the format as does	1052	# the end of the archive. Loki utilized the format as does
835	# many other game companies.	1053	# many other game companies.
836	#	1054	#
837	# Usage: unpack_makeself [file to unpack] [offset]	1055	# Usage: unpack_makeself [file to unpack] [offset] [tail\|dd]
838	# - If the file is not specified then unpack will utilize ${A}.	1056	# - If the file is not specified then unpack will utilize ${A}.
839	# - If the offset is not specified then we will attempt to extract	1057	# - If the offset is not specified then we will attempt to extract
840	# the proper offset from the script itself.	1058	# the proper offset from the script itself.
841	unpack_makeself() {	1059	unpack_makeself() {
842	local src=$1	1060	local src="$(find_unpackable_file "$1")"
843	local skip=$2	1061	local skip="$2"
		1062	local exe="$3"
844		1063
845	[ -z "${src}" ] && src=${A}
846	[ -e ./${src} ] \
847	&& src=${PWD}/${src} \
848	\|\| src=${DISTDIR}/${src}
849	local shrtsrc=`basename ${src}`	1064	local shrtsrc="$(basename "${src}")"
850	echo ">>> Unpacking ${shrtsrc} to ${PWD}"	1065	echo ">>> Unpacking ${shrtsrc} to ${PWD}"
851	if [ -z "${skip}" ] ; then	1066	if [ -z "${skip}" ]
		1067	then
852	local ver="`grep -a '#.*Makeself' ${src} \| awk '{print $NF}'`"	1068	local ver="`grep -a '#.*Makeself' ${src} \| awk '{print $NF}'`"
853	local skip=0	1069	local skip=0
		1070	exe=tail
854	case ${ver} in	1071	case ${ver} in
855	1.5.*) # tested 1.5.{3,4,5} ... guessing 1.5.x series is same	1072	1.5.*) # tested 1.5.{3,4,5} ... guessing 1.5.x series is same
856	skip=`grep -a ^skip= ${src} \| cut -d= -f2`	1073	skip=$(grep -a ^skip= "${src}" \| cut -d= -f2)
857	;;	1074	;;
858	2.0\|2.0.1)	1075	2.0\|2.0.1)
859	skip=`grep -a ^$'\t'tail ${src} \| awk '{print $2}' \| cut -b2-`	1076	skip=$(grep -a ^$'\t'tail "${src}" \| awk '{print $2}' \| cut -b2-)
860	;;	1077	;;
861	2.1.1)	1078	2.1.1)
862	skip=`grep -a ^offset= ${src} \| awk '{print $2}' \| cut -b2-`	1079	skip=$(grep -a ^offset= "${src}" \| awk '{print $2}' \| cut -b2-)
863	let skip="skip + 1"	1080	let skip="skip + 1"
		1081	;;
		1082	2.1.2)
		1083	skip=$(grep -a ^offset= "${src}" \| awk '{print $3}' \| head -n 1)
		1084	let skip="skip + 1"
		1085	;;
		1086	2.1.3)
		1087	skip=`grep -a ^offset= "${src}" \| awk '{print $3}'`
		1088	let skip="skip + 1"
		1089	;;
		1090	2.1.4)
		1091	skip=$(grep -a offset=.head.wc "${src}" \| awk '{print $3}' \| head -n 1)
		1092	skip=$(head -n ${skip} "${src}" \| wc -c)
		1093	exe="dd"
864	;;	1094	;;
865	*)	1095	*)
866	eerror "I'm sorry, but I was unable to support the Makeself file."	1096	eerror "I'm sorry, but I was unable to support the Makeself file."
867	eerror "The version I detected was '${ver}'."	1097	eerror "The version I detected was '${ver}'."
868	eerror "Please file a bug about the file ${shrtsrc} at"	1098	eerror "Please file a bug about the file ${shrtsrc} at"
…		…
870	die "makeself version '${ver}' not supported"	1100	die "makeself version '${ver}' not supported"
871	;;	1101	;;
872	esac	1102	esac
873	debug-print "Detected Makeself version ${ver} ... using ${skip} as offset"	1103	debug-print "Detected Makeself version ${ver} ... using ${skip} as offset"
874	fi	1104	fi
		1105	case ${exe} in
		1106	tail) exe="tail -n +${skip} '${src}'";;
		1107	dd) exe="dd ibs=${skip} skip=1 obs=1024 conv=sync if='${src}'";;
		1108	*) die "makeself cant handle exe '${exe}'"
		1109	esac
875		1110
876	# we do this because otherwise a failure in gzip will cause 0 bytes to be sent	1111	# lets grab the first few bytes of the file to figure out what kind of archive it is
877	# to tar which will make tar not extract anything and exit with 0	1112	local tmpfile="$(emktemp)"
878	local out="`tail +${skip} ${src} \| gzip -cd \| tar -x --no-same-owner -v -f -`"	1113	eval ${exe} 2>/dev/null \| head -c 512 > "${tmpfile}"
		1114	local filetype="$(file -b "${tmpfile}")"
		1115	case ${filetype} in
		1116	*tar\ archive)
		1117	eval ${exe} \| tar --no-same-owner -xf -
		1118	;;
		1119	bzip2*)
		1120	eval ${exe} \| bzip2 -dc \| tar --no-same-owner -xf -
		1121	;;
		1122	gzip*)
		1123	eval ${exe} \| tar --no-same-owner -xzf -
		1124	;;
		1125	compress*)
		1126	eval ${exe} \| gunzip \| tar --no-same-owner -xf -
		1127	;;
		1128	*)
		1129	eerror "Unknown filetype \"${filetype}\" ?"
		1130	false
		1131	;;
		1132	esac
879	[ -z "${out}" ] && die "failure unpacking makeself ${shrtsrc} ('${ver}' +${skip})"	1133	assert "failure unpacking (${filetype}) makeself ${shrtsrc} ('${ver}' +${skip})"
880	}	1134	}
		1135
		1136	# Display a license for user to accept.
		1137	#
		1138	# Usage: check_license [license]
		1139	# - If the file is not specified then ${LICENSE} is used.
		1140	check_license() {
		1141	local lic=$1
		1142	if [ -z "${lic}" ] ; then
		1143	lic="${PORTDIR}/licenses/${LICENSE}"
		1144	else
		1145	if [ -e "${PORTDIR}/licenses/${src}" ] ; then
		1146	lic="${PORTDIR}/licenses/${src}"
		1147	elif [ -e "${PWD}/${src}" ] ; then
		1148	lic="${PWD}/${src}"
		1149	elif [ -e "${src}" ] ; then
		1150	lic="${src}"
		1151	fi
		1152	fi
		1153	[ ! -f "${lic}" ] && die "Could not find requested license ${src}"
		1154	local l="`basename ${lic}`"
		1155
		1156	# here is where we check for the licenses the user already
		1157	# accepted ... if we don't find a match, we make the user accept
		1158	local shopts=$-
		1159	local alic
		1160	set -o noglob #so that bash doesn't expand "*"
		1161	for alic in ${ACCEPT_LICENSE} ; do
		1162	if [[ ${alic} == * \|\| ${alic} == ${l} ]]; then
		1163	set +o noglob; set -${shopts} #reset old shell opts
		1164	return 0
		1165	fi
		1166	done
		1167	set +o noglob; set -$shopts #reset old shell opts
		1168
		1169	local licmsg="$(emktemp)"
		1170	cat << EOF > ${licmsg}
		1171	**********************************************************
		1172	The following license outlines the terms of use of this
		1173	package. You MUST accept this license for installation to
		1174	continue. When you are done viewing, hit 'q'. If you
		1175	CTRL+C out of this, the install will not run!
		1176	**********************************************************
		1177
		1178	EOF
		1179	cat ${lic} >> ${licmsg}
		1180	${PAGER:-less} ${licmsg} \|\| die "Could not execute pager (${PAGER}) to accept ${lic}"
		1181	einfon "Do you accept the terms of this license (${l})? [yes/no] "
		1182	read alic
		1183	case ${alic} in
		1184	yes\|Yes\|y\|Y)
		1185	return 0
		1186	;;
		1187	*)
		1188	echo;echo;echo
		1189	eerror "You MUST accept the license to continue! Exiting!"
		1190	die "Failed to accept license"
		1191	;;
		1192	esac
		1193	}
		1194
		1195	# Aquire cd(s) for those lovely cd-based emerges. Yes, this violates
		1196	# the whole 'non-interactive' policy, but damnit I want CD support !
		1197	#
		1198	# with these cdrom functions we handle all the user interaction and
		1199	# standardize everything. all you have to do is call cdrom_get_cds()
		1200	# and when the function returns, you can assume that the cd has been
		1201	# found at CDROM_ROOT.
		1202	#
		1203	# normally the cdrom functions will refer to the cds as 'cd #1', 'cd #2',
		1204	# etc... if you want to give the cds better names, then just export
		1205	# the CDROM_NAME_X variables before calling cdrom_get_cds().
		1206	#
		1207	# for those multi cd ebuilds, see the cdrom_load_next_cd() below.
		1208	#
		1209	# Usage: cdrom_get_cds <file on cd1> [file on cd2] [file on cd3] [...]
		1210	# - this will attempt to locate a cd based upon a file that is on
		1211	# the cd ... the more files you give this function, the more cds
		1212	# the cdrom functions will handle
		1213	cdrom_get_cds() {
		1214	# first we figure out how many cds we're dealing with by
		1215	# the # of files they gave us
		1216	local cdcnt=0
		1217	local f=
		1218	for f in "$@" ; do
		1219	cdcnt=$((cdcnt + 1))
		1220	export CDROM_CHECK_${cdcnt}="$f"
		1221	done
		1222	export CDROM_TOTAL_CDS=${cdcnt}
		1223	export CDROM_CURRENT_CD=1
		1224
		1225	# now we see if the user gave use CD_ROOT ...
		1226	# if they did, let's just believe them that it's correct
		1227	if [[ ! -z ${CD_ROOT} ]] ; then
		1228	export CDROM_ROOT=${CD_ROOT}
		1229	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
		1230	return
		1231	fi
		1232	# do the same for CD_ROOT_X
		1233	if [[ ! -z ${CD_ROOT_1} ]] ; then
		1234	local var=
		1235	cdcnt=0
		1236	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
		1237	cdcnt=$((cdcnt + 1))
		1238	var="CD_ROOT_${cdcnt}"
		1239	if [[ -z ${!var} ]] ; then
		1240	eerror "You must either use just the CD_ROOT"
		1241	eerror "or specify ALL the CD_ROOT_X variables."
		1242	eerror "In this case, you will need ${CDROM_TOTAL_CDS} CD_ROOT_X variables."
		1243	die "could not locate CD_ROOT_${cdcnt}"
		1244	fi
		1245	export CDROM_ROOTS_${cdcnt}="${!var}"
		1246	done
		1247	export CDROM_ROOT=${CDROM_ROOTS_1}
		1248	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
		1249	return
		1250	fi
		1251
		1252	if [[ ${CDROM_TOTAL_CDS} -eq 1 ]] ; then
		1253	einfon "This ebuild will need the "
		1254	if [[ -z ${CDROM_NAME} ]] ; then
		1255	echo "cdrom for ${PN}."
		1256	else
		1257	echo "${CDROM_NAME}."
		1258	fi
		1259	echo
		1260	einfo "If you do not have the CD, but have the data files"
		1261	einfo "mounted somewhere on your filesystem, just export"
		1262	einfo "the variable CD_ROOT so that it points to the"
		1263	einfo "directory containing the files."
		1264	echo
		1265	einfo "For example:"
		1266	einfo "export CD_ROOT=/mnt/cdrom"
		1267	echo
		1268	else
		1269	einfo "This package will need access to ${CDROM_TOTAL_CDS} cds."
		1270	cdcnt=0
		1271	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
		1272	cdcnt=$((cdcnt + 1))
		1273	var="CDROM_NAME_${cdcnt}"
		1274	[[ ! -z ${!var} ]] && einfo " CD ${cdcnt}: ${!var}"
		1275	done
		1276	echo
		1277	einfo "If you do not have the CDs, but have the data files"
		1278	einfo "mounted somewhere on your filesystem, just export"
		1279	einfo "the following variables so they point to the right place:"
		1280	einfon ""
		1281	cdcnt=0
		1282	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
		1283	cdcnt=$((cdcnt + 1))
		1284	echo -n " CD_ROOT_${cdcnt}"
		1285	done
		1286	echo
		1287	einfo "Or, if you have all the files in the same place, or"
		1288	einfo "you only have one cdrom, you can export CD_ROOT"
		1289	einfo "and that place will be used as the same data source"
		1290	einfo "for all the CDs."
		1291	echo
		1292	einfo "For example:"
		1293	einfo "export CD_ROOT_1=/mnt/cdrom"
		1294	echo
		1295	fi
		1296	export CDROM_CURRENT_CD=0
		1297	cdrom_load_next_cd
		1298	}
		1299
		1300	# this is only used when you need access to more than one cd.
		1301	# when you have finished using the first cd, just call this function.
		1302	# when it returns, CDROM_ROOT will be pointing to the second cd.
		1303	# remember, you can only go forward in the cd chain, you can't go back.
		1304	cdrom_load_next_cd() {
		1305	export CDROM_CURRENT_CD=$((CDROM_CURRENT_CD + 1))
		1306	local var=
		1307
		1308	if [[ ! -z ${CD_ROOT} ]] ; then
		1309	einfo "Using same root as before for CD #${CDROM_CURRENT_CD}"
		1310	return
		1311	fi
		1312
		1313	unset CDROM_ROOT
		1314	var=CDROM_ROOTS_${CDROM_CURRENT_CD}
		1315	if [[ -z ${!var} ]] ; then
		1316	var="CDROM_CHECK_${CDROM_CURRENT_CD}"
		1317	cdrom_locate_file_on_cd ${!var}
		1318	else
		1319	export CDROM_ROOT=${!var}
		1320	fi
		1321
		1322	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
		1323	}
		1324
		1325	# this is used internally by the cdrom_get_cds() and cdrom_load_next_cd()
		1326	# functions. this should never be called from an ebuild.
		1327	# all it does is try to locate a give file on a cd ... if the cd isn't
		1328	# found, then a message asking for the user to insert the cdrom will be
		1329	# displayed and we'll hang out here until:
		1330	# (1) the file is found on a mounted cdrom
		1331	# (2) the user hits CTRL+C
		1332	cdrom_locate_file_on_cd() {
		1333	while [[ -z ${CDROM_ROOT} ]] ; do
		1334	local dir="$(dirname ${@})"
		1335	local file="$(basename ${@})"
		1336	local mline=""
		1337	local showedmsg=0
		1338
		1339	for mline in $(mount \| egrep -e '(iso\|cdrom)' \| awk '{print $3}') ; do
		1340	[[ -d ${mline}/${dir} ]] \|\| continue
		1341	[[ ! -z $(find ${mline}/${dir} -maxdepth 1 -iname ${file}) ]] \
		1342	&& export CDROM_ROOT=${mline}
		1343	done
		1344
		1345	if [[ -z ${CDROM_ROOT} ]] ; then
		1346	echo
		1347	if [[ ${showedmsg} -eq 0 ]] ; then
		1348	if [[ ${CDROM_TOTAL_CDS} -eq 1 ]] ; then
		1349	if [[ -z ${CDROM_NAME} ]] ; then
		1350	einfo "Please insert the cdrom for ${PN} now !"
		1351	else
		1352	einfo "Please insert the ${CDROM_NAME} cdrom now !"
		1353	fi
		1354	else
		1355	if [[ -z ${CDROM_NAME_1} ]] ; then
		1356	einfo "Please insert cd #${CDROM_CURRENT_CD} for ${PN} now !"
		1357	else
		1358	local var="CDROM_NAME_${CDROM_CURRENT_CD}"
		1359	einfo "Please insert+mount the ${!var} cdrom now !"
		1360	fi
		1361	fi
		1362	showedmsg=1
		1363	fi
		1364	einfo "Press return to scan for the cd again"
		1365	einfo "or hit CTRL+C to abort the emerge."
		1366	read
		1367	fi
		1368	done
		1369	}
		1370
		1371	# Make sure that LINGUAS only contains languages that
		1372	# a package can support
		1373	#
		1374	# usage: strip-linguas <allow LINGUAS>
		1375	# strip-linguas -i <directories of .po files>
		1376	# strip-linguas -u <directories of .po files>
		1377	#
		1378	# The first form allows you to specify a list of LINGUAS.
		1379	# The -i builds a list of po files found in all the
		1380	# directories and uses the intersection of the lists.
		1381	# The -u builds a list of po files found in all the
		1382	# directories and uses the union of the lists.
		1383	strip-linguas() {
		1384	local ls newls
		1385	if [[ $1 == "-i" ]] \|\| [[ $1 == "-u" ]] ; then
		1386	local op=$1; shift
		1387	ls=" $(find "$1" -name '*.po' -printf '%f ') "; shift
		1388	local d f
		1389	for d in "$@" ; do
		1390	if [[ ${op} == "-u" ]] ; then
		1391	newls=${ls}
		1392	else
		1393	newls=""
		1394	fi
		1395	for f in $(find "$d" -name '*.po' -printf '%f ') ; do
		1396	if [[ ${op} == "-i" ]] ; then
		1397	[[ ${ls/ ${f} /} != ${ls} ]] && newls="${newls} ${f}"
		1398	else
		1399	[[ ${ls/ ${f} /} == ${ls} ]] && newls="${newls} ${f}"
		1400	fi
		1401	done
		1402	ls=${newls}
		1403	done
		1404	ls=${ls//.po}
		1405	else
		1406	ls=$@
		1407	fi
		1408
		1409	ls=" ${ls} "
		1410	newls=""
		1411	for f in ${LINGUAS} ; do
		1412	if [[ ${ls/ ${f} /} != ${ls} ]] ; then
		1413	newls="${newls} ${f}"
		1414	else
		1415	ewarn "Sorry, but ${PN} does not support the ${f} LINGUA"
		1416	fi
		1417	done
		1418	if [[ -z ${newls} ]] ; then
		1419	export LINGUAS=""
		1420	else
		1421	export LINGUAS=${newls:1}
		1422	fi
		1423	}
		1424
		1425	# moved from kernel.eclass since they are generally useful outside of
		1426	# kernel.eclass -iggy (20041002)
		1427
		1428	# the following functions are useful in kernel module ebuilds, etc.
		1429	# for an example see ivtv or drbd ebuilds
		1430
		1431	# set's ARCH to match what the kernel expects
		1432	set_arch_to_kernel() {
		1433	i=10
		1434	while ((i--)) ; do
		1435	ewarn "PLEASE UPDATE TO YOUR PACKAGE TO USE linux-info.eclass"
		1436	done
		1437	export EUTILS_ECLASS_PORTAGE_ARCH="${ARCH}"
		1438	case ${ARCH} in
		1439	x86) export ARCH="i386";;
		1440	amd64) export ARCH="x86_64";;
		1441	hppa) export ARCH="parisc";;
		1442	mips) export ARCH="mips";;
		1443	sparc) export ARCH="$(tc-arch-kernel)";; # Yeah this is ugly, but it's even WORSE if you don't do this. linux-info.eclass's set_arch_to_kernel is fixed, but won't get used over this one!
		1444	*) export ARCH="${ARCH}";;
		1445	esac
		1446	}
		1447
		1448	# set's ARCH back to what portage expects
		1449	set_arch_to_portage() {
		1450	i=10
		1451	while ((i--)) ; do
		1452	ewarn "PLEASE UPDATE TO YOUR PACKAGE TO USE linux-info.eclass"
		1453	done
		1454	export ARCH="${EUTILS_ECLASS_PORTAGE_ARCH}"
		1455	}
		1456
		1457	# Jeremy Huddleston <eradicator@gentoo.org>:
		1458	# preserve_old_lib /path/to/libblah.so.0
		1459	# preserve_old_lib_notify /path/to/libblah.so.0
		1460	#
		1461	# These functions are useful when a lib in your package changes --soname. Such
		1462	# an example might be from libogg.so.0 to libogg.so.1. Removing libogg.so.0
		1463	# would break packages that link against it. Most people get around this
		1464	# by using the portage SLOT mechanism, but that is not always a relevant
		1465	# solution, so instead you can add the following to your ebuilds:
		1466	#
		1467	# src_install() {
		1468	# ...
		1469	# preserve_old_lib /usr/$(get_libdir)/libogg.so.0
		1470	# ...
		1471	# }
		1472	#
		1473	# pkg_postinst() {
		1474	# ...
		1475	# preserve_old_lib_notify /usr/$(get_libdir)/libogg.so.0
		1476	# ...
		1477	# }
		1478
		1479	preserve_old_lib() {
		1480	LIB=$1
		1481
		1482	if [ -n "${LIB}" -a -f "${ROOT}${LIB}" ]; then
		1483	SONAME=`basename ${LIB}`
		1484	DIRNAME=`dirname ${LIB}`
		1485
		1486	dodir ${DIRNAME}
		1487	cp ${ROOT}${LIB} ${D}${DIRNAME}
		1488	touch ${D}${LIB}
		1489	fi
		1490	}
		1491
		1492	preserve_old_lib_notify() {
		1493	LIB=$1
		1494
		1495	if [ -n "${LIB}" -a -f "${ROOT}${LIB}" ]; then
		1496	SONAME=`basename ${LIB}`
		1497
		1498	einfo "An old version of an installed library was detected on your system."
		1499	einfo "In order to avoid breaking packages that link against is, this older version"
		1500	einfo "is not being removed. In order to make full use of this newer version,"
		1501	einfo "you will need to execute the following command:"
		1502	einfo " revdep-rebuild --soname ${SONAME}"
		1503	einfo
		1504	einfo "After doing that, you can safely remove ${LIB}"
		1505	einfo "Note: 'emerge gentoolkit' to get revdep-rebuild"
		1506	fi
		1507	}
		1508
		1509	# Hack for people to figure out if a package was built with
		1510	# certain USE flags
		1511	#
		1512	# Usage: built_with_use [-a\|-o] <DEPEND ATOM> <List of USE flags>
		1513	# ex: built_with_use xchat gtk2
		1514	#
		1515	# Flags: -a all USE flags should be utilized
		1516	# -o at least one USE flag should be utilized
		1517	# Note: the default flag is '-a'
		1518	built_with_use() {
		1519	local opt=$1
		1520	[[ ${opt:0:1} = "-" ]] && shift \|\| opt="-a"
		1521
		1522	local PKG=$(best_version $1)
		1523	shift
		1524
		1525	local USEFILE="${ROOT}/var/db/pkg/${PKG}/USE"
		1526	[[ ! -e ${USEFILE} ]] && return 1
		1527
		1528	local USE_BUILT=$(<${USEFILE})
		1529	while [[ $# -gt 0 ]] ; do
		1530	if [[ ${opt} = "-o" ]] ; then
		1531	has $1 ${USE_BUILT} && return 0
		1532	else
		1533	has $1 ${USE_BUILT} \|\| return 1
		1534	fi
		1535	shift
		1536	done
		1537	[[ ${opt} = "-a" ]]
		1538	}
		1539
		1540	# Many configure scripts wrongly bail when a C++ compiler
		1541	# could not be detected. #73450
		1542	epunt_cxx() {
		1543	local dir=$1
		1544	[[ -z ${dir} ]] && dir=${S}
		1545	ebegin "Removing useless C++ checks"
		1546	local f
		1547	for f in $(find ${dir} -name configure) ; do
		1548	patch -p0 "${f}" "${PORTDIR}/eclass/ELT-patches/nocxx/nocxx.patch" > /dev/null
		1549	done
		1550	eend 0
		1551	}
		1552
		1553	# dopamd <file> [more files]
		1554	#
		1555	# Install pam auth config file in /etc/pam.d
		1556	dopamd() {
		1557	[[ -z $1 ]] && die "dopamd requires at least one argument"
		1558
		1559	use pam \|\| return 0
		1560
		1561	INSDESTTREE=/etc/pam.d \
		1562	doins "$@" \|\| die "failed to install $@"
		1563	}
		1564	# newpamd <old name> <new name>
		1565	#
		1566	# Install pam file <old name> as <new name> in /etc/pam.d
		1567	newpamd() {
		1568	[[ $# -ne 2 ]] && die "newpamd requires two arguements"
		1569
		1570	use pam \|\| return 0
		1571
		1572	INSDESTTREE=/etc/pam.d \
		1573	newins "$1" "$2" \|\| die "failed to install $1 as $2"
		1574	}
		1575
		1576	# make a wrapper script ...
		1577	# NOTE: this was originally games_make_wrapper, but I noticed other places where
		1578	# this could be used, so I have moved it here and made it not games-specific
		1579	# -- wolf31o2
		1580	# $1 == wrapper name
		1581	# $2 == binary to run
		1582	# $3 == directory to chdir before running binary
		1583	# $4 == extra LD_LIBRARY_PATH's (make it : delimited)
		1584	# $5 == path for wrapper
		1585	make_wrapper() {
		1586	local wrapper=$1 bin=$2 chdir=$3 libdir=$4 path=$5
		1587	local tmpwrapper=$(emktemp)
		1588	cat << EOF > "${tmpwrapper}"
		1589	#!/bin/sh
		1590	cd "${chdir}"
		1591	export LD_LIBRARY_PATH="\${LD_LIBRARY_PATH}:${libdir}"
		1592	exec ${bin} "\$@"
		1593	EOF
		1594	chmod go+rx "${tmpwrapper}"
		1595	if [ -n "${5}" ]
		1596	then
		1597	exeinto ${5}
		1598	newexe "${tmpwrapper}" "${wrapper}"
		1599	else
		1600	newbin "${tmpwrapper}" "${wrapper}"
		1601	fi
		1602	}

 Legend:



Removed from v.1.41
 


changed lines


 
Added in v.1.182
 Legend:



Removed from v.1.41
 


changed lines


 
Added in v.1.182
-Removed from v.1.41
+Added in v.1.182

	ViewVC Help
Powered by ViewVC 1.1.13