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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.60
 


changed lines


 
Added in v.1.376
 Legend:



Removed from v.1.60
 


changed lines


 
Added in v.1.376
-Removed from v.1.60
+Added in v.1.376

	ViewVC Help
Powered by ViewVC 1.1.20