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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

Revision 1.284		Revision 1.379
1	# Copyright 1999-2007 Gentoo Foundation	1	# Copyright 1999-2012 Gentoo Foundation
2	# Distributed under the terms of the GNU General Public License v2	2	# Distributed under the terms of the GNU General Public License v2
3	# $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.379 2012/01/31 06:44:00 ulm 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	inherit multilib portability	18	if [[ ${___ECLASS_ONCE_EUTILS} != "recur -_+^+_- spank" ]] ; then
		19	___ECLASS_ONCE_EUTILS="recur -_+^+_- spank"
		20
		21	inherit multilib cdrom 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 -s 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	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
		184	}
		185
		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.
53	EPATCH_SOURCE="${WORKDIR}/patch"	225	EPATCH_SOURCE="${WORKDIR}/patch"
54	# Default extension for patches	226	# @VARIABLE: EPATCH_SUFFIX
		227	# @DESCRIPTION:
		228	# Default extension for patches (do not prefix the period yourself).
55	EPATCH_SUFFIX="patch.bz2"	229	EPATCH_SUFFIX="patch.bz2"
		230	# @VARIABLE: EPATCH_OPTS
		231	# @DESCRIPTION:
56	# Default options for patch	232	# Default options for patch:
		233	# @CODE
57	# Set -g0 to keep RCS, ClearCase, Perforce and SCCS happy. Bug #24571	234	# -g0 - keep RCS, ClearCase, Perforce and SCCS happy #24571
58	# Set --no-backup-if-mismatch so we don't leave '.orig' files behind.	235	# --no-backup-if-mismatch - do not leave .orig files behind
59	# Set -E to automatically remove empty files.	236	# -E - automatically remove empty files
		237	# @CODE
60	EPATCH_OPTS="-g0 -E --no-backup-if-mismatch"	238	EPATCH_OPTS="-g0 -E --no-backup-if-mismatch"
		239	# @VARIABLE: EPATCH_EXCLUDE
		240	# @DESCRIPTION:
61	# 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,
62	# and not the full path ..	242	# and not the full path. Globs accepted.
63	EPATCH_EXCLUDE=""	243	EPATCH_EXCLUDE=""
		244	# @VARIABLE: EPATCH_SINGLE_MSG
		245	# @DESCRIPTION:
64	# Change the printed message for a single patch.	246	# Change the printed message for a single patch.
65	EPATCH_SINGLE_MSG=""	247	EPATCH_SINGLE_MSG=""
		248	# @VARIABLE: EPATCH_MULTI_MSG
		249	# @DESCRIPTION:
66	# Change the printed message for multiple patches.	250	# Change the printed message for multiple patches.
67	EPATCH_MULTI_MSG="Applying various patches (bugfixes/updates) ..."	251	EPATCH_MULTI_MSG="Applying various patches (bugfixes/updates) ..."
68	# Force applying bulk patches even if not following the style:	252	# @VARIABLE: EPATCH_FORCE
69	#	253	# @DESCRIPTION:
70	# ??_${ARCH}_foo.${EPATCH_SUFFIX}	254	# Only require patches to match EPATCH_SUFFIX rather than the extended
71	#	255	# arch naming style.
72	EPATCH_FORCE="no"	256	EPATCH_FORCE="no"
73		257
74	# This function is for bulk patching, or in theory for just one	258	# @FUNCTION: epatch
75	# 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.
76	#	266	#
77	# 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
78	# Currently all patches should be the same format.	268	# specified by EPATCH_SOURCE.
79	#	269	#
80	# You do not have to specify '-p' option to patch, as it will	270	# When processing directories, epatch will apply all patches that match:
81	# try with -p0 to -p5 until it succeed, or fail at -p5.	271	# @CODE
82	#	272	# 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}	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.
92	#	282	#
93	# For example:	283	# If EPATCH_SUFFIX is empty, then no period before it is implied when searching
		284	# for patches to apply.
94	#	285	#
95	# 01_all_misc-fix.patch.bz2	286	# 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() {	287	epatch() {
108	_epatch_draw_line() {	288	_epatch_draw_line() {
		289	# create a line of same length as input string
109	[[ -z $1 ]] && set "$(printf "%65s" '')"	290	[[ -z $1 ]] && set "$(printf "%65s" '')"
110	echo "${1//?/=}"	291	echo "${1//?/=}"
111	}	292	}
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		293
120	unset P4CONFIG P4PORT P4USER # keep perforce at bay #56402	294	unset P4CONFIG P4PORT P4USER # keep perforce at bay #56402
121		295
122	if [ "$#" -gt 1 ]	296	# Let the rest of the code process one user arg at a time --
123	then	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
124	local m=""	300	local m
125	for m in "$@" ; do	301	for m in "$@" ; do
126	epatch "${m}"	302	epatch "${m}"
127	done	303	done
128	return 0	304	return 0
129	fi	305	fi
130		306
131	if [ -n "$1" -a -f "$1" ]	307	local SINGLE_PATCH="no"
132	then	308	# no args means process ${EPATCH_SOURCE}
		309	[[ $# -eq 0 ]] && set -- "${EPATCH_SOURCE}"
		310
		311	if [[ -f $1 ]] ; then
133	SINGLE_PATCH="yes"	312	SINGLE_PATCH="yes"
134		313	set -- "$1"
135	local EPATCH_SOURCE="$1"	314	# Use the suffix from the single patch (localize it); the code
		315	# below will find the suffix for us
136	local EPATCH_SUFFIX="${1##*\.}"	316	local EPATCH_SUFFIX=$1
137		317
138	elif [ -n "$1" -a -d "$1" ]	318	elif [[ -d $1 ]] ; then
139	then	319	# 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 ...	320	set -- "$1"/*${EPATCH_SUFFIX:+."${EPATCH_SUFFIX}"}
141	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} ]]
142	then	369	then
143	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
144	else	395	else
145	local EPATCH_SOURCE="$1/*.${EPATCH_SUFFIX}"	396	einfo " ${patchname} ..."
146	fi	397	fi
147	else	398
148	if [ ! -d ${EPATCH_SOURCE} ] \|\| [ -n "$1" ]	399	# most of the time, there will only be one run per unique name,
149	then	400	# but if there are more, make sure we get unique log filenames
150	if [ -n "$1" -a "${EPATCH_SOURCE}" = "${WORKDIR}/patch" ]	401	local STDERR_TARGET="${T}/${patchname}.out"
151	then	402	if [[ -e ${STDERR_TARGET} ]] ; then
152	EPATCH_SOURCE="$1"	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
153	fi	421	fi
		422	else
		423	PATCH_TARGET=${x}
		424	fi
154		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} ***"
155	echo	448	echo
156	eerror "Cannot find \$EPATCH_SOURCE! Value for \$EPATCH_SOURCE is:"	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} )"
157	eerror	495	eerror
158	eerror " ${EPATCH_SOURCE}"	496	eerror "Include in your bugreport the contents of:"
159	eerror " ( ${EPATCH_SOURCE##*/} )"	497	eerror
		498	eerror " ${STDERR_TARGET}"
