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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.41
 


changed lines


 
Added in v.1.224
 Legend:



Removed from v.1.41
 


changed lines


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

	ViewVC Help
Powered by ViewVC 1.1.13