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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

Revision 1.284		Revision 1.390
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.390 2012/04/16 14:40:16 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	inherit multilib portability	18	if [[ ${___ECLASS_ONCE_EUTILS} != "recur -_+^+_- spank" ]] ; then
		19	___ECLASS_ONCE_EUTILS="recur -_+^+_- spank"
		20
		21	inherit multilib 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	[[ $# -eq 0 ]] \|\| die "${FUNCNAME}: we take no options"
		218	local s
		219	estack_pop eumask s \|\| die "${FUNCNAME}: unbalanced push"
		220	umask ${s} \|\| die "${FUNCNAME}: sanity: could not restore umask: ${s}"
		221	}
		222
		223	# @VARIABLE: EPATCH_SOURCE
		224	# @DESCRIPTION:
		225	# Default directory to search for patches.
53	EPATCH_SOURCE="${WORKDIR}/patch"	226	EPATCH_SOURCE="${WORKDIR}/patch"
54	# Default extension for patches	227	# @VARIABLE: EPATCH_SUFFIX
		228	# @DESCRIPTION:
		229	# Default extension for patches (do not prefix the period yourself).
55	EPATCH_SUFFIX="patch.bz2"	230	EPATCH_SUFFIX="patch.bz2"
		231	# @VARIABLE: EPATCH_OPTS
		232	# @DESCRIPTION:
56	# Default options for patch	233	# Default options for patch:
		234	# @CODE
57	# Set -g0 to keep RCS, ClearCase, Perforce and SCCS happy. Bug #24571	235	# -g0 - keep RCS, ClearCase, Perforce and SCCS happy #24571
58	# Set --no-backup-if-mismatch so we don't leave '.orig' files behind.	236	# --no-backup-if-mismatch - do not leave .orig files behind
59	# Set -E to automatically remove empty files.	237	# -E - automatically remove empty files
		238	# @CODE
60	EPATCH_OPTS="-g0 -E --no-backup-if-mismatch"	239	EPATCH_OPTS="-g0 -E --no-backup-if-mismatch"
		240	# @VARIABLE: EPATCH_EXCLUDE
		241	# @DESCRIPTION:
61	# List of patches not to apply. Not this is only file names,	242	# List of patches not to apply. Note this is only file names,
62	# and not the full path ..	243	# and not the full path. Globs accepted.
63	EPATCH_EXCLUDE=""	244	EPATCH_EXCLUDE=""
		245	# @VARIABLE: EPATCH_SINGLE_MSG
		246	# @DESCRIPTION:
64	# Change the printed message for a single patch.	247	# Change the printed message for a single patch.
65	EPATCH_SINGLE_MSG=""	248	EPATCH_SINGLE_MSG=""
		249	# @VARIABLE: EPATCH_MULTI_MSG
		250	# @DESCRIPTION:
66	# Change the printed message for multiple patches.	251	# Change the printed message for multiple patches.
67	EPATCH_MULTI_MSG="Applying various patches (bugfixes/updates) ..."	252	EPATCH_MULTI_MSG="Applying various patches (bugfixes/updates) ..."
68	# Force applying bulk patches even if not following the style:	253	# @VARIABLE: EPATCH_FORCE
69	#	254	# @DESCRIPTION:
70	# ??_${ARCH}_foo.${EPATCH_SUFFIX}	255	# Only require patches to match EPATCH_SUFFIX rather than the extended
71	#	256	# arch naming style.
72	EPATCH_FORCE="no"	257	EPATCH_FORCE="no"
73		258
74	# This function is for bulk patching, or in theory for just one	259	# @FUNCTION: epatch
75	# or two patches.	260	# @USAGE: [patches] [dirs of patches]
		261	# @DESCRIPTION:
		262	# epatch is designed to greatly simplify the application of patches. It can
		263	# process patch files directly, or directories of patches. The patches may be
		264	# compressed (bzip/gzip/etc...) or plain text. You generally need not specify
		265	# the -p option as epatch will automatically attempt -p0 to -p5 until things
		266	# apply successfully.
76	#	267	#
77	# It should work with .bz2, .gz, .zip and plain text patches.	268	# If you do not specify any options, then epatch will default to the directory
78	# Currently all patches should be the same format.	269	# specified by EPATCH_SOURCE.
79	#	270	#
80	# You do not have to specify '-p' option to patch, as it will	271	# When processing directories, epatch will apply all patches that match:
81	# try with -p0 to -p5 until it succeed, or fail at -p5.	272	# @CODE
82	#	273	# 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}	274	# ??_${ARCH}_foo.${EPATCH_SUFFIX}
		275	# else
		276	# *.${EPATCH_SUFFIX}
		277	# @CODE
		278	# The leading ?? are typically numbers used to force consistent patch ordering.
		279	# The arch field is used to apply patches only for the host architecture with
		280	# the special value of "all" means apply for everyone. Note that using values
		281	# other than "all" is highly discouraged -- you should apply patches all the
		282	# time and let architecture details be detected at configure/compile time.
92	#	283	#
93	# For example:	284	# If EPATCH_SUFFIX is empty, then no period before it is implied when searching
		285	# for patches to apply.
94	#	286	#
95	# 01_all_misc-fix.patch.bz2	287	# 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() {	288	epatch() {
108	_epatch_draw_line() {	289	_epatch_draw_line() {
		290	# create a line of same length as input string
109	[[ -z $1 ]] && set "$(printf "%65s" '')"	291	[[ -z $1 ]] && set "$(printf "%65s" '')"
110	echo "${1//?/=}"	292	echo "${1//?/=}"
111	}	293	}
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		294
120	unset P4CONFIG P4PORT P4USER # keep perforce at bay #56402	295	unset P4CONFIG P4PORT P4USER # keep perforce at bay #56402
121		296
122	if [ "$#" -gt 1 ]	297	# Let the rest of the code process one user arg at a time --
123	then	298	# each arg may expand into multiple patches, and each arg may
		299	# need to start off with the default global EPATCH_xxx values
		300	if [[ $# -gt 1 ]] ; then
124	local m=""	301	local m
125	for m in "$@" ; do	302	for m in "$@" ; do
126	epatch "${m}"	303	epatch "${m}"
127	done	304	done
128	return 0	305	return 0
129	fi	306	fi
130		307
131	if [ -n "$1" -a -f "$1" ]	308	local SINGLE_PATCH="no"
132	then	309	# no args means process ${EPATCH_SOURCE}
		310	[[ $# -eq 0 ]] && set -- "${EPATCH_SOURCE}"
		311
		312	if [[ -f $1 ]] ; then
133	SINGLE_PATCH="yes"	313	SINGLE_PATCH="yes"
134		314	set -- "$1"
135	local EPATCH_SOURCE="$1"	315	# Use the suffix from the single patch (localize it); the code
		316	# below will find the suffix for us
136	local EPATCH_SUFFIX="${1##*\.}"	317	local EPATCH_SUFFIX=$1
137		318
138	elif [ -n "$1" -a -d "$1" ]	319	elif [[ -d $1 ]] ; then
139	then	320	# 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 ...	321	set -- "$1"/*${EPATCH_SUFFIX:+."${EPATCH_SUFFIX}"}
141	if [ "${EPATCH_FORCE}" = "yes" ] && [ -z "${EPATCH_SUFFIX}" ]	322
		323	elif [[ -f ${EPATCH_SOURCE}/$1 ]] ; then
		324	# Re-use EPATCH_SOURCE as a search dir
		325	epatch "${EPATCH_SOURCE}/$1"
		326	return $?
		327
		328	else
		329	# sanity check ... if it isn't a dir or file, wtf man ?
		330	[[ $# -ne 0 ]] && EPATCH_SOURCE=$1
		331	echo
		332	eerror "Cannot find \$EPATCH_SOURCE! Value for \$EPATCH_SOURCE is:"
		333	eerror
		334	eerror " ${EPATCH_SOURCE}"
		335	eerror " ( ${EPATCH_SOURCE##*/} )"
		336	echo
		337	die "Cannot find \$EPATCH_SOURCE!"
		338	fi
		339
		340	local PIPE_CMD
		341	case ${EPATCH_SUFFIX##*\.} in
		342	xz) PIPE_CMD="xz -dc" ;;
		343	lzma) PIPE_CMD="lzma -dc" ;;
		344	bz2) PIPE_CMD="bzip2 -dc" ;;
		345	gz\|Z\|z) PIPE_CMD="gzip -dc" ;;
		346	ZIP\|zip) PIPE_CMD="unzip -p" ;;
		347	*) ;;
		348	esac
		349
		350	[[ ${SINGLE_PATCH} == "no" ]] && einfo "${EPATCH_MULTI_MSG}"
		351
		352	local x
		353	for x in "$@" ; do
		354	# If the patch dir given contains subdirs, or our EPATCH_SUFFIX
		355	# didn't match anything, ignore continue on
		356	[[ ! -f ${x} ]] && continue
		357
		358	local patchname=${x##*/}
		359
		360	# Apply single patches, or forced sets of patches, or
		361	# patches with ARCH dependant names.
		362	# ???_arch_foo.patch
		363	# Else, skip this input altogether
		364	local a=${patchname#*_} # strip the ???_
		365	a=${a%%_*} # strip the _foo.patch
		366	if ! [[ ${SINGLE_PATCH} == "yes" \|\| \
		367	${EPATCH_FORCE} == "yes" \|\| \
		368	${a} == all \|\| \
		369	${a} == ${ARCH} ]]
142	then	370	then
143	local EPATCH_SOURCE="$1/*"	371	continue
		372	fi
		373
		374	# Let people filter things dynamically
		375	if [[ -n ${EPATCH_EXCLUDE} ]] ; then
		376	# let people use globs in the exclude
		377	eshopts_push -o noglob
		378
		379	local ex
		380	for ex in ${EPATCH_EXCLUDE} ; do
		381	if [[ ${patchname} == ${ex} ]] ; then
		382	eshopts_pop
		383	continue 2
		384	fi
		385	done
		386
		387	eshopts_pop
		388	fi
		389
		390	if [[ ${SINGLE_PATCH} == "yes" ]] ; then
		391	if [[ -n ${EPATCH_SINGLE_MSG} ]] ; then
		392	einfo "${EPATCH_SINGLE_MSG}"
		393	else
		394	einfo "Applying ${patchname} ..."
		395	fi
144	else	396	else
145	local EPATCH_SOURCE="$1/*.${EPATCH_SUFFIX}"	397	einfo " ${patchname} ..."
146	fi	398	fi
147	else	399
148	if [ ! -d ${EPATCH_SOURCE} ] \|\| [ -n "$1" ]	400	# most of the time, there will only be one run per unique name,
149	then	401	# but if there are more, make sure we get unique log filenames
150	if [ -n "$1" -a "${EPATCH_SOURCE}" = "${WORKDIR}/patch" ]	402	local STDERR_TARGET="${T}/${patchname}.out"
151	then	403	if [[ -e ${STDERR_TARGET} ]] ; then
152	EPATCH_SOURCE="$1"	404	STDERR_TARGET="${T}/${patchname}-$$.out"
		405	fi
		406
		407	printf "*** %s ***\nPWD: %s\n\n" "${patchname}" "${PWD}" > "${STDERR_TARGET}"
		408
		409	# Decompress the patch if need be
		410	local count=0
		411	local PATCH_TARGET
		412	if [[ -n ${PIPE_CMD} ]] ; then
		413	PATCH_TARGET="${T}/$$.patch"
		414	echo "PIPE_COMMAND: ${PIPE_CMD} ${x} > ${PATCH_TARGET}" >> "${STDERR_TARGET}"
		415
		416	if ! (${PIPE_CMD} "${x}" > "${PATCH_TARGET}") >> "${STDERR_TARGET}" 2>&1 ; then
		417	echo
		418	eerror "Could not extract patch!"
		419	#die "Could not extract patch!"
		420	count=5
		421	break
153	fi	422	fi
		423	else
		424	PATCH_TARGET=${x}
		425	fi
154		426
		427	# Check for absolute paths in patches. If sandbox is disabled,
		428	# people could (accidently) patch files in the root filesystem.
		429	# Or trigger other unpleasantries #237667. So disallow -p0 on
		430	# such patches.
		431	local abs_paths=$(egrep -n '^[-+]{3} /' "${PATCH_TARGET}" \| awk '$2 != "/dev/null" { print }')
		432	if [[ -n ${abs_paths} ]] ; then
		433	count=1
		434	printf "NOTE: skipping -p0 due to absolute paths in patch:\n%s\n" "${abs_paths}" >> "${STDERR_TARGET}"
		435	fi
		436	# Similar reason, but with relative paths.
		437	local rel_paths=$(egrep -n '^[-+]{3} [^ ]*[.][.]/' "${PATCH_TARGET}")
		438	if [[ -n ${rel_paths} ]] ; then
		439	eqawarn "QA Notice: Your patch uses relative paths '../'."
		440	eqawarn " In the future this will cause a failure."
		441	eqawarn "${rel_paths}"
		442	fi
		443
		444	# Dynamically detect the correct -p# ... i'm lazy, so shoot me :/
		445	local patch_cmd
		446	while [[ ${count} -lt 5 ]] ; do
		447	patch_cmd="${BASH_ALIASES[patch]:-patch} -p${count} ${EPATCH_OPTS}"
		448
		449	# Generate some useful debug info ...
		450	(
		451	_epatch_draw_line "*** ${patchname} ***"
155	echo	452	echo
156	eerror "Cannot find \$EPATCH_SOURCE! Value for \$EPATCH_SOURCE is:"	453	echo "PATCH COMMAND: ${patch_cmd} < '${PATCH_TARGET}'"
		454	echo
		455	_epatch_draw_line "*** ${patchname} ***"
		456	${patch_cmd} --dry-run -f < "${PATCH_TARGET}" 2>&1
		457	ret=$?
		458	echo
		459	echo "patch program exited with status ${ret}"
		460	exit ${ret}
		461	) >> "${STDERR_TARGET}"
		462
		463	if [ $? -eq 0 ] ; then
		464	(
		465	_epatch_draw_line "*** ${patchname} ***"
		466	echo
		467	echo "ACTUALLY APPLYING ${patchname} ..."
		468	echo
		469	_epatch_draw_line "*** ${patchname} ***"
		470	${patch_cmd} < "${PATCH_TARGET}" 2>&1
		471	ret=$?
		472	echo
		473	echo "patch program exited with status ${ret}"
		474	exit ${ret}
		475	) >> "${STDERR_TARGET}"
		476
		477	if [ $? -ne 0 ] ; then
		478	echo
		479	eerror "A dry-run of patch command succeeded, but actually"
		480	eerror "applying the patch failed!"
		481	#die "Real world sux compared to the dreamworld!"
		482	count=5
		483	fi
		484	break
		485	fi
		486
		487	: $(( count++ ))
		488	done
		489
		490	# if we had to decompress the patch, delete the temp one
		491	if [[ -n ${PIPE_CMD} ]] ; then
		492	rm -f "${PATCH_TARGET}"
		493	fi
		494
		495	if [[ ${count} -ge 5 ]] ; then
		496	echo
		497	eerror "Failed Patch: ${patchname} !"
		498	eerror " ( ${PATCH_TARGET} )"
157	eerror	499	eerror
158	eerror " ${EPATCH_SOURCE}"	500	eerror "Include in your bugreport the contents of:"
159	eerror " ( ${EPATCH_SOURCE##*/} )"	501	eerror
		502	eerror " ${STDERR_TARGET}"
160	echo	503	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}!"	504	die "Failed Patch: ${patchname}!"
305	fi	505	fi
306		506
307	rm -f ${STDERR_TARGET%/}/${patchname}-${STDERR_TARGET##/}	507	# if everything worked, delete the full debug patch log
		508	rm -f "${STDERR_TARGET}"
308		509
		510	# then log away the exact stuff for people to review later
		511	cat <<-EOF >> "${T}/epatch.log"
		512	PATCH: ${x}
		513	CMD: ${patch_cmd}
		514	PWD: ${PWD}
		515
		516	EOF
309	eend 0	517	eend 0
310	fi
311	done	518	done
312	if [ "${SINGLE_PATCH}" = "no" ]	519
313	then	520	[[ ${SINGLE_PATCH} == "no" ]] && einfo "Done with patching"
314	einfo "Done with patching"	521	: # everything worked
		522	}
		523
		524	# @FUNCTION: epatch_user
		525	# @USAGE:
		526	# @DESCRIPTION:
		527	# Applies user-provided patches to the source tree. The patches are
		528	# taken from /etc/portage/patches/<CATEGORY>/<PF\|P\|PN>/, where the first
		529	# of these three directories to exist will be the one to use, ignoring
		530	# any more general directories which might exist as well. They must end
		531	# in ".patch" to be applied.
		532	#
		533	# User patches are intended for quick testing of patches without ebuild
		534	# modifications, as well as for permanent customizations a user might
		535	# desire. Obviously, there can be no official support for arbitrarily
		536	# patched ebuilds. So whenever a build log in a bug report mentions that
		537	# user patches were applied, the user should be asked to reproduce the
		538	# problem without these.
		539	#
		540	# Not all ebuilds do call this function, so placing patches in the
		541	# stated directory might or might not work, depending on the package and
		542	# the eclasses it inherits and uses. It is safe to call the function
		543	# repeatedly, so it is always possible to add a call at the ebuild
		544	# level. The first call is the time when the patches will be
		545	# applied.
		546	#
		547	# Ideally, this function should be called after gentoo-specific patches
		548	# have been applied, so that their code can be modified as well, but
		549	# before calls to e.g. eautoreconf, as the user patches might affect
		550	# autotool input files as well.
		551	epatch_user() {
		552	[[ $# -ne 0 ]] && die "epatch_user takes no options"
		553
		554	# Allow multiple calls to this function; ignore all but the first
		555	local applied="${T}/epatch_user.log"
		556	[[ -e ${applied} ]] && return 2
		557
		558	# don't clobber any EPATCH vars that the parent might want
		559	local EPATCH_SOURCE check base=${PORTAGE_CONFIGROOT%/}/etc/portage/patches
		560	for check in ${CATEGORY}/{${P}-${PR},${P},${PN}}; do
		561	EPATCH_SOURCE=${base}/${CTARGET}/${check}
		562	[[ -r ${EPATCH_SOURCE} ]] \|\| EPATCH_SOURCE=${base}/${CHOST}/${check}
		563	[[ -r ${EPATCH_SOURCE} ]] \|\| EPATCH_SOURCE=${base}/${check}
		564	if [[ -d ${EPATCH_SOURCE} ]] ; then
		565	EPATCH_SOURCE=${EPATCH_SOURCE} \
		566	EPATCH_SUFFIX="patch" \
		567	EPATCH_FORCE="yes" \
		568	EPATCH_MULTI_MSG="Applying user patches from ${EPATCH_SOURCE} ..." \
		569	epatch
		570	echo "${EPATCH_SOURCE}" > "${applied}"
		571	return 0
315	fi	572	fi
		573	done
		574	echo "none" > "${applied}"
		575	return 1
316	}	576	}
317		577
318	# @FUNCTION: emktemp	578	# @FUNCTION: emktemp
319	# @USAGE: [temp dir]	579	# @USAGE: [temp dir]
320	# @DESCRIPTION:	580	# @DESCRIPTION:
…		…
348	TMPDIR="${topdir}" mktemp -dt tmp.XXXXXXXXXX	608	TMPDIR="${topdir}" mktemp -dt tmp.XXXXXXXXXX
349	fi	609	fi
350	fi	610	fi
351	}	611	}
352		612
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	613	# @FUNCTION: edos2unix
715	# @USAGE: <file> [more files ...]	614	# @USAGE: <file> [more files ...]
716	# @DESCRIPTION:	615	# @DESCRIPTION:
717	# A handy replacement for dos2unix, recode, fixdos, etc... This allows you	616	# A handy replacement for dos2unix, recode, fixdos, etc... This allows you
718	# to remove all of these text utilities from DEPEND variables because this	617	# 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	618	# 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.	619	# they will all be changed from the DOS CRLF format to the UNIX LF format.
721	edos2unix() {	620	edos2unix() {
722	echo "$@" \| xargs sed -i 's/\r$//'	621	[[ $# -eq 0 ]] && return 0
		622	sed -i 's/\r$//' -- "$@" \|\| die
723	}	623	}
724		624
		625	# @FUNCTION: make_desktop_entry
		626	# @USAGE: make_desktop_entry(<command>, [name], [icon], [type], [fields])
		627	# @DESCRIPTION:
725	# Make a desktop file !	628	# Make a .desktop file.
726	# Great for making those icons in kde/gnome startmenu !
727	# Amaze your friends ! Get the women ! Join today !
728	#	629	#
729	# make_desktop_entry(<command>, [name], [icon], [type], [path])	630	# @CODE
730	#
731	# binary: what command does the app run with ?	631	# binary: what command does the app run with ?
732	# name: the name that will show up in the menu	632	# name: the name that will show up in the menu
733	# icon: give your little like a pretty little icon ...	633	# icon: give your little like a pretty little icon ...
734	# this can be relative (to /usr/share/pixmaps) or	634	# this can be relative (to /usr/share/pixmaps) or
735	# a full path to an icon	635	# a full path to an icon
736	# type: what kind of application is this ? for categories:	636	# type: what kind of application is this?
		637	# for categories:
737	# http://standards.freedesktop.org/menu-spec/latest/apa.html	638	# http://standards.freedesktop.org/menu-spec/latest/apa.html
738	# path: if your app needs to startup in a specific dir	639	# if unset, function tries to guess from package's category
		640	# fields: extra fields to append to the desktop file; a printf string
		641	# @CODE
739	make_desktop_entry() {	642	make_desktop_entry() {
740	[[ -z $1 ]] && eerror "make_desktop_entry: You must specify the executable" && return 1	643	[[ -z $1 ]] && die "make_desktop_entry: You must specify the executable"
741		644
742	local exec=${1}	645	local exec=${1}
743	local name=${2:-${PN}}	646	local name=${2:-${PN}}
744	local icon=${3:-${PN}.png}	647	local icon=${3:-${PN}}
745	local type=${4}	648	local type=${4}
746	local path=${5}	649	local fields=${5}
747		650
748	if [[ -z ${type} ]] ; then	651	if [[ -z ${type} ]] ; then
749	local catmaj=${CATEGORY%%-*}	652	local catmaj=${CATEGORY%%-*}
750	local catmin=${CATEGORY##*-}	653	local catmin=${CATEGORY##*-}
751	case ${catmaj} in	654	case ${catmaj} in
752	app)	655	app)
753	case ${catmin} in	656	case ${catmin} in
754	accessibility) type=Accessibility;;	657	accessibility) type="Utility;Accessibility";;
755	admin) type=System;;	658	admin) type=System;;
756	antivirus) type=System;;	659	antivirus) type=System;;
757	arch) type=Archiving;;	660	arch) type="Utility;Archiving";;
758	backup) type=Archiving;;	661	backup) type="Utility;Archiving";;
759	cdr) type=DiscBurning;;	662	cdr) type="AudioVideo;DiscBurning";;
760	dicts) type=Dictionary;;	663	dicts) type="Office;Dictionary";;
761	doc) type=Documentation;;	664	doc) type=Documentation;;
762	editors) type=TextEditor;;	665	editors) type="Utility;TextEditor";;
763	emacs) type=TextEditor;;	666	emacs) type="Development;TextEditor";;
764	emulation) type=Emulator;;	667	emulation) type="System;Emulator";;
765	laptop) type=HardwareSettings;;	668	laptop) type="Settings;HardwareSettings";;
766	office) type=Office;;	669	office) type=Office;;
767	pda) type=PDA;;	670	pda) type="Office;PDA";;
768	vim) type=TextEditor;;	671	vim) type="Development;TextEditor";;
769	xemacs) type=TextEditor;;	672	xemacs) type="Development;TextEditor";;
770	*) type=;;
771	esac	673	esac
772	;;	674	;;
773		675
774	dev)	676	dev)
775	type="Development"	677	type="Development"
776	;;	678	;;
777		679
778	games)	680	games)
779	case ${catmin} in	681	case ${catmin} in
780	action\|fps) type=ActionGame;;	682	action\|fps) type=ActionGame;;
781	arcade) type=ArcadeGame;;	683	arcade) type=ArcadeGame;;
782	board) type=BoardGame;;	684	board) type=BoardGame;;
783	emulation) type=Emulator;;	685	emulation) type=Emulator;;
784	kids) type=KidsGame;;	686	kids) type=KidsGame;;
785	puzzle) type=LogicGame;;	687	puzzle) type=LogicGame;;
786	roguelike) type=RolePlaying;;	688	roguelike) type=RolePlaying;;
787	rpg) type=RolePlaying;;	689	rpg) type=RolePlaying;;
788	simulation) type=Simulation;;	690	simulation) type=Simulation;;
789	sports) type=SportsGame;;	691	sports) type=SportsGame;;
790	strategy) type=StrategyGame;;	692	strategy) type=StrategyGame;;
791	*) type=;;
792	esac	693	esac
793	type="Game;${type}"	694	type="Game;${type}"
794	;;	695	;;
795		696
796	gnome)	697	gnome)
…		…
805	type="Network;Email"	706	type="Network;Email"
806	;;	707	;;
807		708
808	media)	709	media)
809	case ${catmin} in	710	case ${catmin} in
		711	gfx)
