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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.67
 


changed lines


 
Added in v.1.318
 Legend:



Removed from v.1.67
 


changed lines


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

	ViewVC Help
Powered by ViewVC 1.1.13