160	echo	499	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}!"	500	die "Failed Patch: ${patchname}!"
305	fi	501	fi
306		502
307	rm -f ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}	503	# if everything worked, delete the patch log
308		504	rm -f "${STDERR_TARGET}"
309	eend 0	505	eend 0
310	fi
311	done	506	done
312	if [ "${SINGLE_PATCH}" = "no" ]	507
313	then	508	[[ ${SINGLE_PATCH} == "no" ]] && einfo "Done with patching"
314	einfo "Done with patching"	509	: # everything worked
		510	}
		511
		512	# @FUNCTION: epatch_user
		513	# @USAGE:
		514	# @DESCRIPTION:
		515	# Applies user-provided patches to the source tree. The patches are
		516	# taken from /etc/portage/patches/<CATEGORY>/<PF\|P\|PN>/, where the first
		517	# of these three directories to exist will be the one to use, ignoring
		518	# any more general directories which might exist as well.
		519	#
		520	# User patches are intended for quick testing of patches without ebuild
		521	# modifications, as well as for permanent customizations a user might
		522	# desire. Obviously, there can be no official support for arbitrarily
		523	# patched ebuilds. So whenever a build log in a bug report mentions that
		524	# user patches were applied, the user should be asked to reproduce the
		525	# problem without these.
		526	#
		527	# Not all ebuilds do call this function, so placing patches in the
		528	# stated directory might or might not work, depending on the package and
		529	# the eclasses it inherits and uses. It is safe to call the function
		530	# repeatedly, so it is always possible to add a call at the ebuild
		531	# level. The first call is the time when the patches will be
		532	# applied.
		533	#
		534	# Ideally, this function should be called after gentoo-specific patches
		535	# have been applied, so that their code can be modified as well, but
		536	# before calls to e.g. eautoreconf, as the user patches might affect
		537	# autotool input files as well.
		538	epatch_user() {
		539	[[ $# -ne 0 ]] && die "epatch_user takes no options"
		540
		541	# Allow multiple calls to this function; ignore all but the first
		542	local applied="${T}/epatch_user.applied"
		543	[[ -e ${applied} ]] && return 2
		544
		545	# don't clobber any EPATCH vars that the parent might want
		546	local EPATCH_SOURCE check base=${PORTAGE_CONFIGROOT%/}/etc/portage/patches
		547	for check in ${CATEGORY}/{${P}-${PR},${P},${PN}}; do
		548	EPATCH_SOURCE=${base}/${CTARGET}/${check}
		549	[[ -r ${EPATCH_SOURCE} ]] \|\| EPATCH_SOURCE=${base}/${CHOST}/${check}
		550	[[ -r ${EPATCH_SOURCE} ]] \|\| EPATCH_SOURCE=${base}/${check}
		551	if [[ -d ${EPATCH_SOURCE} ]] ; then
		552	EPATCH_SOURCE=${EPATCH_SOURCE} \
		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
315	fi	559	fi
		560	done
		561	echo "none" > "${applied}"
		562	return 1
316	}	563	}
317		564
318	# @FUNCTION: emktemp	565	# @FUNCTION: emktemp
319	# @USAGE: [temp dir]	566	# @USAGE: [temp dir]
320	# @DESCRIPTION:	567	# @DESCRIPTION:
…		…
348	TMPDIR="${topdir}" mktemp -dt tmp.XXXXXXXXXX	595	TMPDIR="${topdir}" mktemp -dt tmp.XXXXXXXXXX
349	fi	596	fi
350	fi	597	fi
351	}	598	}
352		599
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	600	# @FUNCTION: edos2unix
715	# @USAGE: <file> [more files ...]	601	# @USAGE: <file> [more files ...]
716	# @DESCRIPTION:	602	# @DESCRIPTION:
717	# A handy replacement for dos2unix, recode, fixdos, etc... This allows you	603	# A handy replacement for dos2unix, recode, fixdos, etc... This allows you
718	# to remove all of these text utilities from DEPEND variables because this	604	# 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	605	# 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.	606	# they will all be changed from the DOS CRLF format to the UNIX LF format.
721	edos2unix() {	607	edos2unix() {
722	echo "$@" \| xargs sed -i 's/\r$//'	608	[[ $# -eq 0 ]] && return 0
		609	sed -i 's/\r$//' -- "$@" \|\| die
723	}	610	}
724		611
		612	# @FUNCTION: make_desktop_entry
		613	# @USAGE: make_desktop_entry(<command>, [name], [icon], [type], [fields])
		614	# @DESCRIPTION:
725	# Make a desktop file !	615	# Make a .desktop file.
726	# Great for making those icons in kde/gnome startmenu !
727	# Amaze your friends ! Get the women ! Join today !
728	#	616	#
729	# make_desktop_entry(<command>, [name], [icon], [type], [path])	617	# @CODE
730	#
731	# binary: what command does the app run with ?	618	# binary: what command does the app run with ?
732	# name: the name that will show up in the menu	619	# name: the name that will show up in the menu
733	# icon: give your little like a pretty little icon ...	620	# icon: give your little like a pretty little icon ...
734	# this can be relative (to /usr/share/pixmaps) or	621	# this can be relative (to /usr/share/pixmaps) or
735	# a full path to an icon	622	# a full path to an icon
736	# type: what kind of application is this ? for categories:	623	# type: what kind of application is this?
		624	# for categories:
737	# http://standards.freedesktop.org/menu-spec/latest/apa.html	625	# http://standards.freedesktop.org/menu-spec/latest/apa.html
738	# path: if your app needs to startup in a specific dir	626	# if unset, function tries to guess from package's category
		627	# fields: extra fields to append to the desktop file; a printf string
		628	# @CODE
739	make_desktop_entry() {	629	make_desktop_entry() {
740	[[ -z $1 ]] && eerror "make_desktop_entry: You must specify the executable" && return 1	630	[[ -z $1 ]] && die "make_desktop_entry: You must specify the executable"
741		631
742	local exec=${1}	632	local exec=${1}
743	local name=${2:-${PN}}	633	local name=${2:-${PN}}
744	local icon=${3:-${PN}.png}	634	local icon=${3:-${PN}}
745	local type=${4}	635	local type=${4}
746	local path=${5}	636	local fields=${5}
747		637
748	if [[ -z ${type} ]] ; then	638	if [[ -z ${type} ]] ; then
749	local catmaj=${CATEGORY%%-*}	639	local catmaj=${CATEGORY%%-*}
750	local catmin=${CATEGORY##*-}	640	local catmin=${CATEGORY##*-}
751	case ${catmaj} in	641	case ${catmaj} in
752	app)	642	app)
753	case ${catmin} in	643	case ${catmin} in
754	accessibility) type=Accessibility;;	644	accessibility) type=Accessibility;;
755	admin) type=System;;	645	admin) type=System;;
756	antivirus) type=System;;	646	antivirus) type=System;;
757	arch) type=Archiving;;	647	arch) type=Archiving;;
758	backup) type=Archiving;;	648	backup) type=Archiving;;
759	cdr) type=DiscBurning;;	649	cdr) type=DiscBurning;;
760	dicts) type=Dictionary;;	650	dicts) type=Dictionary;;
761	doc) type=Documentation;;	651	doc) type=Documentation;;
762	editors) type=TextEditor;;	652	editors) type=TextEditor;;
763	emacs) type=TextEditor;;	653	emacs) type=TextEditor;;
764	emulation) type=Emulator;;	654	emulation) type=Emulator;;
765	laptop) type=HardwareSettings;;	655	laptop) type=HardwareSettings;;
766	office) type=Office;;	656	office) type=Office;;
767	pda) type=PDA;;	657	pda) type=PDA;;
768	vim) type=TextEditor;;	658	vim) type=TextEditor;;
769	xemacs) type=TextEditor;;	659	xemacs) type=TextEditor;;
770	*) type=;;
771	esac	660	esac
772	;;	661	;;
773		662
774	dev)	663	dev)
775	type="Development"	664	type="Development"
776	;;	665	;;
777		666
778	games)	667	games)
779	case ${catmin} in	668	case ${catmin} in
780	action\|fps) type=ActionGame;;	669	action\|fps) type=ActionGame;;
781	arcade) type=ArcadeGame;;	670	arcade) type=ArcadeGame;;
782	board) type=BoardGame;;	671	board) type=BoardGame;;
783	emulation) type=Emulator;;	672	emulation) type=Emulator;;
784	kids) type=KidsGame;;	673	kids) type=KidsGame;;
785	puzzle) type=LogicGame;;	674	puzzle) type=LogicGame;;
786	roguelike) type=RolePlaying;;	675	roguelike) type=RolePlaying;;
787	rpg) type=RolePlaying;;	676	rpg) type=RolePlaying;;
788	simulation) type=Simulation;;	677	simulation) type=Simulation;;
789	sports) type=SportsGame;;	678	sports) type=SportsGame;;
790	strategy) type=StrategyGame;;	679	strategy) type=StrategyGame;;
791	*) type=;;
792	esac	680	esac
793	type="Game;${type}"	681	type="Game;${type}"
794	;;	682	;;
795		683
796	gnome)	684	gnome)
…		…
805	type="Network;Email"	693	type="Network;Email"
806	;;	694	;;
807		695
808	media)	696	media)
809	case ${catmin} in	697	case ${catmin} in
		698	gfx)
