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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.9
 


changed lines


 
Added in v.1.378
 Legend:



Removed from v.1.9
 


changed lines


 
Added in v.1.378
-Removed from v.1.9
+Added in v.1.378

	ViewVC Help
Powered by ViewVC 1.1.13