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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.41
 


changed lines


 
Added in v.1.307
 Legend:



Removed from v.1.41
 


changed lines


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

	ViewVC Help
Powered by ViewVC 1.1.20