810	gfx) type=Graphics;;	699	type=Graphics
		700	;;
		701	*)
		702	case ${catmin} in
811	radio) type=Tuner;;	703	radio) type=Tuner;;
812	sound) type=Audio;;	704	sound) type=Audio;;
813	tv) type=TV;;	705	tv) type=TV;;
814	video) type=Video;;	706	video) type=Video;;
815	*) type=;;	707	esac
		708	type="AudioVideo;${type}"
		709	;;
816	esac	710	esac
817	type="AudioVideo;${type}"
818	;;	711	;;
819		712
820	net)	713	net)
821	case ${catmin} in	714	case ${catmin} in
822	dialup) type=Dialup;;	715	dialup) type=Dialup;;
823	ftp) type=FileTransfer;;	716	ftp) type=FileTransfer;;
824	im) type=InstantMessaging;;	717	im) type=InstantMessaging;;
825	irc) type=IRCClient;;	718	irc) type=IRCClient;;
826	mail) type=Email;;	719	mail) type=Email;;
827	news) type=News;;	720	news) type=News;;
828	nntp) type=News;;	721	nntp) type=News;;
829	p2p) type=FileTransfer;;	722	p2p) type=FileTransfer;;
830	*) type=;;	723	voip) type=Telephony;;
831	esac	724	esac
832	type="Network;${type}"	725	type="Network;${type}"
833	;;	726	;;
834		727
835	sci)	728	sci)
836	case ${catmin} in	729	case ${catmin} in
837	astro*) type=Astronomy;;	730	astro*) type=Astronomy;;
838	bio*) type=Biology;;	731	bio*) type=Biology;;
839	calc*) type=Calculator;;	732	calc*) type=Calculator;;
840	chem*) type=Chemistry;;	733	chem*) type=Chemistry;;
841	elec*) type=Electronics;;	734	elec*) type=Electronics;;
842	geo*) type=Geology;;	735	geo*) type=Geology;;
843	math*) type=Math;;	736	math*) type=Math;;
844	physics) type=Physics;;	737	physics) type=Physics;;
845	visual*) type=DataVisualization;;	738	visual*) type=DataVisualization;;
846	*) type=;;
847	esac	739	esac
848	type="Science;${type}"	740	type="Education;Science;${type}"
849	;;	741	;;
850		742
851	sys)	743	sys)
852	type="System"	744	type="System"
853	;;	745	;;
854		746
855	www)	747	www)
856	case ${catmin} in	748	case ${catmin} in
857	client) type=WebBrowser;;	749	client) type=WebBrowser;;
858	*) type=;;
859	esac	750	esac
860	type="Network"	751	type="Network;${type}"
861	;;	752	;;
862		753
863	*)	754	*)
864	type=	755	type=
865	;;	756	;;
…		…
871	local desktop_name="${PN}-${SLOT}"	762	local desktop_name="${PN}-${SLOT}"
872	fi	763	fi
873	local desktop="${T}/$(echo ${exec} \| sed 's:[[:space:]/:]:_:g')-${desktop_name}.desktop"	764	local desktop="${T}/$(echo ${exec} \| sed 's:[[:space:]/:]:_:g')-${desktop_name}.desktop"
874	#local desktop=${T}/${exec%% *:-${desktop_name}}.desktop	765	#local desktop=${T}/${exec%% *:-${desktop_name}}.desktop
875		766
		767	# Don't append another ";" when a valid category value is provided.
		768	type=${type%;}${type:+;}
		769
		770	eshopts_push -s extglob
		771	if [[ -n ${icon} && ${icon} != /* ]] && [[ ${icon} == .xpm \|\| ${icon} == .png \|\| ${icon} == *.svg ]]; then
		772	ewarn "As described in the Icon Theme Specification, icon file extensions are not"
		773	ewarn "allowed in .desktop files if the value is not an absolute path."
		774	icon=${icon%.@(xpm\|png\|svg)}
		775	fi
		776	eshopts_pop
		777
876	cat <<-EOF > "${desktop}"	778	cat <<-EOF > "${desktop}"
877	[Desktop Entry]	779	[Desktop Entry]
878	Encoding=UTF-8
879	Version=1.0
880	Name=${name}	780	Name=${name}
881	Type=Application	781	Type=Application
882	Comment=${DESCRIPTION}	782	Comment=${DESCRIPTION}
883	Exec=${exec}	783	Exec=${exec}
884	TryExec=${exec%% *}	784	TryExec=${exec%% *}
885	Path=${path}
886	Icon=${icon}	785	Icon=${icon}
887	Categories=${type};	786	Categories=${type}
888	EOF	787	EOF
		788
		789	if [[ ${fields:-=} != = ]] ; then
		790	# 5th arg used to be value to Path=
		791	ewarn "make_desktop_entry: update your 5th arg to read Path=${fields}"
		792	fields="Path=${fields}"
		793	fi
		794	[[ -n ${fields} ]] && printf '%b\n' "${fields}" >> "${desktop}"
889		795
890	(	796	(
891	# wrap the env here so that the 'insinto' call	797	# wrap the env here so that the 'insinto' call
892	# doesn't corrupt the env of the caller	798	# doesn't corrupt the env of the caller
893	insinto /usr/share/applications	799	insinto /usr/share/applications
894	doins "${desktop}"	800	doins "${desktop}"
895	)	801	) \|\| die "installing desktop file failed"
896	}	802	}
897		803
898	# @FUNCTION: validate_desktop_entries	804	# @FUNCTION: validate_desktop_entries
899	# @USAGE: [directories]	805	# @USAGE: [directories]
900	# @MAINTAINER:	806	# @MAINTAINER:
…		…
922	einfo "Passing desktop entry validity check. Install dev-util/desktop-file-utils, if you want to help to improve Gentoo."	828	einfo "Passing desktop entry validity check. Install dev-util/desktop-file-utils, if you want to help to improve Gentoo."
923	fi	829	fi
924	}	830	}
925		831
926	# @FUNCTION: make_session_desktop	832	# @FUNCTION: make_session_desktop
927	# @USAGE: <title> <command>	833	# @USAGE: <title> <command> [command args...]
928	# @DESCRIPTION:	834	# @DESCRIPTION:
929	# Make a GDM/KDM Session file. The title is the file to execute to start the	835	# 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.	836	# Window Manager. The command is the name of the Window Manager.
		837	#
		838	# You can set the name of the file via the ${wm} variable.
931	make_session_desktop() {	839	make_session_desktop() {
932	[[ -z $1 ]] && eerror "make_session_desktop: You must specify the title" && return 1	840	[[ -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	841	[[ -z $2 ]] && eerror "$0: You must specify the command" && return 1
934		842
935	local title=$1	843	local title=$1
936	local command=$2	844	local command=$2
937	local desktop=${T}/${wm}.desktop	845	local desktop=${T}/${wm:-${PN}}.desktop
		846	shift 2
938		847
939	cat <<-EOF > "${desktop}"	848	cat <<-EOF > "${desktop}"
940	[Desktop Entry]	849	[Desktop Entry]
941	Encoding=UTF-8
942	Name=${title}	850	Name=${title}
943	Comment=This session logs you into ${title}	851	Comment=This session logs you into ${title}
944	Exec=${command}	852	Exec=${command} $*
945	TryExec=${command}	853	TryExec=${command}
946	Type=Application	854	Type=XSession
947	EOF	855	EOF
948		856
949	(	857	(
950	# wrap the env here so that the 'insinto' call	858	# wrap the env here so that the 'insinto' call
951	# doesn't corrupt the env of the caller	859	# doesn't corrupt the env of the caller
…		…
972	elif [[ -d ${i} ]] ; then	880	elif [[ -d ${i} ]] ; then
973	for j in "${i}"/*.desktop ; do	881	for j in "${i}"/*.desktop ; do
974	doins "${j}"	882	doins "${j}"
975	((ret+=$?))	883	((ret+=$?))
976	done	884	done
		885	else
		886	((++ret))
977	fi	887	fi
978	done	888	done
979	exit ${ret}	889	exit ${ret}
980	)	890	)
981	}	891	}
…		…
1011	elif [[ -d ${i} ]] ; then	921	elif [[ -d ${i} ]] ; then
1012	for j in "${i}"/*.png ; do	922	for j in "${i}"/*.png ; do
1013	doins "${j}"	923	doins "${j}"
1014	((ret+=$?))	924	((ret+=$?))
1015	done	925	done
		926	else
		927	((++ret))
1016	fi	928	fi
1017	done	929	done
1018	exit ${ret}	930	exit ${ret}
1019	)	931	)
1020	}	932	}
…		…
1055	# @DESCRIPTION:	967	# @DESCRIPTION:
1056	# Unpack those pesky pdv generated files ...	968	# Unpack those pesky pdv generated files ...
1057	# They're self-unpacking programs with the binary package stuffed in	969	# 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	970	# 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.	971	# it seems to like to segfault a lot :(. So lets take it apart ourselves.
1060	#	972	#
1061	# You have to specify the off_t size ... I have no idea how to extract that	973	# 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	974	# 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	975	# the size of the off_t type (in bytes) on the machine that built the pdv
1064	# archive.	976	# archive.
1065	#	977	#
1066	# One way to determine this is by running the following commands:	978	# One way to determine this is by running the following commands:
		979	#
		980	# @CODE
1067	# strings <pdv archive> \| grep lseek	981	# strings <pdv archive> \| grep lseek
1068	# strace -elseek <pdv archive>	982	# strace -elseek <pdv archive>
		983	# @CODE
		984	#
1069	# Basically look for the first lseek command (we do the strings/grep because	985	# 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	986	# sometimes the function call is _llseek or something) and steal the 2nd
1071	# parameter. Here is an example:	987	# parameter. Here is an example:
		988	#
		989	# @CODE
1072	# vapier@vapier 0 pdv_unpack # strings hldsupdatetool.bin \| grep lseek	990	# vapier@vapier 0 pdv_unpack # strings hldsupdatetool.bin \| grep lseek
1073	# lseek	991	# lseek
1074	# vapier@vapier 0 pdv_unpack # strace -elseek ./hldsupdatetool.bin	992	# vapier@vapier 0 pdv_unpack # strace -elseek ./hldsupdatetool.bin
1075	# lseek(3, -4, SEEK_END) = 2981250	993	# lseek(3, -4, SEEK_END) = 2981250
		994	# @CODE
		995	#
1076	# Thus we would pass in the value of '4' as the second parameter.	996	# Thus we would pass in the value of '4' as the second parameter.
1077	unpack_pdv() {	997	unpack_pdv() {
1078	local src=$(find_unpackable_file "$1")	998	local src=$(find_unpackable_file "$1")
1079	local sizeoff_t=$2	999	local sizeoff_t=$2
1080		1000
…		…
1150	# @DESCRIPTION:	1070	# @DESCRIPTION:
1151	# Unpack those pesky makeself generated files ...	1071	# Unpack those pesky makeself generated files ...
1152	# They're shell scripts with the binary package tagged onto	1072	# They're shell scripts with the binary package tagged onto
1153	# the end of the archive. Loki utilized the format as does	1073	# the end of the archive. Loki utilized the format as does
1154	# many other game companies.	1074	# many other game companies.
1155	#	1075	#
1156	# If the file is not specified, then ${A} is used. If the	1076	# If the file is not specified, then ${A} is used. If the
1157	# offset is not specified then we will attempt to extract	1077	# offset is not specified then we will attempt to extract
1158	# the proper offset from the script itself.	1078	# the proper offset from the script itself.
1159	unpack_makeself() {	1079	unpack_makeself() {
1160	local src_input=${1:-${A}}	1080	local src_input=${1:-${A}}
…		…
1165	[[ -z ${src} ]] && die "Could not locate source for '${src_input}'"	1085	[[ -z ${src} ]] && die "Could not locate source for '${src_input}'"
1166		1086
1167	local shrtsrc=$(basename "${src}")	1087	local shrtsrc=$(basename "${src}")
1168	echo ">>> Unpacking ${shrtsrc} to ${PWD}"	1088	echo ">>> Unpacking ${shrtsrc} to ${PWD}"
1169	if [[ -z ${skip} ]] ; then	1089	if [[ -z ${skip} ]] ; then
1170	local ver=$(grep -a '#.*Makeself' "${src}" \| awk '{print $NF}')	1090	local ver=$(grep -m1 -a '#.*Makeself' "${src}" \| awk '{print $NF}')
1171	local skip=0	1091	local skip=0
1172	exe=tail	1092	exe=tail
1173	case ${ver} in	1093	case ${ver} in
1174	1.5.*\|1.6.0-nv) # tested 1.5.{3,4,5} ... guessing 1.5.x series is same	1094	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)	1095	skip=$(grep -a ^skip= "${src}" \| cut -d= -f2)
…		…
1177	2.0\|2.0.1)	1097	2.0\|2.0.1)
1178	skip=$(grep -a ^$'\t'tail "${src}" \| awk '{print $2}' \| cut -b2-)	1098	skip=$(grep -a ^$'\t'tail "${src}" \| awk '{print $2}' \| cut -b2-)
1179	;;	1099	;;
1180	2.1.1)	1100	2.1.1)
1181	skip=$(grep -a ^offset= "${src}" \| awk '{print $2}' \| cut -b2-)	1101	skip=$(grep -a ^offset= "${src}" \| awk '{print $2}' \| cut -b2-)
1182	let skip="skip + 1"	1102	(( skip++ ))
1183	;;	1103	;;
1184	2.1.2)	1104	2.1.2)
1185	skip=$(grep -a ^offset= "${src}" \| awk '{print $3}' \| head -n 1)	1105	skip=$(grep -a ^offset= "${src}" \| awk '{print $3}' \| head -n 1)
1186	let skip="skip + 1"	1106	(( skip++ ))
1187	;;	1107	;;
1188	2.1.3)	1108	2.1.3)
1189	skip=`grep -a ^offset= "${src}" \| awk '{print $3}'`	1109	skip=`grep -a ^offset= "${src}" \| awk '{print $3}'`
1190	let skip="skip + 1"	1110	(( skip++ ))
1191	;;	1111	;;
1192	2.1.4\|2.1.5)	1112	2.1.4\|2.1.5)
1193	skip=$(grep -a offset=.head.wc "${src}" \| awk '{print $3}' \| head -n 1)	1113	skip=$(grep -a offset=.head.wc "${src}" \| awk '{print $3}' \| head -n 1)
1194	skip=$(head -n ${skip} "${src}" \| wc -c)	1114	skip=$(head -n ${skip} "${src}" \| wc -c)
1195	exe="dd"	1115	exe="dd"
…		…
1204	esac	1124	esac
1205	debug-print "Detected Makeself version ${ver} ... using ${skip} as offset"	1125	debug-print "Detected Makeself version ${ver} ... using ${skip} as offset"
1206	fi	1126	fi
1207	case ${exe} in	1127	case ${exe} in
1208	tail) exe="tail -n +${skip} '${src}'";;	1128	tail) exe="tail -n +${skip} '${src}'";;
1209	dd) exe="dd ibs=${skip} skip=1 obs=1024 conv=sync if='${src}'";;	1129	dd) exe="dd ibs=${skip} skip=1 if='${src}'";;
1210	*) die "makeself cant handle exe '${exe}'"	1130	*) die "makeself cant handle exe '${exe}'"
1211	esac	1131	esac
1212		1132
1213	# lets grab the first few bytes of the file to figure out what kind of archive it is	1133	# lets grab the first few bytes of the file to figure out what kind of archive it is
1214	local tmpfile=$(emktemp)	1134	local filetype tmpfile=$(emktemp)
1215	eval ${exe} 2>/dev/null \| head -c 512 > "${tmpfile}"	1135	eval ${exe} 2>/dev/null \| head -c 512 > "${tmpfile}"
1216	local filetype=$(file -b "${tmpfile}")	1136	filetype=$(file -b "${tmpfile}") \|\| die
1217	case ${filetype} in	1137	case ${filetype} in
1218	tar\ archive)	1138	tar\ archive)
1219	eval ${exe} \| tar --no-same-owner -xf -	1139	eval ${exe} \| tar --no-same-owner -xf -
1220	;;	1140	;;
1221	bzip2*)	1141	bzip2*)
…		…
1233	;;	1153	;;
1234	esac	1154	esac
1235	assert "failure unpacking (${filetype}) makeself ${shrtsrc} ('${ver}' +${skip})"	1155	assert "failure unpacking (${filetype}) makeself ${shrtsrc} ('${ver}' +${skip})"
1236	}	1156	}
1237		1157
1238	# @FUNCTION: check_license	1158	# @FUNCTION: strip-linguas
1239	# @USAGE: [license]	1159	# @USAGE: [<allow LINGUAS>\|<-i\|-u> <directories of .po files>]
1240	# @DESCRIPTION:	1160	# @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
1299	# @USAGE: <file on cd1> [file on cd2] [file on cd3] [...]
1300	# @DESCRIPTION:
1301	# Aquire cd(s) for those lovely cd-based emerges. Yes, this violates
1302	# the whole 'non-interactive' policy, but damnit I want CD support !
1303	#
1304	# With these cdrom functions we handle all the user interaction and
1305	# 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
1307	# found at CDROM_ROOT.
1308	#
1309	# 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
1311	# the cdrom functions will handle.
1312	#
1313	# 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
1315	# 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
1317	# also use the CDROM_NAME_SET bash array.
1318	#
1319	# For those multi cd ebuilds, see the cdrom_load_next_cd() function.
1320	cdrom_get_cds() {
1321	# first we figure out how many cds we're dealing with by
1322	# the # of files they gave us
1323	local cdcnt=0
1324	local f=
1325	for f in "$@" ; do
1326	((++cdcnt))
1327	export CDROM_CHECK_${cdcnt}="$f"
1328	done
1329	export CDROM_TOTAL_CDS=${cdcnt}
1330	export CDROM_CURRENT_CD=1
1331
1332	# now we see if the user gave use CD_ROOT ...
1333	# if they did, let's just believe them that it's correct
1334	if [[ -n ${CD_ROOT}${CD_ROOT_1} ]] ; then
1335	local var=
1336	cdcnt=0
1337	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
1338	((++cdcnt))
1339	var="CD_ROOT_${cdcnt}"
1340	[[ -z ${!var} ]] && var="CD_ROOT"
1341	if [[ -z ${!var} ]] ; then
1342	eerror "You must either use just the CD_ROOT"
1343	eerror "or specify ALL the CD_ROOT_X variables."
1344	eerror "In this case, you will need ${CDROM_TOTAL_CDS} CD_ROOT_X variables."
1345	die "could not locate CD_ROOT_${cdcnt}"
1346	fi
1347	done
1348	export CDROM_ROOT=${CD_ROOT_1:-${CD_ROOT}}
1349	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
1350	export CDROM_SET=-1
1351	for f in ${CDROM_CHECK_1//:/ } ; do
1352	((++CDROM_SET))
1353	[[ -e ${CD_ROOT}/${f} ]] && break
1354	done
1355	export CDROM_MATCH=${f}
1356	return
1357	fi
1358
1359	# User didn't help us out so lets make sure they know they can
1360	# simplify the whole process ...
1361	if [[ ${CDROM_TOTAL_CDS} -eq 1 ]] ; then
1362	einfo "This ebuild will need the ${CDROM_NAME:-cdrom for ${PN}}"
1363	echo
1364	einfo "If you do not have the CD, but have the data files"
1365	einfo "mounted somewhere on your filesystem, just export"
1366	einfo "the variable CD_ROOT so that it points to the"
1367	einfo "directory containing the files."
1368	echo
1369	einfo "For example:"
1370	einfo "export CD_ROOT=/mnt/cdrom"
1371	echo
1372	else
1373	if [[ -n ${CDROM_NAME_SET} ]] ; then
1374	# Translate the CDROM_NAME_SET array into CDROM_NAME_#
1375	cdcnt=0
1376	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
1377	((++cdcnt))
1378	export CDROM_NAME_${cdcnt}="${CDROM_NAME_SET[$((${cdcnt}-1))]}"
1379	done
1380	fi
1381
1382	einfo "This package will need access to ${CDROM_TOTAL_CDS} cds."
1383	cdcnt=0
1384	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
1385	((++cdcnt))
1386	var="CDROM_NAME_${cdcnt}"
1387	[[ ! -z ${!var} ]] && einfo " CD ${cdcnt}: ${!var}"
1388	done
1389	echo
1390	einfo "If you do not have the CDs, but have the data files"
1391	einfo "mounted somewhere on your filesystem, just export"
1392	einfo "the following variables so they point to the right place:"
1393	einfon ""
1394	cdcnt=0
1395	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
1396	((++cdcnt))
1397	echo -n " CD_ROOT_${cdcnt}"
1398	done
1399	echo
1400	einfo "Or, if you have all the files in the same place, or"
1401	einfo "you only have one cdrom, you can export CD_ROOT"
1402	einfo "and that place will be used as the same data source"
1403	einfo "for all the CDs."
1404	echo
1405	einfo "For example:"
1406	einfo "export CD_ROOT_1=/mnt/cdrom"
1407	echo
1408	fi
1409
1410	export CDROM_SET=""
1411	export CDROM_CURRENT_CD=0
1412	cdrom_load_next_cd
1413	}
1414
1415	# @FUNCTION: cdrom_load_next_cd
1416	# @DESCRIPTION:
1417	# Some packages are so big they come on multiple CDs. When you're done reading
1418	# files off a CD and want access to the next one, just call this function.
1419	# Again, all the messy details of user interaction are taken care of for you.
1420	# Once this returns, just read the variable CDROM_ROOT for the location of the
1421	# mounted CD. Note that you can only go forward in the CD list, so make sure
1422	# you only call this function when you're done using the current CD.
1423	cdrom_load_next_cd() {
1424	local var
1425	((++CDROM_CURRENT_CD))
1426
1427	unset CDROM_ROOT
1428	var=CD_ROOT_${CDROM_CURRENT_CD}
1429	[[ -z ${!var} ]] && var="CD_ROOT"
1430	if [[ -z ${!var} ]] ; then
1431	var="CDROM_CHECK_${CDROM_CURRENT_CD}"
1432	_cdrom_locate_file_on_cd ${!var}
1433	else
1434	export CDROM_ROOT=${!var}
1435	fi
1436
1437	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
1438	}
1439
1440	# this is used internally by the cdrom_get_cds() and cdrom_load_next_cd()
1441	# functions. this should never be called from an ebuild.
1442	# all it does is try to locate a give file on a cd ... if the cd isn't
1443	# found, then a message asking for the user to insert the cdrom will be
1444	# displayed and we'll hang out here until:
1445	# (1) the file is found on a mounted cdrom
1446	# (2) the user hits CTRL+C
1447	_cdrom_locate_file_on_cd() {
1448	local mline=""
1449	local showedmsg=0
1450
1451	while [[ -z ${CDROM_ROOT} ]] ; do
1452	local i=0
1453	local -a cdset=(${*//:/ })
1454	if [[ -n ${CDROM_SET} ]] ; then
1455	cdset=(${cdset[${CDROM_SET}]})
1456	fi
1457
1458	while [[ -n ${cdset[${i}]} ]] ; do
1459	local dir=$(dirname ${cdset[${i}]})
1460	local file=$(basename ${cdset[${i}]})
1461
1462	local point= node= fs= foo=
1463	while read point node fs foo ; do
1464	[[ " cd9660 iso9660 udf " != " ${fs} " ]] && \
1465	! [[ ${fs} == "subfs" && ",${opts}," == ",fs=cdfss," ]] \
1466	&& continue
1467	point=${point//\040/ }
1468	[[ -z $(find "${point}/${dir}" -maxdepth 1 -iname "${file}") ]] && continue
1469	export CDROM_ROOT=${point}
1470	export CDROM_SET=${i}
1471	export CDROM_MATCH=${cdset[${i}]}
1472	return
1473	done <<< "$(get_mounts)"
1474
1475	((++i))
1476	done
1477
1478	echo
1479	if [[ ${showedmsg} -eq 0 ]] ; then
1480	if [[ ${CDROM_TOTAL_CDS} -eq 1 ]] ; then
1481	if [[ -z ${CDROM_NAME} ]] ; then
1482	einfo "Please insert+mount the cdrom for ${PN} now !"
1483	else
1484	einfo "Please insert+mount the ${CDROM_NAME} cdrom now !"
1485	fi
1486	else
1487	if [[ -z ${CDROM_NAME_1} ]] ; then
1488	einfo "Please insert+mount cd #${CDROM_CURRENT_CD} for ${PN} now !"
1489	else
1490	local var="CDROM_NAME_${CDROM_CURRENT_CD}"
1491	einfo "Please insert+mount the ${!var} cdrom now !"
1492	fi
1493	fi
1494	showedmsg=1
1495	fi
1496	einfo "Press return to scan for the cd again"
1497	einfo "or hit CTRL+C to abort the emerge."
1498	echo
1499	einfo "If you are having trouble with the detection"
1500	einfo "of your CD, it is possible that you do not have"
1501	einfo "Joliet support enabled in your kernel. Please"
1502	einfo "check that CONFIG_JOLIET is enabled in your kernel."
1503	read \|\| die "something is screwed with your system"
1504	done
1505	}
1506
1507	# Make sure that LINGUAS only contains languages that	1161	# Make sure that LINGUAS only contains languages that
1508	# a package can support	1162	# a package can support. The first form allows you to
1509	#	1163	# specify a list of LINGUAS. The -i builds a list of po
1510	# usage: strip-linguas <allow LINGUAS>	1164	# files found in all the directories and uses the
1511	# strip-linguas -i <directories of .po files>	1165	# intersection of the lists. The -u builds a list of po
1512	# strip-linguas -u <directories of .po files>	1166	# files found in all the directories and uses the union
1513	#	1167	# 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() {	1168	strip-linguas() {
1520	local ls newls nols	1169	local ls newls nols
1521	if [[ $1 == "-i" ]] \|\| [[ $1 == "-u" ]] ; then	1170	if [[ $1 == "-i" ]] \|\| [[ $1 == "-u" ]] ; then
1522	local op=$1; shift	1171	local op=$1; shift
1523	ls=$(find "$1" -name '*.po' -exec basename {} .po \;); shift	1172	ls=$(find "$1" -name '*.po' -exec basename {} .po ';'); shift
1524	local d f	1173	local d f
1525	for d in "$@" ; do	1174	for d in "$@" ; do
1526	if [[ ${op} == "-u" ]] ; then	1175	if [[ ${op} == "-u" ]] ; then
1527	newls=${ls}	1176	newls=${ls}
1528	else	1177	else
1529	newls=""	1178	newls=""
1530	fi	1179	fi
1531	for f in $(find "$d" -name '*.po' -exec basename {} .po \;) ; do	1180	for f in $(find "$d" -name '*.po' -exec basename {} .po ';') ; do
1532	if [[ ${op} == "-i" ]] ; then	1181	if [[ ${op} == "-i" ]] ; then
1533	hasq ${f} ${ls} && newls="${newls} ${f}"	1182	has ${f} ${ls} && newls="${newls} ${f}"
1534	else	1183	else
1535	hasq ${f} ${ls} \|\| newls="${newls} ${f}"	1184	has ${f} ${ls} \|\| newls="${newls} ${f}"
1536	fi	1185	fi
1537	done	1186	done
1538	ls=${newls}	1187	ls=${newls}
1539	done	1188	done
1540	else	1189	else
…		…
1542	fi	1191	fi
1543		1192
1544	nols=""	1193	nols=""
1545	newls=""	1194	newls=""
1546	for f in ${LINGUAS} ; do	1195	for f in ${LINGUAS} ; do
1547	if hasq ${f} ${ls} ; then	1196	if has ${f} ${ls} ; then
1548	newls="${newls} ${f}"	1197	newls="${newls} ${f}"
1549	else	1198	else
1550	nols="${nols} ${f}"	1199	nols="${nols} ${f}"
1551	fi	1200	fi
1552	done	1201	done
1553	[[ -n ${nols} ]] \	1202	[[ -n ${nols} ]] \
1554	&& ewarn "Sorry, but ${PN} does not support the LINGUAs:" ${nols}	1203	&& ewarn "Sorry, but ${PN} does not support the LINGUAS:" ${nols}
1555	export LINGUAS=${newls:1}	1204	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	}	1205	}
1587		1206
1588	# @FUNCTION: preserve_old_lib	1207	# @FUNCTION: preserve_old_lib
1589	# @USAGE: <libs to preserve> [more libs]	1208	# @USAGE: <libs to preserve> [more libs]
1590	# @DESCRIPTION:	1209	# @DESCRIPTION:
…		…
1599	eerror "preserve_old_lib() must be called from pkg_preinst() only"	1218	eerror "preserve_old_lib() must be called from pkg_preinst() only"
1600	die "Invalid preserve_old_lib() usage"	1219	die "Invalid preserve_old_lib() usage"
1601	fi	1220	fi
1602	[[ -z $1 ]] && die "Usage: preserve_old_lib <library to preserve> [more libraries to preserve]"	1221	[[ -z $1 ]] && die "Usage: preserve_old_lib <library to preserve> [more libraries to preserve]"
1603		1222
		1223	# let portage worry about it
		1224	has preserve-libs ${FEATURES} && return 0
		1225
