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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.70
 


changed lines


 
Added in v.1.294
 Legend:



Removed from v.1.70
 


changed lines


 
Added in v.1.294
-Removed from v.1.70
+Added in v.1.294

	ViewVC Help
Powered by ViewVC 1.1.20