810	gfx) type=Graphics;;	712	type=Graphics
		713	;;
		714	*)
		715	case ${catmin} in
811	radio) type=Tuner;;	716	radio) type=Tuner;;
812	sound) type=Audio;;	717	sound) type=Audio;;
813	tv) type=TV;;	718	tv) type=TV;;
814	video) type=Video;;	719	video) type=Video;;
815	*) type=;;	720	esac
		721	type="AudioVideo;${type}"
		722	;;
816	esac	723	esac
817	type="AudioVideo;${type}"
818	;;	724	;;
819		725
820	net)	726	net)
821	case ${catmin} in	727	case ${catmin} in
822	dialup) type=Dialup;;	728	dialup) type=Dialup;;
823	ftp) type=FileTransfer;;	729	ftp) type=FileTransfer;;
824	im) type=InstantMessaging;;	730	im) type=InstantMessaging;;
825	irc) type=IRCClient;;	731	irc) type=IRCClient;;
826	mail) type=Email;;	732	mail) type=Email;;
827	news) type=News;;	733	news) type=News;;
828	nntp) type=News;;	734	nntp) type=News;;
829	p2p) type=FileTransfer;;	735	p2p) type=FileTransfer;;
830	*) type=;;	736	voip) type=Telephony;;
831	esac	737	esac
832	type="Network;${type}"	738	type="Network;${type}"
833	;;	739	;;
834		740
835	sci)	741	sci)
836	case ${catmin} in	742	case ${catmin} in
837	astro*) type=Astronomy;;	743	astro*) type=Astronomy;;
838	bio*) type=Biology;;	744	bio*) type=Biology;;
839	calc*) type=Calculator;;	745	calc*) type=Calculator;;
840	chem*) type=Chemistry;;	746	chem*) type=Chemistry;;
841	elec*) type=Electronics;;	747	elec*) type=Electronics;;
842	geo*) type=Geology;;	748	geo*) type=Geology;;
843	math*) type=Math;;	749	math*) type=Math;;
844	physics) type=Physics;;	750	physics) type=Physics;;
845	visual*) type=DataVisualization;;	751	visual*) type=DataVisualization;;
846	*) type=;;
847	esac	752	esac
848	type="Science;${type}"	753	type="Education;Science;${type}"
849	;;	754	;;
850		755
851	sys)	756	sys)
852	type="System"	757	type="System"
853	;;	758	;;
854		759
855	www)	760	www)
856	case ${catmin} in	761	case ${catmin} in
857	client) type=WebBrowser;;	762	client) type=WebBrowser;;
858	*) type=;;
859	esac	763	esac
860	type="Network"	764	type="Network;${type}"
861	;;	765	;;
862		766
863	*)	767	*)
864	type=	768	type=
865	;;	769	;;
…		…
871	local desktop_name="${PN}-${SLOT}"	775	local desktop_name="${PN}-${SLOT}"
872	fi	776	fi
873	local desktop="${T}/$(echo ${exec} \| sed 's:[[:space:]/:]:_:g')-${desktop_name}.desktop"	777	local desktop="${T}/$(echo ${exec} \| sed 's:[[:space:]/:]:_:g')-${desktop_name}.desktop"
874	#local desktop=${T}/${exec%% *:-${desktop_name}}.desktop	778	#local desktop=${T}/${exec%% *:-${desktop_name}}.desktop
875		779
		780	# Don't append another ";" when a valid category value is provided.
		781	type=${type%;}${type:+;}
		782
		783	eshopts_push -s extglob
		784	if [[ -n ${icon} && ${icon} != /* ]] && [[ ${icon} == .xpm \|\| ${icon} == .png \|\| ${icon} == *.svg ]]; then
		785	ewarn "As described in the Icon Theme Specification, icon file extensions are not"
		786	ewarn "allowed in .desktop files if the value is not an absolute path."
		787	icon=${icon%.@(xpm\|png\|svg)}
		788	fi
		789	eshopts_pop
		790
876	cat <<-EOF > "${desktop}"	791	cat <<-EOF > "${desktop}"
877	[Desktop Entry]	792	[Desktop Entry]
878	Encoding=UTF-8
879	Version=1.0
880	Name=${name}	793	Name=${name}
881	Type=Application	794	Type=Application
882	Comment=${DESCRIPTION}	795	Comment=${DESCRIPTION}
883	Exec=${exec}	796	Exec=${exec}
884	TryExec=${exec%% *}	797	TryExec=${exec%% *}
885	Path=${path}
886	Icon=${icon}	798	Icon=${icon}
887	Categories=${type};	799	Categories=${type}
888	EOF	800	EOF
		801
		802	if [[ ${fields:-=} != = ]] ; then
		803	# 5th arg used to be value to Path=
		804	ewarn "make_desktop_entry: update your 5th arg to read Path=${fields}"
		805	fields="Path=${fields}"
		806	fi
		807	[[ -n ${fields} ]] && printf '%b\n' "${fields}" >> "${desktop}"
889		808
890	(	809	(
891	# wrap the env here so that the 'insinto' call	810	# wrap the env here so that the 'insinto' call
892	# doesn't corrupt the env of the caller	811	# doesn't corrupt the env of the caller
893	insinto /usr/share/applications	812	insinto /usr/share/applications
894	doins "${desktop}"	813	doins "${desktop}"
895	)	814	) \|\| die "installing desktop file failed"
896	}	815	}
897		816
898	# @FUNCTION: validate_desktop_entries	817	# @FUNCTION: validate_desktop_entries
899	# @USAGE: [directories]	818	# @USAGE: [directories]
900	# @MAINTAINER:	819	# @MAINTAINER:
…		…
922	einfo "Passing desktop entry validity check. Install dev-util/desktop-file-utils, if you want to help to improve Gentoo."	841	einfo "Passing desktop entry validity check. Install dev-util/desktop-file-utils, if you want to help to improve Gentoo."
923	fi	842	fi
924	}	843	}
925		844
926	# @FUNCTION: make_session_desktop	845	# @FUNCTION: make_session_desktop
927	# @USAGE: <title> <command>	846	# @USAGE: <title> <command> [command args...]
928	# @DESCRIPTION:	847	# @DESCRIPTION:
929	# Make a GDM/KDM Session file. The title is the file to execute to start the	848	# 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.	849	# Window Manager. The command is the name of the Window Manager.
		850	#
		851	# You can set the name of the file via the ${wm} variable.
931	make_session_desktop() {	852	make_session_desktop() {
932	[[ -z $1 ]] && eerror "make_session_desktop: You must specify the title" && return 1	853	[[ -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	854	[[ -z $2 ]] && eerror "$0: You must specify the command" && return 1
934		855
935	local title=$1	856	local title=$1
936	local command=$2	857	local command=$2
937	local desktop=${T}/${wm}.desktop	858	local desktop=${T}/${wm:-${PN}}.desktop
		859	shift 2
938		860
939	cat <<-EOF > "${desktop}"	861	cat <<-EOF > "${desktop}"
940	[Desktop Entry]	862	[Desktop Entry]
941	Encoding=UTF-8
942	Name=${title}	863	Name=${title}
943	Comment=This session logs you into ${title}	864	Comment=This session logs you into ${title}
944	Exec=${command}	865	Exec=${command} $*
945	TryExec=${command}	866	TryExec=${command}
946	Type=Application	867	Type=XSession
947	EOF	868	EOF
948		869
949	(	870	(
950	# wrap the env here so that the 'insinto' call	871	# wrap the env here so that the 'insinto' call
951	# doesn't corrupt the env of the caller	872	# doesn't corrupt the env of the caller
…		…
972	elif [[ -d ${i} ]] ; then	893	elif [[ -d ${i} ]] ; then
973	for j in "${i}"/*.desktop ; do	894	for j in "${i}"/*.desktop ; do
974	doins "${j}"	895	doins "${j}"
975	((ret+=$?))	896	((ret+=$?))
976	done	897	done
		898	else
		899	((++ret))
977	fi	900	fi
978	done	901	done
979	exit ${ret}	902	exit ${ret}
980	)	903	)
981	}	904	}
…		…
1011	elif [[ -d ${i} ]] ; then	934	elif [[ -d ${i} ]] ; then
1012	for j in "${i}"/*.png ; do	935	for j in "${i}"/*.png ; do
1013	doins "${j}"	936	doins "${j}"
1014	((ret+=$?))	937	((ret+=$?))
1015	done	938	done
		939	else
		940	((++ret))
1016	fi	941	fi
1017	done	942	done
1018	exit ${ret}	943	exit ${ret}
1019	)	944	)
1020	}	945	}
…		…
1030	insinto /usr/share/pixmaps	955	insinto /usr/share/pixmaps
1031	newins "$@"	956	newins "$@"
1032	)	957	)
1033	}	958	}
1034		959
1035	# for internal use only (unpack_pdv and unpack_makeself)	960	# @FUNCTION: strip-linguas
1036	find_unpackable_file() {	961	# @USAGE: [<allow LINGUAS>\|<-i\|-u> <directories of .po files>]
1037	local src=$1
1038	if [[ -z ${src} ]] ; then
1039	src=${DISTDIR}/${A}
1040	else
1041	if [[ -e ${DISTDIR}/${src} ]] ; then
1042	src=${DISTDIR}/${src}
1043	elif [[ -e ${PWD}/${src} ]] ; then
1044	src=${PWD}/${src}
1045	elif [[ -e ${src} ]] ; then
1046	src=${src}
1047	fi
1048	fi
1049	[[ ! -e ${src} ]] && return 1
1050	echo "${src}"
1051	}
1052
1053	# @FUNCTION: unpack_pdv
1054	# @USAGE: <file to unpack> <size of off_t>
1055	# @DESCRIPTION:	962	# @DESCRIPTION:
1056	# Unpack those pesky pdv generated files ...
1057	# 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
1059	# it seems to like to segfault a lot :(. So lets take it apart ourselves.
1060	#
1061	# 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
1063	# the size of the off_t type (in bytes) on the machine that built the pdv
1064	# archive.
1065	#
1066	# One way to determine this is by running the following commands:
1067	# strings <pdv archive> \| grep lseek
1068	# strace -elseek <pdv archive>
1069	# 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
1071	# parameter. Here is an example:
1072	# vapier@vapier 0 pdv_unpack # strings hldsupdatetool.bin \| grep lseek
1073	# lseek
1074	# vapier@vapier 0 pdv_unpack # strace -elseek ./hldsupdatetool.bin
1075	# lseek(3, -4, SEEK_END) = 2981250
1076	# Thus we would pass in the value of '4' as the second parameter.
1077	unpack_pdv() {
1078	local src=$(find_unpackable_file "$1")
1079	local sizeoff_t=$2
1080
1081	[[ -z ${src} ]] && die "Could not locate source for '$1'"
1082	[[ -z ${sizeoff_t} ]] && die "No idea what off_t size was used for this pdv :("
1083
1084	local shrtsrc=$(basename "${src}")
1085	echo ">>> Unpacking ${shrtsrc} to ${PWD}"
1086	local metaskip=$(tail -c ${sizeoff_t} "${src}" \| hexdump -e \"%i\")
1087	local tailskip=$(tail -c $((${sizeoff_t}*2)) "${src}" \| head -c ${sizeoff_t} \| hexdump -e \"%i\")
1088
1089	# grab metadata for debug reasons
1090	local metafile=$(emktemp)
1091	tail -c +$((${metaskip}+1)) "${src}" > "${metafile}"
1092
1093	# rip out the final file name from the metadata
1094	local datafile=$(tail -c +$((${metaskip}+1)) "${src}" \| strings \| head -n 1)
1095	datafile=$(basename "${datafile}")
1096
1097	# now lets uncompress/untar the file if need be
1098	local tmpfile=$(emktemp)
1099	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \| head -c 512 > ${tmpfile}
1100
1101	local iscompressed=$(file -b "${tmpfile}")
1102	if [[ ${iscompressed:0:8} == "compress" ]] ; then
1103	iscompressed=1
1104	mv ${tmpfile}{,.Z}
1105	gunzip ${tmpfile}
1106	else
1107	iscompressed=0
1108	fi
1109	local istar=$(file -b "${tmpfile}")
1110	if [[ ${istar:0:9} == "POSIX tar" ]] ; then
1111	istar=1
1112	else
1113	istar=0
1114	fi
1115
1116	#for some reason gzip dies with this ... dd cant provide buffer fast enough ?
1117	#dd if=${src} ibs=${metaskip} count=1 \
1118	# \| dd ibs=${tailskip} skip=1 \
1119	# \| gzip -dc \
1120	# > ${datafile}
1121	if [ ${iscompressed} -eq 1 ] ; then
1122	if [ ${istar} -eq 1 ] ; then
1123	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
1124	\| head -c $((${metaskip}-${tailskip})) \
1125	\| tar -xzf -
1126	else
1127	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
1128	\| head -c $((${metaskip}-${tailskip})) \
1129	\| gzip -dc \
1130	> ${datafile}
1131	fi
1132	else
1133	if [ ${istar} -eq 1 ] ; then
1134	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
1135	\| head -c $((${metaskip}-${tailskip})) \
1136	\| tar --no-same-owner -xf -
1137	else
1138	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
1139	\| head -c $((${metaskip}-${tailskip})) \
1140	> ${datafile}
1141	fi
1142	fi
1143	true
1144	#[ -s "${datafile}" ] \|\| die "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"
1145	#assert "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"
1146	}
1147
1148	# @FUNCTION: unpack_makeself
1149	# @USAGE: [file to unpack] [offset] [tail\|dd]
1150	# @DESCRIPTION:
1151	# Unpack those pesky makeself generated files ...
1152	# They're shell scripts with the binary package tagged onto
1153	# the end of the archive. Loki utilized the format as does
1154	# many other game companies.
1155	#
1156	# If the file is not specified, then ${A} is used. If the
1157	# offset is not specified then we will attempt to extract
1158	# the proper offset from the script itself.
1159	unpack_makeself() {
1160	local src_input=${1:-${A}}
1161	local src=$(find_unpackable_file "${src_input}")
1162	local skip=$2
1163	local exe=$3
1164
1165	[[ -z ${src} ]] && die "Could not locate source for '${src_input}'"
1166
1167	local shrtsrc=$(basename "${src}")
1168	echo ">>> Unpacking ${shrtsrc} to ${PWD}"
1169	if [[ -z ${skip} ]] ; then
1170	local ver=$(grep -a '#.*Makeself' "${src}" \| awk '{print $NF}')
1171	local skip=0
1172	exe=tail
1173	case ${ver} in
1174	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)
1176	;;
1177	2.0\|2.0.1)
1178	skip=$(grep -a ^$'\t'tail "${src}" \| awk '{print $2}' \| cut -b2-)
1179	;;
1180	2.1.1)
1181	skip=$(grep -a ^offset= "${src}" \| awk '{print $2}' \| cut -b2-)
1182	let skip="skip + 1"
1183	;;
1184	2.1.2)
1185	skip=$(grep -a ^offset= "${src}" \| awk '{print $3}' \| head -n 1)
1186	let skip="skip + 1"
1187	;;
1188	2.1.3)
1189	skip=`grep -a ^offset= "${src}" \| awk '{print $3}'`
1190	let skip="skip + 1"
1191	;;
1192	2.1.4\|2.1.5)
1193	skip=$(grep -a offset=.head.wc "${src}" \| awk '{print $3}' \| head -n 1)
1194	skip=$(head -n ${skip} "${src}" \| wc -c)
1195	exe="dd"
1196	;;
1197	*)
1198	eerror "I'm sorry, but I was unable to support the Makeself file."
1199	eerror "The version I detected was '${ver}'."
1200	eerror "Please file a bug about the file ${shrtsrc} at"
1201	eerror "http://bugs.gentoo.org/ so that support can be added."
1202	die "makeself version '${ver}' not supported"
1203	;;
1204	esac
1205	debug-print "Detected Makeself version ${ver} ... using ${skip} as offset"
1206	fi
1207	case ${exe} in
1208	tail) exe="tail -n +${skip} '${src}'";;
1209	dd) exe="dd ibs=${skip} skip=1 obs=1024 conv=sync if='${src}'";;
1210	*) die "makeself cant handle exe '${exe}'"
1211	esac
1212
1213	# lets grab the first few bytes of the file to figure out what kind of archive it is
1214	local tmpfile=$(emktemp)
1215	eval ${exe} 2>/dev/null \| head -c 512 > "${tmpfile}"
1216	local filetype=$(file -b "${tmpfile}")
1217	case ${filetype} in
1218	tar\ archive)
1219	eval ${exe} \| tar --no-same-owner -xf -
1220	;;
1221	bzip2*)
1222	eval ${exe} \| bzip2 -dc \| tar --no-same-owner -xf -
1223	;;
1224	gzip*)
1225	eval ${exe} \| tar --no-same-owner -xzf -
1226	;;
1227	compress*)
1228	eval ${exe} \| gunzip \| tar --no-same-owner -xf -
1229	;;
1230	*)
1231	eerror "Unknown filetype \"${filetype}\" ?"
1232	false
1233	;;
1234	esac
1235	assert "failure unpacking (${filetype}) makeself ${shrtsrc} ('${ver}' +${skip})"
1236	}
1237
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
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	963	# Make sure that LINGUAS only contains languages that
1508	# a package can support	964	# a package can support. The first form allows you to
1509	#	965	# specify a list of LINGUAS. The -i builds a list of po
1510	# usage: strip-linguas <allow LINGUAS>	966	# files found in all the directories and uses the
1511	# strip-linguas -i <directories of .po files>	967	# intersection of the lists. The -u builds a list of po
1512	# strip-linguas -u <directories of .po files>	968	# files found in all the directories and uses the union
1513	#	969	# 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() {	970	strip-linguas() {
1520	local ls newls nols	971	local ls newls nols
1521	if [[ $1 == "-i" ]] \|\| [[ $1 == "-u" ]] ; then	972	if [[ $1 == "-i" ]] \|\| [[ $1 == "-u" ]] ; then
1522	local op=$1; shift	973	local op=$1; shift
1523	ls=$(find "$1" -name '*.po' -exec basename {} .po \;); shift	974	ls=$(find "$1" -name '*.po' -exec basename {} .po ';'); shift
1524	local d f	975	local d f
1525	for d in "$@" ; do	976	for d in "$@" ; do
1526	if [[ ${op} == "-u" ]] ; then	977	if [[ ${op} == "-u" ]] ; then
1527	newls=${ls}	978	newls=${ls}
1528	else	979	else
1529	newls=""	980	newls=""
1530	fi	981	fi
1531	for f in $(find "$d" -name '*.po' -exec basename {} .po \;) ; do	982	for f in $(find "$d" -name '*.po' -exec basename {} .po ';') ; do
1532	if [[ ${op} == "-i" ]] ; then	983	if [[ ${op} == "-i" ]] ; then
1533	hasq ${f} ${ls} && newls="${newls} ${f}"	984	has ${f} ${ls} && newls="${newls} ${f}"
1534	else	985	else
1535	hasq ${f} ${ls} \|\| newls="${newls} ${f}"	986	has ${f} ${ls} \|\| newls="${newls} ${f}"
1536	fi	987	fi
1537	done	988	done
1538	ls=${newls}	989	ls=${newls}
1539	done	990	done
1540	else	991	else
…		…
1542	fi	993	fi
1543		994
1544	nols=""	995	nols=""
1545	newls=""	996	newls=""
1546	for f in ${LINGUAS} ; do	997	for f in ${LINGUAS} ; do
1547	if hasq ${f} ${ls} ; then	998	if has ${f} ${ls} ; then
1548	newls="${newls} ${f}"	999	newls="${newls} ${f}"
1549	else	1000	else
1550	nols="${nols} ${f}"	1001	nols="${nols} ${f}"
1551	fi	1002	fi
1552	done	1003	done
1553	[[ -n ${nols} ]] \	1004	[[ -n ${nols} ]] \
1554	&& ewarn "Sorry, but ${PN} does not support the LINGUAs:" ${nols}	1005	&& einfo "Sorry, but ${PN} does not support the LINGUAS:" ${nols}
1555	export LINGUAS=${newls:1}	1006	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	}	1007	}
1587		1008
1588	# @FUNCTION: preserve_old_lib	1009	# @FUNCTION: preserve_old_lib
1589	# @USAGE: <libs to preserve> [more libs]	1010	# @USAGE: <libs to preserve> [more libs]
1590	# @DESCRIPTION:	1011	# @DESCRIPTION:
…		…
1599	eerror "preserve_old_lib() must be called from pkg_preinst() only"	1020	eerror "preserve_old_lib() must be called from pkg_preinst() only"
1600	die "Invalid preserve_old_lib() usage"	1021	die "Invalid preserve_old_lib() usage"
1601	fi	1022	fi
1602	[[ -z $1 ]] && die "Usage: preserve_old_lib <library to preserve> [more libraries to preserve]"	1023	[[ -z $1 ]] && die "Usage: preserve_old_lib <library to preserve> [more libraries to preserve]"
1603		1024
		1025	# let portage worry about it
		1026	has preserve-libs ${FEATURES} && return 0
		1027
1604	local lib dir	1028	local lib dir
1605	for lib in "$@" ; do	1029	for lib in "$@" ; do
1606	[[ -e ${ROOT}/${lib} ]] \|\| continue	1030	[[ -e ${ROOT}/${lib} ]] \|\| continue
1607	dir=${lib%/*}	1031	dir=${lib%/*}
1608	dodir ${dir} \|\| die "dodir ${dir} failed"	1032	dodir ${dir} \|\| die "dodir ${dir} failed"
…		…
1618	preserve_old_lib_notify() {	1042	preserve_old_lib_notify() {
1619	if [[ ${EBUILD_PHASE} != "postinst" ]] ; then	1043	if [[ ${EBUILD_PHASE} != "postinst" ]] ; then
1620	eerror "preserve_old_lib_notify() must be called from pkg_postinst() only"	1044	eerror "preserve_old_lib_notify() must be called from pkg_postinst() only"
1621	die "Invalid preserve_old_lib_notify() usage"	1045	die "Invalid preserve_old_lib_notify() usage"
1622	fi	1046	fi
		1047
		1048	# let portage worry about it
		1049	has preserve-libs ${FEATURES} && return 0
1623		1050
1624	local lib notice=0	1051	local lib notice=0
1625	for lib in "$@" ; do	1052	for lib in "$@" ; do
1626	[[ -e ${ROOT}/${lib} ]] \|\| continue	1053	[[ -e ${ROOT}/${lib} ]] \|\| continue
1627	if [[ ${notice} -eq 0 ]] ; then	1054	if [[ ${notice} -eq 0 ]] ; then
…		…
1631	ewarn "the libraries are not being removed. You need to run revdep-rebuild"	1058	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"	1059	ewarn "in order to remove these old dependencies. If you do not have this"
1633	ewarn "helper program, simply emerge the 'gentoolkit' package."	1060	ewarn "helper program, simply emerge the 'gentoolkit' package."
1634	ewarn	1061	ewarn
1635	fi	1062	fi
		1063	# temp hack for #348634 #357225
		1064	[[ ${PN} == "mpfr" ]] && lib=${lib##*/}
1636	ewarn " # revdep-rebuild --library ${lib##*/}"	1065	ewarn " # revdep-rebuild --library '${lib}'"
1637	done	1066	done
		1067	if [[ ${notice} -eq 1 ]] ; then
		1068	ewarn
		1069	ewarn "Once you've finished running revdep-rebuild, it should be safe to"
		1070	ewarn "delete the old libraries. Here is a copy & paste for the lazy:"
		1071	for lib in "$@" ; do
		1072	ewarn " # rm '${lib}'"
		1073	done
		1074	fi
1638	}	1075	}
1639		1076
1640	# @FUNCTION: built_with_use	1077	# @FUNCTION: built_with_use
1641	# @USAGE: [--hidden] [--missing <action>] [-a\|-o] <DEPEND ATOM> <List of USE flags>	1078	# @USAGE: [--hidden] [--missing <action>] [-a\|-o] <DEPEND ATOM> <List of USE flags>
1642	# @DESCRIPTION:	1079	# @DESCRIPTION:
		1080	#
		1081	# Deprecated: Use EAPI 2 use deps in DEPEND\|RDEPEND and with has_version calls.
		1082	#
