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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.1.1.1
 


changed lines


 
Added in v.1.67
 Legend:



Removed from v.1.1.1.1
 


changed lines


 
Added in v.1.67
-Removed from v.1.1.1.1
+Added in v.1.67

	ViewVC Help
Powered by ViewVC 1.1.20