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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.284
 


changed lines


 
Added in v.1.373
 Legend:



Removed from v.1.284
 


changed lines


 
Added in v.1.373
-Removed from v.1.284
+Added in v.1.373

	ViewVC Help
Powered by ViewVC 1.1.20