1643	# A temporary hack until portage properly supports DEPENDing on USE	1083	# A temporary hack until portage properly supports DEPENDing on USE
1644	# flags being enabled in packages. This will check to see if the specified	1084	# 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	1085	# 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	1086	# --missing option controls the behavior if called on a package that does
1647	# not actually support the defined USE flags (aka listed in IUSE).	1087	# 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	1088	# 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"	1089	# 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	1090	# 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	1091	# 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	1092	# 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	1093	# means the USE flag we're checking is hidden expanded, so it won't be found
1654	# in IUSE like normal USE flags.	1094	# in IUSE like normal USE flags.
1655	#	1095	#
1656	# Remember that this function isn't terribly intelligent so order of optional	1096	# Remember that this function isn't terribly intelligent so order of optional
1657	# flags matter.	1097	# flags matter.
1658	built_with_use() {	1098	built_with_use() {
1659	local hidden="no"	1099	local hidden="no"
1660	if [[ $1 == "--hidden" ]] ; then	1100	if [[ $1 == "--hidden" ]] ; then
…		…
1691	die) die "Unable to determine what USE flags $PKG was built with";;	1131	die) die "Unable to determine what USE flags $PKG was built with";;
1692	esac	1132	esac
1693	fi	1133	fi
1694		1134
1695	if [[ ${hidden} == "no" ]] ; then	1135	if [[ ${hidden} == "no" ]] ; then
1696	local IUSE_BUILT=$(<${IUSEFILE})	1136	local IUSE_BUILT=( $(<"${IUSEFILE}") )
1697	# Don't check USE_EXPAND #147237	1137	# Don't check USE_EXPAND #147237
1698	local expand	1138	local expand
1699	for expand in $(echo ${USE_EXPAND} \| tr '[:upper:]' '[:lower:]') ; do	1139	for expand in $(echo ${USE_EXPAND} \| tr '[:upper:]' '[:lower:]') ; do
1700	if [[ $1 == ${expand}_* ]] ; then	1140	if [[ $1 == ${expand}_* ]] ; then
1701	expand=""	1141	expand=""
1702	break	1142	break
1703	fi	1143	fi
1704	done	1144	done
1705	if [[ -n ${expand} ]] ; then	1145	if [[ -n ${expand} ]] ; then
1706	if ! has $1 ${IUSE_BUILT} ; then	1146	if ! has $1 ${IUSE_BUILT[@]#[-+]} ; then
1707	case ${missing_action} in	1147	case ${missing_action} in
1708	true) return 0;;	1148	true) return 0;;
1709	false) return 1;;	1149	false) return 1;;
1710	die) die "$PKG does not actually support the $1 USE flag!";;	1150	die) die "$PKG does not actually support the $1 USE flag!";;
1711	esac	1151	esac
…		…
1723	shift	1163	shift
1724	done	1164	done
1725	[[ ${opt} = "-a" ]]	1165	[[ ${opt} = "-a" ]]
1726	}	1166	}
1727		1167
1728	# @DESCRIPTION: epunt_cxx	1168	# @FUNCTION: epunt_cxx
1729	# @USAGE: [dir to scan]	1169	# @USAGE: [dir to scan]
1730	# @DESCRIPTION:	1170	# @DESCRIPTION:
1731	# Many configure scripts wrongly bail when a C++ compiler could not be	1171	# Many configure scripts wrongly bail when a C++ compiler could not be
1732	# detected. If dir is not specified, then it defaults to ${S}.	1172	# detected. If dir is not specified, then it defaults to ${S}.
1733	#	1173	#
…		…
1735	epunt_cxx() {	1175	epunt_cxx() {
1736	local dir=$1	1176	local dir=$1
1737	[[ -z ${dir} ]] && dir=${S}	1177	[[ -z ${dir} ]] && dir=${S}
1738	ebegin "Removing useless C++ checks"	1178	ebegin "Removing useless C++ checks"
1739	local f	1179	local f
1740	for f in $(find ${dir} -name configure) ; do	1180	find "${dir}" -name configure \| while read f ; do
1741	patch -p0 "${f}" "${PORTDIR}/eclass/ELT-patches/nocxx/nocxx.patch" > /dev/null	1181	patch --no-backup-if-mismatch -p0 "${f}" "${PORTDIR}/eclass/ELT-patches/nocxx/nocxx.patch" > /dev/null
1742	done	1182	done
1743	eend 0	1183	eend 0
1744	}	1184	}
1745		1185
1746	# @FUNCTION: make_wrapper	1186	# @FUNCTION: make_wrapper
1747	# @USAGE: <wrapper> <target> <chdir> [libpaths] [installpath]	1187	# @USAGE: <wrapper> <target> [chdir] [libpaths] [installpath]
1748	# @DESCRIPTION:	1188	# @DESCRIPTION:
1749	# Create a shell wrapper script named wrapper in installpath	1189	# Create a shell wrapper script named wrapper in installpath
1750	# (defaults to the bindir) to execute target (default of wrapper) by	1190	# (defaults to the bindir) to execute target (default of wrapper) by
1751	# first optionally setting LD_LIBRARY_PATH to the colon-delimited	1191	# first optionally setting LD_LIBRARY_PATH to the colon-delimited
1752	# libpaths followed by optionally changing directory to chdir.	1192	# libpaths followed by optionally changing directory to chdir.
…		…
1775	) \|\| die	1215	) \|\| die
1776	else	1216	else
1777	newbin "${tmpwrapper}" "${wrapper}" \|\| die	1217	newbin "${tmpwrapper}" "${wrapper}" \|\| die
1778	fi	1218	fi
1779	}	1219	}
		1220
		1221	# @FUNCTION: path_exists
		1222	# @USAGE: [-a\|-o] <paths>
		1223	# @DESCRIPTION:
		1224	# Check if the specified paths exist. Works for all types of paths
		1225	# (files/dirs/etc...). The -a and -o flags control the requirements
		1226	# of the paths. They correspond to "and" and "or" logic. So the -a
		1227	# flag means all the paths must exist while the -o flag means at least
		1228	# one of the paths must exist. The default behavior is "and". If no
		1229	# paths are specified, then the return value is "false".
		1230	path_exists() {
		1231	local opt=$1
		1232	[[ ${opt} == -[ao] ]] && shift \|\| opt="-a"
		1233
		1234	# no paths -> return false
		1235	# same behavior as: [[ -e "" ]]
		1236	[[ $# -eq 0 ]] && return 1
		1237
		1238	local p r=0
		1239	for p in "$@" ; do
		1240	[[ -e ${p} ]]
		1241	: $(( r += $? ))
		1242	done
		1243
		1244	case ${opt} in
		1245	-a) return $(( r != 0 )) ;;
		1246	-o) return $(( r == $# )) ;;
		1247	esac
		1248	}
		1249
		1250	# @FUNCTION: in_iuse
		1251	# @USAGE: <flag>
		1252	# @DESCRIPTION:
		1253	# Determines whether the given flag is in IUSE. Strips IUSE default prefixes
		1254	# as necessary.
		1255	#
		1256	# Note that this function should not be used in the global scope.
		1257	in_iuse() {
		1258	debug-print-function ${FUNCNAME} "${@}"
		1259	[[ ${#} -eq 1 ]] \|\| die "Invalid args to ${FUNCNAME}()"
		1260
		1261	local flag=${1}
		1262	local liuse=( ${IUSE} )
		1263
		1264	has "${flag}" "${liuse[@]#[+-]}"
		1265	}
		1266
		1267	# @FUNCTION: use_if_iuse
		1268	# @USAGE: <flag>
		1269	# @DESCRIPTION:
		1270	# Return true if the given flag is in USE and IUSE.
		1271	#
		1272	# Note that this function should not be used in the global scope.
		1273	use_if_iuse() {
		1274	in_iuse $1 \|\| return 1
		1275	use $1
		1276	}
		1277
		1278	# @FUNCTION: usex
		1279	# @USAGE: <USE flag> [true output] [false output] [true suffix] [false suffix]
		1280	# @DESCRIPTION:
		1281	# If USE flag is set, echo [true output][true suffix] (defaults to "yes"),
		1282	# otherwise echo [false output][false suffix] (defaults to "no").
		1283	usex() { use "$1" && echo "${2-yes}$4" \|\| echo "${3-no}$5" ; } #382963
		1284
		1285	# @FUNCTION: makeopts_jobs
		1286	# @USAGE: [${MAKEOPTS}]
		1287	# @DESCRIPTION:
		1288	# Searches the arguments (defaults to ${MAKEOPTS}) and extracts the jobs number
		1289	# specified therein. i.e. if the user has MAKEOPTS=-j9, this will show "9".
		1290	# We can't return the number as bash normalizes it to [0, 255]. If the flags
		1291	# haven't specified a -j flag, then "1" is shown as that is the default `make`
		1292	# uses. Useful for running non-make tools in parallel too.
		1293	makeopts_jobs() {
		1294	[[ $# -eq 0 ]] && set -- ${MAKEOPTS}
		1295	local x jobs
		1296	for x ; do [[ ${x} == -j* ]] && jobs=${x#-j} ; done
		1297	echo ${jobs:-1}
		1298	}
		1299
		1300	check_license() { die "you no longer need this as portage supports ACCEPT_LICENSE itself"; }
		1301
		1302	fi

 Legend:



Removed from v.1.284
 


changed lines


 
Added in v.1.390
 Legend:



Removed from v.1.284
 


changed lines


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

	ViewVC Help
Powered by ViewVC 1.1.13