1604	local lib dir	1226	local lib dir
1605	for lib in "$@" ; do	1227	for lib in "$@" ; do
1606	[[ -e ${ROOT}/${lib} ]] \|\| continue	1228	[[ -e ${ROOT}/${lib} ]] \|\| continue
1607	dir=${lib%/*}	1229	dir=${lib%/*}
1608	dodir ${dir} \|\| die "dodir ${dir} failed"	1230	dodir ${dir} \|\| die "dodir ${dir} failed"
…		…
1618	preserve_old_lib_notify() {	1240	preserve_old_lib_notify() {
1619	if [[ ${EBUILD_PHASE} != "postinst" ]] ; then	1241	if [[ ${EBUILD_PHASE} != "postinst" ]] ; then
1620	eerror "preserve_old_lib_notify() must be called from pkg_postinst() only"	1242	eerror "preserve_old_lib_notify() must be called from pkg_postinst() only"
1621	die "Invalid preserve_old_lib_notify() usage"	1243	die "Invalid preserve_old_lib_notify() usage"
1622	fi	1244	fi
		1245
		1246	# let portage worry about it
		1247	has preserve-libs ${FEATURES} && return 0
1623		1248
1624	local lib notice=0	1249	local lib notice=0
1625	for lib in "$@" ; do	1250	for lib in "$@" ; do
1626	[[ -e ${ROOT}/${lib} ]] \|\| continue	1251	[[ -e ${ROOT}/${lib} ]] \|\| continue
1627	if [[ ${notice} -eq 0 ]] ; then	1252	if [[ ${notice} -eq 0 ]] ; then
…		…
1631	ewarn "the libraries are not being removed. You need to run revdep-rebuild"	1256	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"	1257	ewarn "in order to remove these old dependencies. If you do not have this"
1633	ewarn "helper program, simply emerge the 'gentoolkit' package."	1258	ewarn "helper program, simply emerge the 'gentoolkit' package."
1634	ewarn	1259	ewarn
1635	fi	1260	fi
		1261	# temp hack for #348634 #357225
		1262	[[ ${PN} == "mpfr" ]] && lib=${lib##*/}
