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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.54
 


changed lines


 
Added in v.1.252
 Legend:



Removed from v.1.54
 


changed lines


 
Added in v.1.252
-Removed from v.1.54
+Added in v.1.252

	ViewVC Help
Powered by ViewVC 1.1.20