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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.45
 


changed lines


 
Added in v.1.231
 Legend:



Removed from v.1.45
 


changed lines


 
Added in v.1.231
-Removed from v.1.45
+Added in v.1.231

	ViewVC Help
Powered by ViewVC 1.1.20