1636	ewarn " # revdep-rebuild --library ${lib##*/}"	1263	ewarn " # revdep-rebuild --library '${lib}'"
1637	done	1264	done
		1265	if [[ ${notice} -eq 1 ]] ; then
		1266	ewarn
		1267	ewarn "Once you've finished running revdep-rebuild, it should be safe to"
		1268	ewarn "delete the old libraries. Here is a copy & paste for the lazy:"
		1269	for lib in "$@" ; do
		1270	ewarn " # rm '${lib}'"
		1271	done
		1272	fi
1638	}	1273	}
1639		1274
1640	# @FUNCTION: built_with_use	1275	# @FUNCTION: built_with_use
1641	# @USAGE: [--hidden] [--missing <action>] [-a\|-o] <DEPEND ATOM> <List of USE flags>	1276	# @USAGE: [--hidden] [--missing <action>] [-a\|-o] <DEPEND ATOM> <List of USE flags>
1642	# @DESCRIPTION:	1277	# @DESCRIPTION:
		1278	#
		1279	# Deprecated: Use EAPI 2 use deps in DEPEND\|RDEPEND and with has_version calls.
		1280	#
1643	# A temporary hack until portage properly supports DEPENDing on USE	1281	# A temporary hack until portage properly supports DEPENDing on USE
1644	# flags being enabled in packages. This will check to see if the specified	1282	# 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	1283	# 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	1284	# --missing option controls the behavior if called on a package that does
1647	# not actually support the defined USE flags (aka listed in IUSE).	1285	# 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	1286	# 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"	1287	# 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	1288	# 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	1289	# 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	1290	# 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	1291	# means the USE flag we're checking is hidden expanded, so it won't be found
1654	# in IUSE like normal USE flags.	1292	# in IUSE like normal USE flags.
1655	#	1293	#
1656	# Remember that this function isn't terribly intelligent so order of optional	1294	# Remember that this function isn't terribly intelligent so order of optional
1657	# flags matter.	1295	# flags matter.
1658	built_with_use() {	1296	built_with_use() {
1659	local hidden="no"	1297	local hidden="no"
1660	if [[ $1 == "--hidden" ]] ; then	1298	if [[ $1 == "--hidden" ]] ; then
…		…
1691	die) die "Unable to determine what USE flags $PKG was built with";;	1329	die) die "Unable to determine what USE flags $PKG was built with";;
1692	esac	1330	esac
1693	fi	1331	fi
1694		1332
1695	if [[ ${hidden} == "no" ]] ; then	1333	if [[ ${hidden} == "no" ]] ; then
1696	local IUSE_BUILT=$(<${IUSEFILE})	1334	local IUSE_BUILT=( $(<"${IUSEFILE}") )
1697	# Don't check USE_EXPAND #147237	1335	# Don't check USE_EXPAND #147237
1698	local expand	1336	local expand
1699	for expand in $(echo ${USE_EXPAND} \| tr '[:upper:]' '[:lower:]') ; do	1337	for expand in $(echo ${USE_EXPAND} \| tr '[:upper:]' '[:lower:]') ; do
1700	if [[ $1 == ${expand}_* ]] ; then	1338	if [[ $1 == ${expand}_* ]] ; then
1701	expand=""	1339	expand=""
1702	break	1340	break
1703	fi	1341	fi
1704	done	1342	done
1705	if [[ -n ${expand} ]] ; then	1343	if [[ -n ${expand} ]] ; then
1706	if ! has $1 ${IUSE_BUILT} ; then	1344	if ! has $1 ${IUSE_BUILT[@]#[-+]} ; then
1707	case ${missing_action} in	1345	case ${missing_action} in
1708	true) return 0;;	1346	true) return 0;;
1709	false) return 1;;	1347	false) return 1;;
1710	die) die "$PKG does not actually support the $1 USE flag!";;	1348	die) die "$PKG does not actually support the $1 USE flag!";;
1711	esac	1349	esac
…		…
1723	shift	1361	shift
1724	done	1362	done
1725	[[ ${opt} = "-a" ]]	1363	[[ ${opt} = "-a" ]]
1726	}	1364	}
1727		1365
1728	# @DESCRIPTION: epunt_cxx	1366	# @FUNCTION: epunt_cxx
1729	# @USAGE: [dir to scan]	1367	# @USAGE: [dir to scan]
1730	# @DESCRIPTION:	1368	# @DESCRIPTION:
1731	# Many configure scripts wrongly bail when a C++ compiler could not be	1369	# Many configure scripts wrongly bail when a C++ compiler could not be
1732	# detected. If dir is not specified, then it defaults to ${S}.	1370	# detected. If dir is not specified, then it defaults to ${S}.
1733	#	1371	#
…		…
1735	epunt_cxx() {	1373	epunt_cxx() {
1736	local dir=$1	1374	local dir=$1
1737	[[ -z ${dir} ]] && dir=${S}	1375	[[ -z ${dir} ]] && dir=${S}
1738	ebegin "Removing useless C++ checks"	1376	ebegin "Removing useless C++ checks"
1739	local f	1377	local f
1740	for f in $(find ${dir} -name configure) ; do	1378	find "${dir}" -name configure \| while read f ; do
1741	patch -p0 "${f}" "${PORTDIR}/eclass/ELT-patches/nocxx/nocxx.patch" > /dev/null	1379	patch --no-backup-if-mismatch -p0 "${f}" "${PORTDIR}/eclass/ELT-patches/nocxx/nocxx.patch" > /dev/null
1742	done	1380	done
1743	eend 0	1381	eend 0
1744	}	1382	}
1745		1383
1746	# @FUNCTION: make_wrapper	1384	# @FUNCTION: make_wrapper
1747	# @USAGE: <wrapper> <target> <chdir> [libpaths] [installpath]	1385	# @USAGE: <wrapper> <target> [chdir] [libpaths] [installpath]
1748	# @DESCRIPTION:	1386	# @DESCRIPTION:
1749	# Create a shell wrapper script named wrapper in installpath	1387	# Create a shell wrapper script named wrapper in installpath
1750	# (defaults to the bindir) to execute target (default of wrapper) by	1388	# (defaults to the bindir) to execute target (default of wrapper) by
1751	# first optionally setting LD_LIBRARY_PATH to the colon-delimited	1389	# first optionally setting LD_LIBRARY_PATH to the colon-delimited
1752	# libpaths followed by optionally changing directory to chdir.	1390	# libpaths followed by optionally changing directory to chdir.
…		…
1775	) \|\| die	1413	) \|\| die
1776	else	1414	else
1777	newbin "${tmpwrapper}" "${wrapper}" \|\| die	1415	newbin "${tmpwrapper}" "${wrapper}" \|\| die
1778	fi	1416	fi
1779	}	1417	}
		1418
		1419	# @FUNCTION: path_exists
		1420	# @USAGE: [-a\|-o] <paths>
		1421	# @DESCRIPTION:
		1422	# Check if the specified paths exist. Works for all types of paths
		1423	# (files/dirs/etc...). The -a and -o flags control the requirements
		1424	# of the paths. They correspond to "and" and "or" logic. So the -a
		1425	# flag means all the paths must exist while the -o flag means at least
		1426	# one of the paths must exist. The default behavior is "and". If no
		1427	# paths are specified, then the return value is "false".
		1428	path_exists() {
		1429	local opt=$1
		1430	[[ ${opt} == -[ao] ]] && shift \|\| opt="-a"
		1431
		1432	# no paths -> return false
		1433	# same behavior as: [[ -e "" ]]
		1434	[[ $# -eq 0 ]] && return 1
		1435
		1436	local p r=0
		1437	for p in "$@" ; do
		1438	[[ -e ${p} ]]
		1439	: $(( r += $? ))
		1440	done
		1441
		1442	case ${opt} in
		1443	-a) return $(( r != 0 )) ;;
		1444	-o) return $(( r == $# )) ;;
		1445	esac
		1446	}
		1447
		1448	# @FUNCTION: in_iuse
		1449	# @USAGE: <flag>
		1450	# @DESCRIPTION:
		1451	# Determines whether the given flag is in IUSE. Strips IUSE default prefixes
		1452	# as necessary.
		1453	#
		1454	# Note that this function should not be used in the global scope.
		1455	in_iuse() {
		1456	debug-print-function ${FUNCNAME} "${@}"
		1457	[[ ${#} -eq 1 ]] \|\| die "Invalid args to ${FUNCNAME}()"
		1458
		1459	local flag=${1}
		1460	local liuse=( ${IUSE} )
		1461
		1462	has "${flag}" "${liuse[@]#[+-]}"
		1463	}
		1464
		1465	# @FUNCTION: use_if_iuse
		1466	# @USAGE: <flag>
		1467	# @DESCRIPTION:
		1468	# Return true if the given flag is in USE and IUSE.
		1469	#
		1470	# Note that this function should not be used in the global scope.
		1471	use_if_iuse() {
		1472	in_iuse $1 \|\| return 1
		1473	use $1
		1474	}
		1475
		1476	# @FUNCTION: usex
		1477	# @USAGE: <USE flag> [true output] [false output] [true suffix] [false suffix]
		1478	# @DESCRIPTION:
		1479	# If USE flag is set, echo [true output][true suffix] (defaults to "yes"),
		1480	# otherwise echo [false output][false suffix] (defaults to "no").
		1481	usex() { use "$1" && echo "${2-yes}$4" \|\| echo "${3-no}$5" ; } #382963
		1482
		1483	check_license() { die "you no longer need this as portage supports ACCEPT_LICENSE itself"; }
		1484
		1485	fi

 Legend:



Removed from v.1.284
 


changed lines


 
Added in v.1.379
 Legend:



Removed from v.1.284
 


changed lines


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

	ViewVC Help
Powered by ViewVC 1.1.20