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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.76
 


changed lines


 
Added in v.1.305
 Legend:



Removed from v.1.76
 


changed lines


 
Added in v.1.305
-Removed from v.1.76
+Added in v.1.305

	ViewVC Help
Powered by ViewVC 1.1.13