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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.41
 


changed lines


 
Added in v.1.191
 Legend:



Removed from v.1.41
 


changed lines


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

	ViewVC Help
Powered by ViewVC 1.1.20