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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.60
 


changed lines


 
Added in v.1.304
 Legend:



Removed from v.1.60
 


changed lines


 
Added in v.1.304
-Removed from v.1.60
+Added in v.1.304

	ViewVC Help
Powered by ViewVC 1.1.13