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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

Revision 1.92		Revision 1.388
1	# Copyright 1999-2004 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.92 2004/08/03 17:24:52 vapier Exp $	3	# $Header: /var/cvsroot/gentoo-x86/eclass/eutils.eclass,v 1.388 2012/04/02 22:13:57 pacho Exp $
4	#
5	# Author: Martin Schlemmer <azarah@gentoo.org>
6	#
7	# This eclass is for general purpose functions that most ebuilds
8	# have to implement themselves.
9	#
10	# NB: If you add anything, please comment it!
11		4
12	ECLASS=eutils	5	# @ECLASS: eutils.eclass
13	INHERITED="$INHERITED $ECLASS"	6	# @MAINTAINER:
		7	# base-system@gentoo.org
		8	# @BLURB: many extra (but common) functions that are used in ebuilds
		9	# @DESCRIPTION:
		10	# The eutils eclass contains a suite of functions that complement
		11	# the ones that ebuild.sh already contain. The idea is that the functions
		12	# are not required in all ebuilds but enough utilize them to have a common
		13	# home rather than having multiple ebuilds implementing the same thing.
		14	#
		15	# Due to the nature of this eclass, some functions may have maintainers
		16	# different from the overall eclass!
14		17
15	DEPEND="!bootstrap? ( sys-devel/patch )"	18	if [[ ${___ECLASS_ONCE_EUTILS} != "recur -_+^+_- spank" ]] ; then
		19	___ECLASS_ONCE_EUTILS="recur -_+^+_- spank"
		20
		21	inherit multilib user
16		22
17	DESCRIPTION="Based on the ${ECLASS} eclass"	23	DESCRIPTION="Based on the ${ECLASS} eclass"
18		24
19	# This function generate linker scripts in /usr/lib for dynamic	25	if has "${EAPI:-0}" 0 1 2; then
20	# libs in /lib. This is to fix linking problems when you have
21	# the .so in /lib, and the .a in /usr/lib. What happens is that
22	# in some cases when linking dynamic, the .a in /usr/lib is used
23	# instead of the .so in /lib due to gcc/libtool tweaking ld's
24	# library search path. This cause many builds to fail.
25	# See bug #4411 for more info.
26	#
27	# To use, simply call:
28	#
29	# gen_usr_ldscript libfoo.so
30	#
31	# Note that you should in general use the unversioned name of
32	# the library, as ldconfig should usually update it correctly
33	# to point to the latest version of the library present.
34	#
35	# <azarah@gentoo.org> (26 Oct 2002)
36	#
37	gen_usr_ldscript() {
38		26
39	# Just make sure it exists	27	# @FUNCTION: epause
40	dodir /usr/lib	28	# @USAGE: [seconds]
41		29	# @DESCRIPTION:
42	cat > ${D}/usr/lib/$1 <<"END_LDSCRIPT"	30	# Sleep for the specified number of seconds (default of 5 seconds). Useful when
43	/* GNU ld script	31	# printing a message the user should probably be reading and often used in
44	Because Gentoo have critical dynamic libraries	32	# conjunction with the ebeep function. If the EPAUSE_IGNORE env var is set,
45	in /lib, and the static versions in /usr/lib, we	33	# don't wait at all. Defined in EAPIs 0 1 and 2.
46	need to have a "fake" dynamic lib in /usr/lib,	34	epause() {
47	otherwise we run into linking problems.	35	[[ -z ${EPAUSE_IGNORE} ]] && sleep ${1:-5}
48	See bug #4411 on http://bugs.gentoo.org/ for
49	more info. */
50	GROUP ( /lib/libxxx )
51	END_LDSCRIPT
52
53	dosed "s:libxxx:$1:" /usr/lib/$1
54
55	return 0
56	}	36	}
57		37
58	# Simple function to draw a line consisting of '=' the same length as $*	38	# @FUNCTION: ebeep
59	#	39	# @USAGE: [number of beeps]
60	# <azarah@gentoo.org> (11 Nov 2002)	40	# @DESCRIPTION:
61	#	41	# Issue the specified number of beeps (default of 5 beeps). Useful when
62	draw_line() {	42	# printing a message the user should probably be reading and often used in
		43	# conjunction with the epause function. If the EBEEP_IGNORE env var is set,
		44	# don't beep at all. Defined in EAPIs 0 1 and 2.
		45	ebeep() {
63	local i=0	46	local n
64	local str_length=""	47	if [[ -z ${EBEEP_IGNORE} ]] ; then
65		48	for ((n=1 ; n <= ${1:-5} ; n++)) ; do
66	# Handle calls that do not have args, or wc not being installed ...
67	if [ -z "$1" -o ! -x "$(which wc 2>/dev/null)" ]
68	then
69	echo "==============================================================="
70	return 0
71	fi
72
73	# Get the length of $*
74	str_length="$(echo -n "$*" \| wc -m)"
75
76	while [ "$i" -lt "${str_length}" ]
77	do
78	echo -n "="	49	echo -ne "\a"
79		50	sleep 0.1 &>/dev/null ; sleep 0,1 &>/dev/null
80	i=$((i + 1))	51	echo -ne "\a"
		52	sleep 1
81	done	53	done
		54	fi
		55	}
82		56
83	echo	57	else
84		58
		59	ebeep() {
		60	ewarn "QA Notice: ebeep is not defined in EAPI=${EAPI}, please file a bug at http://bugs.gentoo.org"
		61	}
		62
		63	epause() {
		64	ewarn "QA Notice: epause is not defined in EAPI=${EAPI}, please file a bug at http://bugs.gentoo.org"
		65	}
		66
		67	fi
		68
		69	# @FUNCTION: eqawarn
		70	# @USAGE: [message]
		71	# @DESCRIPTION:
		72	# Proxy to ewarn for package managers that don't provide eqawarn and use the PM
		73	# implementation if available. Reuses PORTAGE_ELOG_CLASSES as set by the dev
		74	# profile.
		75	if ! declare -F eqawarn >/dev/null ; then
		76	eqawarn() {
		77	has qa ${PORTAGE_ELOG_CLASSES} && ewarn "$@"
		78	:
		79	}
		80	fi
		81
		82	# @FUNCTION: ecvs_clean
		83	# @USAGE: [list of dirs]
		84	# @DESCRIPTION:
		85	# Remove CVS directories recursiveley. Useful when a source tarball contains
		86	# internal CVS directories. Defaults to $PWD.
		87	ecvs_clean() {
		88	[[ -z $* ]] && set -- .
		89	find "$@" -type d -name 'CVS' -prune -print0 \| xargs -0 rm -rf
		90	find "$@" -type f -name '.cvs*' -print0 \| xargs -0 rm -rf
		91	}
		92
		93	# @FUNCTION: esvn_clean
		94	# @USAGE: [list of dirs]
		95	# @DESCRIPTION:
		96	# Remove .svn directories recursiveley. Useful when a source tarball contains
		97	# internal Subversion directories. Defaults to $PWD.
		98	esvn_clean() {
		99	[[ -z $* ]] && set -- .
		100	find "$@" -type d -name '.svn' -prune -print0 \| xargs -0 rm -rf
		101	}
		102
		103	# @FUNCTION: estack_push
		104	# @USAGE: <stack> [items to push]
		105	# @DESCRIPTION:
		106	# Push any number of items onto the specified stack. Pick a name that
		107	# is a valid variable (i.e. stick to alphanumerics), and push as many
		108	# items as you like onto the stack at once.
		109	#
		110	# The following code snippet will echo 5, then 4, then 3, then ...
		111	# @CODE
		112	# estack_push mystack 1 2 3 4 5
		113	# while estack_pop mystack i ; do
		114	# echo "${i}"
		115	# done
		116	# @CODE
		117	estack_push() {
		118	[[ $# -eq 0 ]] && die "estack_push: incorrect # of arguments"
		119	local stack_name="__ESTACK_$1__" ; shift
		120	eval ${stack_name}+=$ \"\$@\" $
		121	}
		122
		123	# @FUNCTION: estack_pop
		124	# @USAGE: <stack> [variable]
		125	# @DESCRIPTION:
		126	# Pop a single item off the specified stack. If a variable is specified,
		127	# the popped item is stored there. If no more items are available, return
		128	# 1, else return 0. See estack_push for more info.
		129	estack_pop() {
		130	[[ $# -eq 0 \|\| $# -gt 2 ]] && die "estack_pop: incorrect # of arguments"
		131
		132	# We use the fugly __estack_xxx var names to avoid collision with
		133	# passing back the return value. If we used "local i" and the
		134	# caller ran `estack_pop ... i`, we'd end up setting the local
		135	# copy of "i" rather than the caller's copy. The __estack_xxx
		136	# garbage is preferable to using $1/$2 everywhere as that is a
		137	# bit harder to read.
		138	local __estack_name="__ESTACK_$1__" ; shift
		139	local __estack_retvar=$1 ; shift
		140	eval local __estack_i=\${#${__estack_name}\[@\]}
		141	# Don't warn -- let the caller interpret this as a failure
		142	# or as normal behavior (akin to `shift`)
		143	[[ $(( --__estack_i )) -eq -1 ]] && return 1
		144
		145	if [[ -n ${__estack_retvar} ]] ; then
		146	eval ${__estack_retvar}=\"\${${__estack_name}\[${__estack_i}\]}\"
		147	fi
		148	eval unset ${__estack_name}\[${__estack_i}\]
		149	}
		150
		151	# @FUNCTION: eshopts_push
		152	# @USAGE: [options to `set` or `shopt`]
		153	# @DESCRIPTION:
		154	# Often times code will want to enable a shell option to change code behavior.
		155	# Since changing shell options can easily break other pieces of code (which
		156	# assume the default state), eshopts_push is used to (1) push the current shell
		157	# options onto a stack and (2) pass the specified arguments to set.
		158	#
		159	# If the first argument is '-s' or '-u', we assume you want to call `shopt`
		160	# rather than `set` as there are some options only available via that.
		161	#
		162	# A common example is to disable shell globbing so that special meaning/care
		163	# may be used with variables/arguments to custom functions. That would be:
		164	# @CODE
		165	# eshopts_push -s noglob
		166	# for x in ${foo} ; do
		167	# if ...some check... ; then
		168	# eshopts_pop
85	return 0	169	# return 0
		170	# fi
		171	# done
		172	# eshopts_pop
		173	# @CODE
		174	eshopts_push() {
		175	if [[ $1 == -[su] ]] ; then
		176	estack_push eshopts "$(shopt -p)"
		177	[[ $# -eq 0 ]] && return 0
		178	shopt "$@" \|\| die "${FUNCNAME}: bad options to shopt: $*"
		179	else
		180	estack_push eshopts $-
		181	[[ $# -eq 0 ]] && return 0
		182	set "$@" \|\| die "${FUNCNAME}: bad options to set: $*"
		183	fi
86	}	184	}
87		185
88	# Default directory where patches are located	186	# @FUNCTION: eshopts_pop
		187	# @USAGE:
		188	# @DESCRIPTION:
		189	# Restore the shell options to the state saved with the corresponding
		190	# eshopts_push call. See that function for more details.
		191	eshopts_pop() {
		192	local s
		193	estack_pop eshopts s \|\| die "${FUNCNAME}: unbalanced push"
		194	if [[ ${s} == "shopt -"* ]] ; then
		195	eval "${s}" \|\| die "${FUNCNAME}: sanity: invalid shopt options: ${s}"
		196	else
		197	set +$- \|\| die "${FUNCNAME}: sanity: invalid shell settings: $-"
		198	set -${s} \|\| die "${FUNCNAME}: sanity: unable to restore saved shell settings: ${s}"
		199	fi
		200	}
		201
		202	# @FUNCTION: eumask_push
		203	# @USAGE: <new umask>
		204	# @DESCRIPTION:
		205	# Set the umask to the new value specified while saving the previous
		206	# value onto a stack. Useful for temporarily changing the umask.
		207	eumask_push() {
		208	estack_push eumask "$(umask)"
		209	umask "$@" \|\| die "${FUNCNAME}: bad options to umask: $*"
		210	}
		211
		212	# @FUNCTION: eumask_pop
		213	# @USAGE:
		214	# @DESCRIPTION:
		215	# Restore the previous umask state.
		216	eumask_pop() {
		217	[[ $# -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.
89	EPATCH_SOURCE="${WORKDIR}/patch"	226	EPATCH_SOURCE="${WORKDIR}/patch"
90	# Default extension for patches	227	# @VARIABLE: EPATCH_SUFFIX
		228	# @DESCRIPTION:
		229	# Default extension for patches (do not prefix the period yourself).
91	EPATCH_SUFFIX="patch.bz2"	230	EPATCH_SUFFIX="patch.bz2"
		231	# @VARIABLE: EPATCH_OPTS
		232	# @DESCRIPTION:
92	# Default options for patch	233	# Default options for patch:
		234	# @CODE
93	# Set -g0 to keep RCS, ClearCase, Perforce and SCCS happy. Bug #24571	235	# -g0 - keep RCS, ClearCase, Perforce and SCCS happy #24571
94	EPATCH_OPTS="-g0"	236	# --no-backup-if-mismatch - do not leave .orig files behind
		237	# -E - automatically remove empty files
		238	# @CODE
		239	EPATCH_OPTS="-g0 -E --no-backup-if-mismatch"
		240	# @VARIABLE: EPATCH_EXCLUDE
		241	# @DESCRIPTION:
95	# 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,
96	# and not the full path ..	243	# and not the full path. Globs accepted.
97	EPATCH_EXCLUDE=""	244	EPATCH_EXCLUDE=""
		245	# @VARIABLE: EPATCH_SINGLE_MSG
		246	# @DESCRIPTION:
98	# Change the printed message for a single patch.	247	# Change the printed message for a single patch.
99	EPATCH_SINGLE_MSG=""	248	EPATCH_SINGLE_MSG=""
100	# Force applying bulk patches even if not following the style:	249	# @VARIABLE: EPATCH_MULTI_MSG
101	#	250	# @DESCRIPTION:
102	# ??_${ARCH}_foo.${EPATCH_SUFFIX}	251	# Change the printed message for multiple patches.
103	#	252	EPATCH_MULTI_MSG="Applying various patches (bugfixes/updates) ..."
		253	# @VARIABLE: EPATCH_FORCE
		254	# @DESCRIPTION:
		255	# Only require patches to match EPATCH_SUFFIX rather than the extended
		256	# arch naming style.
104	EPATCH_FORCE="no"	257	EPATCH_FORCE="no"
105		258
106	# This function is for bulk patching, or in theory for just one	259	# @FUNCTION: epatch
107	# 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.
108	#	267	#
109	# 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
110	# Currently all patches should be the same format.	269	# specified by EPATCH_SOURCE.
111	#	270	#
112	# You do not have to specify '-p' option to patch, as it will	271	# When processing directories, epatch will apply all patches that match:
113	# try with -p0 to -p5 until it succeed, or fail at -p5.	272	# @CODE
114	#	273	# if ${EPATCH_FORCE} != "yes"
115	# Above EPATCH_* variables can be used to control various defaults,
116	# bug they should be left as is to ensure an ebuild can rely on
117	# them for.
118	#
119	# Patches are applied in current directory.
120	#
121	# Bulk Patches should preferibly have the form of:
122	#
123	# ??_${ARCH}_foo.${EPATCH_SUFFIX}	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.
124	#	283	#
125	# For example:	284	# If EPATCH_SUFFIX is empty, then no period before it is implied when searching
		285	# for patches to apply.
126	#	286	#
127	# 01_all_misc-fix.patch.bz2	287	# Refer to the other EPATCH_xxx variables for more customization of behavior.
128	# 02_sparc_another-fix.patch.bz2
129	#
130	# This ensures that there are a set order, and you can have ARCH
131	# specific patches.
132	#
133	# If you however give an argument to epatch(), it will treat it as a
134	# single patch that need to be applied if its a file. If on the other
135	# hand its a directory, it will set EPATCH_SOURCE to this.
136	#
137	# <azarah@gentoo.org> (10 Nov 2002)
138	#
139	epatch() {	288	epatch() {
140	local PIPE_CMD=""	289	_epatch_draw_line() {
141	local STDERR_TARGET="${T}/$$.out"	290	# create a line of same length as input string
142	local PATCH_TARGET="${T}/$$.patch"	291	[[ -z $1 ]] && set "$(printf "%65s" '')"
143	local PATCH_SUFFIX=""	292	echo "${1//?/=}"
		293	}
		294
		295	unset P4CONFIG P4PORT P4USER # keep perforce at bay #56402
		296
		297	# Let the rest of the code process one user arg at a time --
		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
		301	local m
		302	for m in "$@" ; do
		303	epatch "${m}"
		304	done
		305	return 0
		306	fi
		307
144	local SINGLE_PATCH="no"	308	local SINGLE_PATCH="no"
145	local x=""	309	# no args means process ${EPATCH_SOURCE}
		310	[[ $# -eq 0 ]] && set -- "${EPATCH_SOURCE}"
146		311
147	if [ "$#" -gt 1 ]	312	if [[ -f $1 ]] ; then
148	then
149	eerror "Invalid arguments to epatch()"
150	die "Invalid arguments to epatch()"
151	fi
152
153	if [ -n "$1" -a -f "$1" ]
154	then
155	SINGLE_PATCH="yes"	313	SINGLE_PATCH="yes"
156		314	set -- "$1"
157	local EPATCH_SOURCE="$1"	315	# Use the suffix from the single patch (localize it); the code
		316	# below will find the suffix for us
158	local EPATCH_SUFFIX="${1##*\.}"	317	local EPATCH_SUFFIX=$1
159		318
160	elif [ -n "$1" -a -d "$1" ]	319	elif [[ -d $1 ]] ; then
161	then	320	# Some people like to make dirs of patches w/out suffixes (vim)
162	# Allow no extension if EPATCH_FORCE=yes ... used by vim for example ...	321	set -- "$1"/*${EPATCH_SUFFIX:+."${EPATCH_SUFFIX}"}
163	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} ]]
164	then	370	then
165	local EPATCH_SOURCE="$1/*"	371	continue
166	else
167	local EPATCH_SOURCE="$1/*.${EPATCH_SUFFIX}"
168	fi
169	else
170	if [ ! -d ${EPATCH_SOURCE} ]
171	then
172	if [ -n "$1" -a "${EPATCH_SOURCE}" = "${WORKDIR}/patch" ]
173	then
174	EPATCH_SOURCE="$1"
175	fi	372	fi
176		373
177	echo	374	# Let people filter things dynamically
178	eerror "Cannot find \$EPATCH_SOURCE! Value for \$EPATCH_SOURCE is:"
179	eerror
180	eerror " ${EPATCH_SOURCE}"
181	echo
182	die "Cannot find \$EPATCH_SOURCE!"
183	fi
184
185	local EPATCH_SOURCE="${EPATCH_SOURCE}/*.${EPATCH_SUFFIX}"
186	fi
187
188	case ${EPATCH_SUFFIX##*\.} in
189	bz2)
190	PIPE_CMD="bzip2 -dc"
191	PATCH_SUFFIX="bz2"
192	;;
193	gz\|Z\|z)
194	PIPE_CMD="gzip -dc"
195	PATCH_SUFFIX="gz"
196	;;
197	ZIP\|zip)
198	PIPE_CMD="unzip -p"
199	PATCH_SUFFIX="zip"
200	;;
201	*)
202	PIPE_CMD="cat"
203	PATCH_SUFFIX="patch"
204	;;
205	esac
206
207	if [ "${SINGLE_PATCH}" = "no" ]
208	then
209	einfo "Applying various patches (bugfixes/updates)..."
210	fi
211	for x in ${EPATCH_SOURCE}
212	do
213	# New ARCH dependant patch naming scheme...
214	#
215	# ???_arch_foo.patch
216	#
217	if [ -f ${x} ] && \
218	([ "${SINGLE_PATCH}" = "yes" -o "${x/_all_}" != "${x}" -o "`eval echo \$\{x/_${ARCH}_\}`" != "${x}" ] \|\| \
219	[ "${EPATCH_FORCE}" = "yes" ])
220	then
221	local count=0
222	local popts="${EPATCH_OPTS}"
223
224	if [ -n "${EPATCH_EXCLUDE}" ]	375	if [[ -n ${EPATCH_EXCLUDE} ]] ; then
225	then	376	# let people use globs in the exclude
226	if [ "`eval echo \$\{EPATCH_EXCLUDE/${x##*/}\}`" != "${EPATCH_EXCLUDE}" ]	377	eshopts_push -o noglob
227	then	378
		379	local ex
		380	for ex in ${EPATCH_EXCLUDE} ; do
		381	if [[ ${patchname} == ${ex} ]] ; then
		382	eshopts_pop
228	continue	383	continue 2
229	fi	384	fi
		385	done
		386
		387	eshopts_pop
230	fi	388	fi
231		389
232	if [ "${SINGLE_PATCH}" = "yes" ]	390	if [[ ${SINGLE_PATCH} == "yes" ]] ; then
233	then
234	if [ -n "${EPATCH_SINGLE_MSG}" ]	391	if [[ -n ${EPATCH_SINGLE_MSG} ]] ; then
235	then
236	einfo "${EPATCH_SINGLE_MSG}"	392	einfo "${EPATCH_SINGLE_MSG}"
237	else
238	einfo "Applying ${x##*/}..."
239	fi
240	else	393	else
241	einfo " ${x##*/}..."	394	einfo "Applying ${patchname} ..."
242	fi
243
244	echo "***** ${x##/} ***" > ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}
245	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
246
247	# Allow for prefix to differ ... im lazy, so shoot me :/
248	while [ "${count}" -lt 5 ]
249	do
250	# Generate some useful debug info ...
251	draw_line "***** ${x##/} ***" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}
252	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
253
254	if [ "${PATCH_SUFFIX}" != "patch" ]
255	then
256	echo -n "PIPE_COMMAND: " >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
257	echo "${PIPE_CMD} ${x} > ${PATCH_TARGET}" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
258	else
259	PATCH_TARGET="${x}"
260	fi
261
262	echo -n "PATCH COMMAND: " >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
263	echo "patch -p${count} ${popts} < ${PATCH_TARGET}" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
264
265	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
266	draw_line "***** ${x##/} ***" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}
267
268	if [ "${PATCH_SUFFIX}" != "patch" ]
269	then
270	if ! (${PIPE_CMD} ${x} > ${PATCH_TARGET}) >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/} 2>&1
271	then
272	echo
273	eerror "Could not extract patch!"
274	#die "Could not extract patch!"
275	count=5
276	break
277	fi
278	fi
279
280	if (cat ${PATCH_TARGET} \| patch -p${count} ${popts} --dry-run -f) >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/} 2>&1
281	then
282	draw_line "***** ${x##/} ***" > ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}.real
283	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}.real
284	echo "ACTUALLY APPLYING ${x##/}..." >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}.real
285	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}.real
286	draw_line "***** ${x##/} ***" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}.real
287
288	cat ${PATCH_TARGET} \| patch -p${count} ${popts} >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}.real 2>&1
289
290	if [ "$?" -ne 0 ]
291	then
292	cat ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}.real >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}
293	echo
294	eerror "A dry-run of patch command succeeded, but actually"
295	eerror "applying the patch failed!"
296	#die "Real world sux compared to the dreamworld!"
297	count=5
298	fi
299
300	rm -f ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}.real
301
302	break
303	fi
304
305	count=$((count + 1))
306	done
307
308	if [ "${PATCH_SUFFIX}" != "patch" ]
309	then
310	rm -f ${PATCH_TARGET}
311	fi
312
313	if [ "${count}" -eq 5 ]
314	then
315	echo
316	eerror "Failed Patch: ${x##*/}!"
317	eerror
318	eerror "Include in your bugreport the contents of:"
319	eerror
320	eerror " ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}"
321	echo
322	die "Failed Patch: ${x##*/}!"
323	fi
324
325	rm -f ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
326
327	eend 0
328	fi
329	done
330	if [ "${SINGLE_PATCH}" = "no" ]
331	then
332	einfo "Done with patching"
333	fi
334	}
335
336	# This function return true if we are using the NPTL pthreads
337	# implementation.
338	#
339	# <azarah@gentoo.org> (06 March 2003)
340	#
341
342	have_NPTL() {
343
344	cat > ${T}/test-nptl.c <<-"END"
345	#define _XOPEN_SOURCE
346	#include <unistd.h>
347	#include <stdio.h>
348
349	int main()
350	{
351	char buf[255];
352	char *str = buf;
353
354	confstr(_CS_GNU_LIBPTHREAD_VERSION, str, 255);
355	if (NULL != str) {
356	printf("%s\n", str);
357	if (NULL != strstr(str, "NPTL"))
358	return 0;
359	}
360
361	return 1;
362	}
363	END
364
365	einfon "Checking for _CS_GNU_LIBPTHREAD_VERSION support in glibc ... "
366	if gcc -o ${T}/nptl ${T}/test-nptl.c &> /dev/null
367	then
368	echo "yes"
369	einfon "Checking what PTHREADS implementation we have ... "
370	if ${T}/nptl
371	then
372	return 0
373	else
374	return 1
375	fi
376	else
377	echo "no"
378	fi
379
380	return 1
381	}
382
383	# This function check how many cpu's are present, and then set
384	# -j in MAKEOPTS accordingly.
385	#
386	# Thanks to nall <nall@gentoo.org> for this.
387	#
388	get_number_of_jobs() {
389	local jobs=0
390
391	if [ ! -r /proc/cpuinfo ]
392	then
393	return 1
394	fi
395
396	# This bit is from H?kan Wessberg <nacka-gentoo@refug.org>, bug #13565.
397	if [ "`egrep "^[[:space:]]*MAKEOPTS=" /etc/make.conf \| wc -l`" -gt 0 ]
398	then
399	ADMINOPTS="`egrep "^[[:space:]]*MAKEOPTS=" /etc/make.conf \| cut -d= -f2 \| sed 's/\"//g'`"
400	ADMINPARAM="`echo ${ADMINOPTS} \| gawk '{match($0, /-j [0-9]/, opt); print opt[0]}'`"
401	ADMINPARAM="${ADMINPARAM/-j}"
402	fi
403
404	export MAKEOPTS="`echo ${MAKEOPTS} \| sed -e 's:-j [0-9]::g'`"
405
406	if [ "${ARCH}" = "amd64" -o "${ARCH}" = "x86" -o "${ARCH}" = "hppa" -o \
407	"${ARCH}" = "arm" -o "${ARCH}" = "mips" -o "${ARCH}" = "ia64" ]
408	then
409	# these archs will always have "[Pp]rocessor"
410	jobs="$((`grep -c ^[Pp]rocessor /proc/cpuinfo` * 2))"
411
412	elif [ "${ARCH}" = "sparc" -o "${ARCH}" = "sparc64" ]
413	then
414	# sparc always has "ncpus active"
415	jobs="$((`grep "^ncpus active" /proc/cpuinfo \| sed -e "s/^.: //"` 2))"
416
417	elif [ "${ARCH}" = "alpha" ]
418	then
419	# alpha has "cpus active", but only when compiled with SMP
420	if [ "`grep -c "^cpus active" /proc/cpuinfo`" -eq 1 ]
421	then
422	jobs="$((`grep "^cpus active" /proc/cpuinfo \| sed -e "s/^.: //"` 2))"
423	else
424	jobs=2
425	fi
426
427	elif [ "${ARCH}" = "ppc" -o "${ARCH}" = "ppc64" ]
428	then
429	# ppc has "processor", but only when compiled with SMP
430	if [ "`grep -c "^processor" /proc/cpuinfo`" -eq 1 ]
431	then
432	jobs="$((`grep -c ^processor /proc/cpuinfo` * 2))"
433	else
434	jobs=2
435	fi
436	elif [ "${ARCH}" = "s390" ]
437	then
438	# s390 has "# processors : "
439	jobs="$((`grep "^\# processors" /proc/cpuinfo \| sed -e "s/^.: //"` 2))"
440	else
441	jobs="$((`grep -c ^cpu /proc/cpuinfo` * 2))"
442	die "Unknown ARCH -- ${ARCH}!"
443	fi
444
445	# Make sure the number is valid ...
446	if [ "${jobs}" -lt 1 ]
447	then
448	jobs=1
449	fi
450
451	if [ -n "${ADMINPARAM}" ]
452	then
453	if [ "${jobs}" -gt "${ADMINPARAM}" ]
454	then
455	einfo "Setting make jobs to \"-j${ADMINPARAM}\" to ensure successful merge..."
456	export MAKEOPTS="${MAKEOPTS} -j${ADMINPARAM}"
457	else
458	einfo "Setting make jobs to \"-j${jobs}\" to ensure successful merge..."
459	export MAKEOPTS="${MAKEOPTS} -j${jobs}"
460	fi
461	fi
462	}
463
464	# Cheap replacement for when debianutils (and thus mktemp)
465	# does not exist on the users system
466	# vapier@gentoo.org
467	#
468	# Takes just 1 parameter (the directory to create tmpfile in)
469	mymktemp() {
470	local topdir="$1"
471
472	[ -z "${topdir}" ] && topdir=/tmp
473	if [ "`which mktemp 2>/dev/null`" ]
474	then
475	mktemp -p ${topdir}
476	else
477	local tmp="${topdir}/tmp.${RANDOM}.${RANDOM}.${RANDOM}"
478	touch ${tmp}
479	echo ${tmp}
480	fi
481	}
482
483	# Small wrapper for getent (Linux) and nidump (Mac OS X)
484	# used in enewuser()/enewgroup()
485	# Joe Jezak <josejx@gmail.com> and usata@gentoo.org
486	#
487	# egetent(database, key)
488	egetent() {
489	if [ "${ARCH}" == "macos" ] ; then
490	case "$2" in
491	[!0-9]) # Non numeric
492	nidump $1 . \| awk -F":" "{ if (\$1 ~ /^$2$/) {print \$0;exit;} }"
493	;;
494	*) # Numeric
495	nidump $1 . \| awk -F":" "{ if (\$3 == $2) {print \$0;exit;} }"
496	;;
497	esac
498	else
499	getent $1 $2
500	fi
501	}
502
503	# Simplify/standardize adding users to the system
504	# vapier@gentoo.org
505	#
506	# enewuser(username, uid, shell, homedir, groups, extra options)
507	#
508	# Default values if you do not specify any:
509	# username: REQUIRED !
510	# uid: next available (see useradd(8))
511	# note: pass -1 to get default behavior
512	# shell: /bin/false
513	# homedir: /dev/null
514	# groups: none
515	# extra: comment of 'added by portage for ${PN}'
516	enewuser() {
517	# get the username
518	local euser="$1"; shift
519	if [ -z "${euser}" ]
520	then
521	eerror "No username specified !"
522	die "Cannot call enewuser without a username"
523	fi
524
525	# lets see if the username already exists
526	if [ "${euser}" == "`egetent passwd \"${euser}\" \| cut -d: -f1`" ]
527	then
528	return 0
529	fi
530	einfo "Adding user '${euser}' to your system ..."
531
532	# options to pass to useradd
533	local opts=
534
535	# handle uid
536	local euid="$1"; shift
537	if [ ! -z "${euid}" ] && [ "${euid}" != "-1" ]
538	then
539	if [ "${euid}" -gt 0 ]
540	then
541	if [ ! -z "`egetent passwd ${euid}`" ]
542	then
543	euid="next"
544	fi	395	fi
545	else	396	else
546	eerror "Userid given but is not greater than 0 !"	397	einfo " ${patchname} ..."
547	die "${euid} is not a valid UID"	398	fi
		399
		400	# most of the time, there will only be one run per unique name,
		401	# but if there are more, make sure we get unique log filenames
		402	local STDERR_TARGET="${T}/${patchname}.out"
		403	if [[ -e ${STDERR_TARGET} ]] ; then
		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
548	fi	422	fi
		423	else
		424	PATCH_TARGET=${x}
		425	fi
		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} ***"
		452	echo
		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} )"
		499	eerror
		500	eerror "Include in your bugreport the contents of:"
		501	eerror
		502	eerror " ${STDERR_TARGET}"
		503	echo
		504	die "Failed Patch: ${patchname}!"
		505	fi
		506
		507	# if everything worked, delete the full debug patch log
		508	rm -f "${STDERR_TARGET}"
		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
		517	eend 0
		518	done
		519
		520	[[ ${SINGLE_PATCH} == "no" ]] && 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
		572	fi
		573	done
		574	echo "none" > "${applied}"
		575	return 1
		576	}
		577
		578	# @FUNCTION: emktemp
		579	# @USAGE: [temp dir]
		580	# @DESCRIPTION:
		581	# Cheap replacement for when debianutils (and thus mktemp)
		582	# does not exist on the users system.
		583	emktemp() {
		584	local exe="touch"
		585	[[ $1 == -d ]] && exe="mkdir" && shift
		586	local topdir=$1
		587
		588	if [[ -z ${topdir} ]] ; then
		589	[[ -z ${T} ]] \
		590	&& topdir="/tmp" \
		591	\|\| topdir=${T}
		592	fi
		593
		594	if ! type -P mktemp > /dev/null ; then
		595	# system lacks `mktemp` so we have to fake it
		596	local tmp=/
		597	while [[ -e ${tmp} ]] ; do
		598	tmp=${topdir}/tmp.${RANDOM}.${RANDOM}.${RANDOM}
		599	done
		600	${exe} "${tmp}" \|\| ${exe} -p "${tmp}"
		601	echo "${tmp}"
549	else	602	else
550	euid="next"	603	# the args here will give slightly wierd names on BSD,
551	fi	604	# but should produce a usable file on all userlands
552	if [ "${euid}" == "next" ]	605	if [[ ${exe} == "touch" ]] ; then
553	then	606	TMPDIR="${topdir}" mktemp -t tmp.XXXXXXXXXX
554	local pwrange
555	if [ "${ARCH}" == "macos" ] ; then
556	pwrange="`jot 898 101`"
557	else	607	else
558	pwrange="`seq 101 999`"	608	TMPDIR="${topdir}" mktemp -dt tmp.XXXXXXXXXX
		609	fi
559	fi	610	fi
560	for euid in ${pwrange} ; do	611	}
561	[ -z "`egetent passwd ${euid}`" ] && break	612
		613	# @FUNCTION: edos2unix
		614	# @USAGE: <file> [more files ...]
		615	# @DESCRIPTION:
		616	# A handy replacement for dos2unix, recode, fixdos, etc... This allows you
		617	# to remove all of these text utilities from DEPEND variables because this
		618	# is a script based solution. Just give it a list of files to convert and
		619	# they will all be changed from the DOS CRLF format to the UNIX LF format.
		620	edos2unix() {
		621	[[ $# -eq 0 ]] && return 0
		622	sed -i 's/\r$//' -- "$@" \|\| die
		623	}
		624
		625	# @FUNCTION: make_desktop_entry
		626	# @USAGE: make_desktop_entry(<command>, [name], [icon], [type], [fields])
		627	# @DESCRIPTION:
		628	# Make a .desktop file.
		629	#
		630	# @CODE
		631	# binary: what command does the app run with ?
		632	# name: the name that will show up in the menu
		633	# icon: give your little like a pretty little icon ...
		634	# this can be relative (to /usr/share/pixmaps) or
		635	# a full path to an icon
		636	# type: what kind of application is this?
		637	# for categories:
		638	# http://standards.freedesktop.org/menu-spec/latest/apa.html
		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
		642	make_desktop_entry() {
		643	[[ -z $1 ]] && die "make_desktop_entry: You must specify the executable"
		644
		645	local exec=${1}
		646	local name=${2:-${PN}}
		647	local icon=${3:-${PN}}
		648	local type=${4}
		649	local fields=${5}
		650
		651	if [[ -z ${type} ]] ; then
		652	local catmaj=${CATEGORY%%-*}
		653	local catmin=${CATEGORY##*-}
		654	case ${catmaj} in
		655	app)
		656	case ${catmin} in
		657	accessibility) type="Utility;Accessibility";;
		658	admin) type=System;;
		659	antivirus) type=System;;
		660	arch) type="Utility;Archiving";;
		661	backup) type="Utility;Archiving";;
		662	cdr) type="AudioVideo;DiscBurning";;
		663	dicts) type="Office;Dictionary";;
		664	doc) type=Documentation;;
		665	editors) type="Utility;TextEditor";;
		666	emacs) type="Development;TextEditor";;
		667	emulation) type="System;Emulator";;
		668	laptop) type="Settings;HardwareSettings";;
		669	office) type=Office;;
		670	pda) type="Office;PDA";;
		671	vim) type="Development;TextEditor";;
		672	xemacs) type="Development;TextEditor";;
		673	esac
		674	;;
		675
		676	dev)
		677	type="Development"
		678	;;
		679
		680	games)
		681	case ${catmin} in
		682	action\|fps) type=ActionGame;;
		683	arcade) type=ArcadeGame;;
		684	board) type=BoardGame;;
		685	emulation) type=Emulator;;
		686	kids) type=KidsGame;;
		687	puzzle) type=LogicGame;;
		688	roguelike) type=RolePlaying;;
		689	rpg) type=RolePlaying;;
		690	simulation) type=Simulation;;
		691	sports) type=SportsGame;;
		692	strategy) type=StrategyGame;;
		693	esac
		694	type="Game;${type}"
		695	;;
		696
		697	gnome)
		698	type="Gnome;GTK"
		699	;;
		700
		701	kde)
		702	type="KDE;Qt"
		703	;;
		704
		705	mail)
		706	type="Network;Email"
		707	;;
		708
		709	media)
		710	case ${catmin} in
		711	gfx)
		712	type=Graphics
		713	;;
		714	*)
		715	case ${catmin} in
		716	radio) type=Tuner;;
		717	sound) type=Audio;;
		718	tv) type=TV;;
		719	video) type=Video;;
		720	esac
		721	type="AudioVideo;${type}"
		722	;;
		723	esac
		724	;;
		725
		726	net)
		727	case ${catmin} in
		728	dialup) type=Dialup;;
		729	ftp) type=FileTransfer;;
		730	im) type=InstantMessaging;;
		731	irc) type=IRCClient;;
		732	mail) type=Email;;
		733	news) type=News;;
		734	nntp) type=News;;
		735	p2p) type=FileTransfer;;
		736	voip) type=Telephony;;
		737	esac
		738	type="Network;${type}"
		739	;;
		740
		741	sci)
		742	case ${catmin} in
		743	astro*) type=Astronomy;;
		744	bio*) type=Biology;;
		745	calc*) type=Calculator;;
		746	chem*) type=Chemistry;;
		747	elec*) type=Electronics;;
		748	geo*) type=Geology;;
		749	math*) type=Math;;
		750	physics) type=Physics;;
		751	visual*) type=DataVisualization;;
		752	esac
		753	type="Education;Science;${type}"
		754	;;
		755
		756	sys)
		757	type="System"
		758	;;
		759
		760	www)
		761	case ${catmin} in
		762	client) type=WebBrowser;;
		763	esac
		764	type="Network;${type}"
		765	;;
		766
		767	*)
		768	type=
		769	;;
		770	esac
		771	fi
		772	if [ "${SLOT}" == "0" ] ; then
		773	local desktop_name="${PN}"
		774	else
		775	local desktop_name="${PN}-${SLOT}"
		776	fi
		777	local desktop="${T}/$(echo ${exec} \| sed 's:[[:space:]/:]:_:g')-${desktop_name}.desktop"
		778	#local desktop=${T}/${exec%% *:-${desktop_name}}.desktop
		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
		791	cat <<-EOF > "${desktop}"
		792	[Desktop Entry]
		793	Name=${name}
		794	Type=Application
		795	Comment=${DESCRIPTION}
		796	Exec=${exec}
		797	TryExec=${exec%% *}
		798	Icon=${icon}
		799	Categories=${type}
		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}"
		808
		809	(
		810	# wrap the env here so that the 'insinto' call
		811	# doesn't corrupt the env of the caller
		812	insinto /usr/share/applications
		813	doins "${desktop}"
		814	) \|\| die "installing desktop file failed"
		815	}
		816
		817	# @FUNCTION: validate_desktop_entries
		818	# @USAGE: [directories]
		819	# @MAINTAINER:
		820	# Carsten Lohrke <carlo@gentoo.org>
		821	# @DESCRIPTION:
		822	# Validate desktop entries using desktop-file-utils
		823	validate_desktop_entries() {
		824	if [[ -x /usr/bin/desktop-file-validate ]] ; then
		825	einfo "Checking desktop entry validity"
		826	local directories=""
		827	for d in /usr/share/applications $@ ; do
		828	[[ -d ${D}${d} ]] && directories="${directories} ${D}${d}"
562	done	829	done
		830	if [[ -n ${directories} ]] ; then
		831	for FILE in $(find ${directories} -name "*\.desktop" \
		832	-not -path '.hidden' \| sort -u 2>/dev/null)
		833	do
		834	local temp=$(desktop-file-validate ${FILE} \| grep -v "warning:" \| \
		835	sed -e "s\|error: \|\|" -e "s\|${FILE}:\|--\|g" )
		836	[[ -n $temp ]] && elog ${temp/--/${FILE/${D}/}:}
		837	done
563	fi	838	fi
564	opts="${opts} -u ${euid}"	839	echo ""
565	einfo " - Userid: ${euid}"
566
567	# handle shell
568	local eshell="$1"; shift
569	if [ ! -z "${eshell}" ] && [ "${eshell}" != "-1" ]
570	then
571	if [ ! -e "${eshell}" ]
572	then
573	eerror "A shell was specified but it does not exist !"
574	die "${eshell} does not exist"
575	fi
576	else	840	else
577	eshell="/bin/false"	841	einfo "Passing desktop entry validity check. Install dev-util/desktop-file-utils, if you want to help to improve Gentoo."
578	fi
579	einfo " - Shell: ${eshell}"
580	opts="${opts} -s ${eshell}"
581
582	# handle homedir
583	local ehome="$1"; shift
584	if [ -z "${ehome}" ] && [ "${eshell}" != "-1" ]
585	then
586	ehome="/dev/null"
587	fi
588	einfo " - Home: ${ehome}"
589	opts="${opts} -d ${ehome}"
590
591	# handle groups
592	local egroups="$1"; shift
593	if [ ! -z "${egroups}" ]
594	then
595	local oldifs="${IFS}"
596	export IFS=","
597	for g in ${egroups}
598	do
599	if [ -z "`egetent group \"${g}\"`" ]
600	then
601	eerror "You must add group ${g} to the system first"
602	die "${g} is not a valid GID"
603	fi	842	fi
604	done	843	}
605	export IFS="${oldifs}"
606	opts="${opts} -g ${egroups}"
607	else
608	egroups="(none)"
609	fi
610	einfo " - Groups: ${egroups}"
611		844
612	# handle extra and add the user	845	# @FUNCTION: make_session_desktop
613	local eextra="$@"	846	# @USAGE: <title> <command> [command args...]
614	local oldsandbox="${SANDBOX_ON}"	847	# @DESCRIPTION:
615	export SANDBOX_ON="0"	848	# Make a GDM/KDM Session file. The title is the file to execute to start the
616	if [ "${ARCH}" == "macos" ];	849	# Window Manager. The command is the name of the Window Manager.
617	then	850	#
618	### Make the user	851	# You can set the name of the file via the ${wm} variable.
619	if [ -z "${eextra}" ]	852	make_session_desktop() {
620	then	853	[[ -z $1 ]] && eerror "$0: You must specify the title" && return 1
621	dscl . create /users/${euser} uid ${euid}	854	[[ -z $2 ]] && eerror "$0: You must specify the command" && return 1
622	dscl . create /users/${euser} shell ${eshell}	855
623	dscl . create /users/${euser} home ${ehome}	856	local title=$1
624	dscl . create /users/${euser} realname "added by portage for ${PN}"	857	local command=$2
625	### Add the user to the groups specified	858	local desktop=${T}/${wm:-${PN}}.desktop
626	for g in ${egroups}	859	shift 2
627	do	860
628	dscl . merge /groups/${g} users ${euser}	861	cat <<-EOF > "${desktop}"
		862	[Desktop Entry]
		863	Name=${title}
		864	Comment=This session logs you into ${title}
		865	Exec=${command} $*
		866	TryExec=${command}
		867	Type=XSession
		868	EOF
		869
		870	(
		871	# wrap the env here so that the 'insinto' call
		872	# doesn't corrupt the env of the caller
		873	insinto /usr/share/xsessions
		874	doins "${desktop}"
		875	)
		876	}
		877
		878	# @FUNCTION: domenu
		879	# @USAGE: <menus>
		880	# @DESCRIPTION:
		881	# Install the list of .desktop menu files into the appropriate directory
		882	# (/usr/share/applications).
		883	domenu() {
		884	(
		885	# wrap the env here so that the 'insinto' call
		886	# doesn't corrupt the env of the caller
		887	local i j ret=0
		888	insinto /usr/share/applications
		889	for i in "$@" ; do
		890	if [[ -f ${i} ]] ; then
		891	doins "${i}"
		892	((ret+=$?))
		893	elif [[ -d ${i} ]] ; then
		894	for j in "${i}"/*.desktop ; do
		895	doins "${j}"
		896	((ret+=$?))
629	done	897	done
630	else	898	else
631	einfo "Extra options are not supported on macos yet"	899	((++ret))
632	einfo "Please report the ebuild along with the info below"
633	einfo "eextra: ${eextra}"
634	die "Required function missing"
635	fi	900	fi
636	else	901	done
637	if [ -z "${eextra}" ]	902	exit ${ret}
638	then	903	)
639	useradd ${opts} ${euser} \	904	}
640	-c "added by portage for ${PN}" \	905
641	\|\| die "enewuser failed"	906	# @FUNCTION: newmenu
		907	# @USAGE: <menu> <newname>
		908	# @DESCRIPTION:
		909	# Like all other new* functions, install the specified menu as newname.
		910	newmenu() {
		911	(
		912	# wrap the env here so that the 'insinto' call
		913	# doesn't corrupt the env of the caller
		914	insinto /usr/share/applications
		915	newins "$@"
		916	)
		917	}
		918
		919	# @FUNCTION: doicon
		920	# @USAGE: <list of icons>
		921	# @DESCRIPTION:
		922	# Install the list of icons into the icon directory (/usr/share/pixmaps).
		923	# This is useful in conjunction with creating desktop/menu files.
		924	doicon() {
		925	(
		926	# wrap the env here so that the 'insinto' call
		927	# doesn't corrupt the env of the caller
		928	local i j ret
		929	insinto /usr/share/pixmaps
		930	for i in "$@" ; do
		931	if [[ -f ${i} ]] ; then
		932	doins "${i}"
		933	((ret+=$?))
		934	elif [[ -d ${i} ]] ; then
		935	for j in "${i}"/*.png ; do
		936	doins "${j}"
		937	((ret+=$?))
		938	done
642	else	939	else
643	einfo " - Extra: ${eextra}"	940	((++ret))
644	useradd ${opts} ${euser} ${eextra} \
645	\|\| die "enewuser failed"
646	fi
647	fi
648	export SANDBOX_ON="${oldsandbox}"
649
650	if [ ! -e "${ehome}" ] && [ ! -e "${D}/${ehome}" ]
651	then
652	einfo " - Creating ${ehome} in ${D}"
653	dodir ${ehome}
654	fowners ${euser} ${ehome}
655	fperms 755 ${ehome}
656	fi
657	}
658
659	# Simplify/standardize adding groups to the system
660	# vapier@gentoo.org
661	#
662	# enewgroup(group, gid)
663	#
664	# Default values if you do not specify any:
665	# groupname: REQUIRED !
666	# gid: next available (see groupadd(8))
667	# extra: none
668	enewgroup() {
669	# get the group
670	local egroup="$1"; shift
671	if [ -z "${egroup}" ]
672	then
673	eerror "No group specified !"
674	die "Cannot call enewgroup without a group"
675	fi
676
677	# see if group already exists
678	if [ "${egroup}" == "`egetent group \"${egroup}\" \| cut -d: -f1`" ]
679	then
680	return 0
681	fi
682	einfo "Adding group '${egroup}' to your system ..."
683
684	# options to pass to useradd
685	local opts=
686
687	# handle gid
688	local egid="$1"; shift
689	if [ ! -z "${egid}" ]
690	then
691	if [ "${egid}" -gt 0 ]
692	then
693	if [ -z "`egetent group ${egid}`" ]
694	then
695	if [ "${ARCH}" == "macos" ] ; then
696	opts="${opts} ${egid}"
697	else
698	opts="${opts} -g ${egid}"
699	fi
700	else
701	egid="next available; requested gid taken"
702	fi	941	fi
703	else
704	eerror "Groupid given but is not greater than 0 !"
705	die "${egid} is not a valid GID"
706	fi
707	else
708	egid="next available"
709	fi
710	einfo " - Groupid: ${egid}"
711
712	# handle extra
713	local eextra="$@"
714	opts="${opts} ${eextra}"
715
716	# add the group
717	local oldsandbox="${SANDBOX_ON}"
718	export SANDBOX_ON="0"
719	if [ "${ARCH}" == "macos" ];
720	then
721	if [ ! -z "${eextra}" ];
722	then
723	einfo "Extra options are not supported on macos yet"
724	einfo "Please report the ebuild along with the info below"
725	einfo "eextra: ${eextra}"
726	die "Required function missing"
727	fi
728
729	# If we need the next available
730	case ${egid} in
731	[!0-9]) # Non numeric
732	for egid in `jot 898 101`; do
733	[ -z "`egetent group ${egid}`" ] && break
734	done
735	esac
736	dscl . create /groups/${egroup} gid ${egid}
737	dscl . create /groups/${egroup} passwd '*'
738	else
739	groupadd ${opts} ${egroup} \|\| die "enewgroup failed"
740	fi
741	export SANDBOX_ON="${oldsandbox}"
742	}
743
744	# Simple script to replace 'dos2unix' binaries
745	# vapier@gentoo.org
746	#
747	# edos2unix(file, <more files>...)
748	edos2unix() {
749	for f in "$@"
750	do
751	cp "${f}" ${T}/edos2unix
752	sed 's/\r$//' ${T}/edos2unix > "${f}"
753	done	942	done
		943	exit ${ret}
		944	)
754	}	945	}
755		946
756	# Make a desktop file !	947	# @FUNCTION: newicon
757	# Great for making those icons in kde/gnome startmenu !	948	# @USAGE: <icon> <newname>
758	# Amaze your friends ! Get the women ! Join today !	949	# @DESCRIPTION:
759	# gnome2 /usr/share/applications	950	# Like all other new* functions, install the specified icon as newname.
760	# gnome1 /usr/share/gnome/apps/	951	newicon() {
761	# KDE ${KDEDIR}/share/applnk /usr/share/applnk	952	(
762	#	953	# wrap the env here so that the 'insinto' call
763	# make_desktop_entry(<binary>, [name], [icon], [type], [path])	954	# doesn't corrupt the env of the caller
764	#
765	# binary: what binary does the app run with ?
766	# name: the name that will show up in the menu
767	# icon: give your little like a pretty little icon ...
768	# this can be relative (to /usr/share/pixmaps) or
769	# a full path to an icon
770	# type: what kind of application is this ? for categories:
771	# http://www.freedesktop.org/standards/menu-spec/
772	# path: if your app needs to startup in a specific dir
773	make_desktop_entry() {
774	[ -z "$1" ] && eerror "You must specify the executable" && return 1
775
776	local exec="${1}"
777	local name="${2:-${PN}}"
778	local icon="${3:-${PN}.png}"
779	local type="${4}"
780	local subdir="${6}"
781	local path="${5:-${GAMES_PREFIX}}"
782	if [ -z "${type}" ]
783	then
784	case ${CATEGORY} in
785	"app-emulation")
786	type=Emulator
787	subdir="Emulation"
788	;;
789	"games-"*)
790	type=Game
791	subdir="Games"
792	;;
793	"net-"*)
794	type=Network
795	subdir="${type}"
796	;;
797	*)
798	type=
799	subdir=
800	;;
801	esac
802	fi
803	local desktop="${T}/${exec}.desktop"
804
805	echo "[Desktop Entry]
806	Encoding=UTF-8
807	Version=0.9.2
808	Name=${name}
809	Type=Application
810	Comment=${DESCRIPTION}
811	Exec=${exec}
812	Path=${path}
813	Icon=${icon}
814	Categories=Application;${type};" > ${desktop}
815
816	if [ -d "/usr/share/applications" ]
817	then
818	insinto /usr/share/applications	955	insinto /usr/share/pixmaps
819	doins ${desktop}	956	newins "$@"
820	fi	957	)
821
822	#if [ -d "/usr/share/gnome/apps" ]
823	#then
824	# insinto /usr/share/gnome/apps/Games
825	# doins ${desktop}
826	#fi
827
828	#if [ ! -z "`ls /usr/kde/* 2>/dev/null`" ]
829	#then
830	# for ver in /usr/kde/*
831	# do
832	# insinto ${ver}/share/applnk/Games
833	# doins ${desktop}
834	# done
835	#fi
836
837	if [ -d "/usr/share/applnk" ]
838	then
839	insinto /usr/share/applnk/${subdir}
840	doins ${desktop}
841	fi
842
843	return 0
844	}	958	}
845		959
846	# for internal use only (unpack_pdv and unpack_makeself)	960	# @FUNCTION: strip-linguas
847	find_unpackable_file() {	961	# @USAGE: [<allow LINGUAS>\|<-i\|-u> <directories of .po files>]
848	local src="$1"	962	# @DESCRIPTION:
849	if [ -z "${src}" ]
850	then
851	src="${DISTDIR}/${A}"
852	else
853	if [ -e "${DISTDIR}/${src}" ]
854	then
855	src="${DISTDIR}/${src}"
856	elif [ -e "${PWD}/${src}" ]
857	then
858	src="${PWD}/${src}"
859	elif [ -e "${src}" ]
860	then
861	src="${src}"
862	fi
863	fi
864	[ ! -e "${src}" ] && die "Could not find requested archive ${src}"
865	echo "${src}"
866	}
867
868	# Unpack those pesky pdv generated files ...
869	# They're self-unpacking programs with the binary package stuffed in
870	# the middle of the archive. Valve seems to use it a lot ... too bad
871	# it seems to like to segfault a lot :(. So lets take it apart ourselves.
872	#
873	# Usage: unpack_pdv [file to unpack] [size of off_t]
874	# - you have to specify the off_t size ... i have no idea how to extract that
875	# information out of the binary executable myself. basically you pass in
876	# the size of the off_t type (in bytes) on the machine that built the pdv
877	# archive. one way to determine this is by running the following commands:
878	# strings <pdv archive> \| grep lseek
879	# strace -elseek <pdv archive>
880	# basically look for the first lseek command (we do the strings/grep because
881	# sometimes the function call is _llseek or something) and steal the 2nd
882	# parameter. here is an example:
883	# root@vapier 0 pdv_unpack # strings hldsupdatetool.bin \| grep lseek
884	# lseek
885	# root@vapier 0 pdv_unpack # strace -elseek ./hldsupdatetool.bin
886	# lseek(3, -4, SEEK_END) = 2981250
887	# thus we would pass in the value of '4' as the second parameter.
888	unpack_pdv() {
889	local src="`find_unpackable_file $1`"
890	local sizeoff_t="$2"
891
892	[ -z "${sizeoff_t}" ] && die "No idea what off_t size was used for this pdv :("
893
894	local shrtsrc="`basename ${src}`"
895	echo ">>> Unpacking ${shrtsrc} to ${PWD}"
896	local metaskip=`tail -c ${sizeoff_t} ${src} \| hexdump -e \"%i\"`
897	local tailskip=`tail -c $((${sizeoff_t}*2)) ${src} \| head -c ${sizeoff_t} \| hexdump -e \"%i\"`
898
899	# grab metadata for debug reasons
900	local metafile="`mymktemp ${T}`"
901	tail -c +$((${metaskip}+1)) ${src} > ${metafile}
902
903	# rip out the final file name from the metadata
904	local datafile="`tail -c +$((${metaskip}+1)) ${src} \| strings \| head -n 1`"
905	datafile="`basename ${datafile}`"
906
907	# now lets uncompress/untar the file if need be
908	local tmpfile="`mymktemp ${T}`"
909	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \| head -c 512 > ${tmpfile}
910
911	local iscompressed="`file -b ${tmpfile}`"
912	if [ "${iscompressed:0:8}" == "compress" ] ; then
913	iscompressed=1
914	mv ${tmpfile}{,.Z}
915	gunzip ${tmpfile}
916	else
917	iscompressed=0
918	fi
919	local istar="`file -b ${tmpfile}`"
920	if [ "${istar:0:9}" == "POSIX tar" ] ; then
921	istar=1
922	else
923	istar=0
924	fi
925
926	#for some reason gzip dies with this ... dd cant provide buffer fast enough ?
927	#dd if=${src} ibs=${metaskip} count=1 \
928	# \| dd ibs=${tailskip} skip=1 \
929	# \| gzip -dc \
930	# > ${datafile}
931	if [ ${iscompressed} -eq 1 ] ; then
932	if [ ${istar} -eq 1 ] ; then
933	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
934	\| head -c $((${metaskip}-${tailskip})) \
935	\| tar -xzf -
936	else
937	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
938	\| head -c $((${metaskip}-${tailskip})) \
939	\| gzip -dc \
940	> ${datafile}
941	fi
942	else
943	if [ ${istar} -eq 1 ] ; then
944	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
945	\| head -c $((${metaskip}-${tailskip})) \
946	\| tar --no-same-owner -xf -
947	else
948	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
949	\| head -c $((${metaskip}-${tailskip})) \
950	> ${datafile}
951	fi
952	fi
953	true
954	#[ -s "${datafile}" ] \|\| die "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"
955	#assert "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"
956	}
957
958	# Unpack those pesky makeself generated files ...
959	# They're shell scripts with the binary package tagged onto
960	# the end of the archive. Loki utilized the format as does
961	# many other game companies.
962	#
963	# Usage: unpack_makeself [file to unpack] [offset]
964	# - If the file is not specified then unpack will utilize ${A}.
965	# - If the offset is not specified then we will attempt to extract
966	# the proper offset from the script itself.
967	unpack_makeself() {
968	local src="`find_unpackable_file $1`"
969	local skip="$2"
970
971	local shrtsrc="`basename ${src}`"
972	echo ">>> Unpacking ${shrtsrc} to ${PWD}"
973	if [ -z "${skip}" ]
974	then
975	local ver="`grep -a '#.*Makeself' ${src} \| awk '{print $NF}'`"
976	local skip=0
977	case ${ver} in
978	1.5.*) # tested 1.5.{3,4,5} ... guessing 1.5.x series is same
979	skip=`grep -a ^skip= ${src} \| cut -d= -f2`
980	;;
981	2.0\|2.0.1)
982	skip=`grep -a ^$'\t'tail ${src} \| awk '{print $2}' \| cut -b2-`
983	;;
984	2.1.1)
985	skip=`grep -a ^offset= ${src} \| awk '{print $2}' \| cut -b2-`
986	let skip="skip + 1"
987	;;
988	2.1.2)
989	skip=`grep -a ^offset= ${src} \| awk '{print $3}' \| head -n 1`
990	let skip="skip + 1"
991	;;
992	2.1.3)
993	skip=`grep -a ^offset= ${src} \| awk '{print $3}'`
994	let skip="skip + 1"
995	;;
996	*)
997	eerror "I'm sorry, but I was unable to support the Makeself file."
998	eerror "The version I detected was '${ver}'."
999	eerror "Please file a bug about the file ${shrtsrc} at"
1000	eerror "http://bugs.gentoo.org/ so that support can be added."
1001	die "makeself version '${ver}' not supported"
1002	;;
1003	esac
1004	debug-print "Detected Makeself version ${ver} ... using ${skip} as offset"
1005	fi
1006
1007	# lets grab the first few bytes of the file to figure out what kind of archive it is
1008	local tmpfile="`mymktemp ${T}`"
1009	tail -n +${skip} ${src} 2>/dev/null \| head -c 512 > ${tmpfile}
1010	local filetype="`file -b ${tmpfile}`"
1011	case ${filetype} in
1012	*tar\ archive)
1013	tail -n +${skip} ${src} \| tar --no-same-owner -xf -
1014	;;
1015	bzip2*)
1016	tail -n +${skip} ${src} \| bzip2 -dc \| tar --no-same-owner -xf -
1017	;;
1018	gzip*)
1019	tail -n +${skip} ${src} \| tar --no-same-owner -xzf -
1020	;;
1021	*)
1022	false
1023	;;
1024	esac
1025	assert "failure unpacking (${filetype}) makeself ${shrtsrc} ('${ver}' +${skip})"
1026	}
1027
1028	# Display a license for user to accept.
1029	#
1030	# Usage: check_license [license]
1031	# - If the file is not specified then ${LICENSE} is used.
1032	check_license() {
1033	local lic=$1
1034	if [ -z "${lic}" ] ; then
1035	lic="${PORTDIR}/licenses/${LICENSE}"
1036	else
1037	if [ -e "${PORTDIR}/licenses/${src}" ] ; then
1038	lic="${PORTDIR}/licenses/${src}"
1039	elif [ -e "${PWD}/${src}" ] ; then
1040	lic="${PWD}/${src}"
1041	elif [ -e "${src}" ] ; then
1042	lic="${src}"
1043	fi
1044	fi
1045	[ ! -f "${lic}" ] && die "Could not find requested license ${src}"
1046	local l="`basename ${lic}`"
1047
1048	# here is where we check for the licenses the user already
1049	# accepted ... if we don't find a match, we make the user accept
1050	local alic
1051	for alic in "${ACCEPT_LICENSE}" ; do
1052	[ "${alic}" == "*" ] && return 0
1053	[ "${alic}" == "${l}" ] && return 0
1054	done
1055
1056	local licmsg="`mymktemp ${T}`"
1057	cat << EOF > ${licmsg}
1058	**********************************************************
1059	The following license outlines the terms of use of this
1060	package. You MUST accept this license for installation to
1061	continue. When you are done viewing, hit 'q'. If you
1062	CTRL+C out of this, the install will not run!
1063	**********************************************************
1064
1065	EOF
1066	cat ${lic} >> ${licmsg}
1067	${PAGER:-less} ${licmsg} \|\| die "Could not execute pager (${PAGER}) to accept ${lic}"
1068	einfon "Do you accept the terms of this license (${l})? [yes/no] "
1069	read alic
1070	case ${alic} in
1071	yes\|Yes\|y\|Y)
1072	return 0
1073	;;
1074	*)
1075	echo;echo;echo
1076	eerror "You MUST accept the license to continue! Exiting!"
1077	die "Failed to accept license"
1078	;;
1079	esac
1080	}
1081
1082	# Aquire cd(s) for those lovely cd-based emerges. Yes, this violates
1083	# the whole 'non-interactive' policy, but damnit I want CD support !
1084	#
1085	# with these cdrom functions we handle all the user interaction and
1086	# standardize everything. all you have to do is call cdrom_get_cds()
1087	# and when the function returns, you can assume that the cd has been
1088	# found at CDROM_ROOT.
1089	#
1090	# normally the cdrom functions will refer to the cds as 'cd #1', 'cd #2',
1091	# etc... if you want to give the cds better names, then just export
1092	# the CDROM_NAME_X variables before calling cdrom_get_cds().
1093	#
1094	# for those multi cd ebuilds, see the cdrom_load_next_cd() below.
1095	#
1096	# Usage: cdrom_get_cds <file on cd1> [file on cd2] [file on cd3] [...]
1097	# - this will attempt to locate a cd based upon a file that is on
1098	# the cd ... the more files you give this function, the more cds
1099	# the cdrom functions will handle
1100	cdrom_get_cds() {
1101	# first we figure out how many cds we're dealing with by
1102	# the # of files they gave us
1103	local cdcnt=0
1104	local f=
1105	for f in "$@" ; do
1106	cdcnt=$((cdcnt + 1))
1107	export CDROM_CHECK_${cdcnt}="$f"
1108	done
1109	export CDROM_TOTAL_CDS=${cdcnt}
1110	export CDROM_CURRENT_CD=1
1111
1112	# now we see if the user gave use CD_ROOT ...
1113	# if they did, let's just believe them that it's correct
1114	if [ ! -z "${CD_ROOT}" ] ; then
1115	export CDROM_ROOT="${CD_ROOT}"
1116	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
1117	return
1118	fi
1119	# do the same for CD_ROOT_X
1120	if [ ! -z "${CD_ROOT_1}" ] ; then
1121	local var=
1122	cdcnt=0
1123	while [ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ] ; do
1124	cdcnt=$((cdcnt + 1))
1125	var="CD_ROOT_${cdcnt}"
1126	if [ -z "${!var}" ] ; then
1127	eerror "You must either use just the CD_ROOT"
1128	eerror "or specify ALL the CD_ROOT_X variables."
1129	eerror "In this case, you will need ${CDROM_TOTAL_CDS} CD_ROOT_X variables."
1130	die "could not locate CD_ROOT_${cdcnt}"
1131	fi
1132	export CDROM_ROOTS_${cdcnt}="${!var}"
1133	done
1134	export CDROM_ROOT=${CDROM_ROOTS_1}
1135	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
1136	return
1137	fi
1138
1139	if [ ${CDROM_TOTAL_CDS} -eq 1 ] ; then
1140	einfon "This ebuild will need the "
1141	if [ -z "${CDROM_NAME}" ] ; then
1142	echo "cdrom for ${PN}."
1143	else
1144	echo "${CDROM_NAME}."
1145	fi
1146	echo
1147	einfo "If you do not have the CD, but have the data files"
1148	einfo "mounted somewhere on your filesystem, just export"
1149	einfo "the variable CD_ROOT so that it points to the"
1150	einfo "directory containing the files."
1151	echo
1152	else
1153	einfo "This package will need access to ${CDROM_TOTAL_CDS} cds."
1154	cdcnt=0
1155	while [ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ] ; do
1156	cdcnt=$((cdcnt + 1))
1157	var="CDROM_NAME_${cdcnt}"
1158	[ ! -z "${!var}" ] && einfo " CD ${cdcnt}: ${!var}"
1159	done
1160	echo
1161	einfo "If you do not have the CDs, but have the data files"
1162	einfo "mounted somewhere on your filesystem, just export"
1163	einfo "the following variables so they point to the right place:"
1164	einfon ""
1165	cdcnt=0
1166	while [ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ] ; do
1167	cdcnt=$((cdcnt + 1))
1168	echo -n " CD_ROOT_${cdcnt}"
1169	done
1170	echo
1171	einfo "Or, if you have all the files in the same place, or"
1172	einfo "you only have one cdrom, you can export CD_ROOT"
1173	einfo "and that place will be used as the same data source"
1174	einfo "for all the CDs."
1175	echo
1176	fi
1177	export CDROM_CURRENT_CD=0
1178	cdrom_load_next_cd
1179	}
1180
1181	# this is only used when you need access to more than one cd.
1182	# when you have finished using the first cd, just call this function.
1183	# when it returns, CDROM_ROOT will be pointing to the second cd.
1184	# remember, you can only go forward in the cd chain, you can't go back.
1185	cdrom_load_next_cd() {
1186	export CDROM_CURRENT_CD=$((CDROM_CURRENT_CD + 1))
1187	local var=
1188
1189	if [ ! -z "${CD_ROOT}" ] ; then
1190	einfo "Using same root as before for CD #${CDROM_CURRENT_CD}"
1191	return
1192	fi
1193
1194	unset CDROM_ROOT
1195	var=CDROM_ROOTS_${CDROM_CURRENT_CD}
1196	if [ -z "${!var}" ] ; then
1197	var="CDROM_CHECK_${CDROM_CURRENT_CD}"
1198	cdrom_locate_file_on_cd ${!var}
1199	else
1200	export CDROM_ROOT="${!var}"
1201	fi
1202
1203	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
1204	}
1205
1206	# this is used internally by the cdrom_get_cds() and cdrom_load_next_cd()
1207	# functions. this should never be called from an ebuild.
1208	# all it does is try to locate a give file on a cd ... if the cd isn't
1209	# found, then a message asking for the user to insert the cdrom will be
1210	# displayed and we'll hang out here until:
1211	# (1) the file is found on a mounted cdrom
1212	# (2) the user hits CTRL+C
1213	cdrom_locate_file_on_cd() {
1214	while [ -z "${CDROM_ROOT}" ] ; do
1215	local dir="$(dirname ${@})"
1216	local file="$(basename ${@})"
1217	local mline=""
1218	local showedmsg=0
1219
1220	for mline in `mount \| egrep -e '(iso\|cdrom)' \| awk '{print $3}'` ; do
1221	[ -d "${mline}/${dir}" ] \|\| continue
1222	[ ! -z "$(find ${mline}/${dir} -iname ${file} -maxdepth 1)" ] \
1223	&& export CDROM_ROOT=${mline}
1224	done
1225
1226	if [ -z "${CDROM_ROOT}" ] ; then
1227	echo
1228	if [ ${showedmsg} -eq 0 ] ; then
1229	if [ ${CDROM_TOTAL_CDS} -eq 1 ] ; then
1230	if [ -z "${CDROM_NAME}" ] ; then
1231	einfo "Please insert the cdrom for ${PN} now !"
1232	else
1233	einfo "Please insert the ${CDROM_NAME} cdrom now !"
1234	fi
1235	else
1236	if [ -z "${CDROM_NAME_1}" ] ; then
1237	einfo "Please insert cd #${CDROM_CURRENT_CD} for ${PN} now !"
1238	else
1239	local var="CDROM_NAME_${CDROM_CURRENT_CD}"
1240	einfo "Please insert+mount the ${!var} cdrom now !"
1241	fi
1242	fi
1243	showedmsg=1
1244	fi
1245	einfo "Press return to scan for the cd again"
1246	einfo "or hit CTRL+C to abort the emerge."
1247	read
1248	fi
1249	done
1250	}
1251
1252	# Make sure that LINGUAS only contains languages that	963	# Make sure that LINGUAS only contains languages that
1253	# a package can support	964	# a package can support. The first form allows you to
1254	#	965	# specify a list of LINGUAS. The -i builds a list of po
1255	# usage: strip-linguas <allow LINGUAS>	966	# files found in all the directories and uses the
1256	# strip-linguas -i <directories of .po files>	967	# intersection of the lists. The -u builds a list of po
1257	# strip-linguas -u <directories of .po files>	968	# files found in all the directories and uses the union
1258	#	969	# of the lists.
1259	# The first form allows you to specify a list of LINGUAS.
1260	# The -i builds a list of po files found in all the
1261	# directories and uses the intersection of the lists.
1262	# The -u builds a list of po files found in all the
1263	# directories and uses the union of the lists.
1264	strip-linguas() {	970	strip-linguas() {
1265	local ls newls	971	local ls newls nols
1266	if [ "$1" == "-i" ] \|\| [ "$1" == "-u" ] ; then	972	if [[ $1 == "-i" ]] \|\| [[ $1 == "-u" ]] ; then
1267	local op="$1"; shift	973	local op=$1; shift
1268	ls=" $(find "$1" -name '*.po' -printf '%f ') "; shift	974	ls=$(find "$1" -name '*.po' -exec basename {} .po ';'); shift
1269	local d f	975	local d f
1270	for d in "$@" ; do	976	for d in "$@" ; do
1271	if [ "${op}" == "-u" ] ; then	977	if [[ ${op} == "-u" ]] ; then
1272	newls="${ls}"	978	newls=${ls}
1273	else	979	else
1274	newls=""	980	newls=""
1275	fi	981	fi
1276	for f in $(find "$d" -name '*.po' -printf '%f ') ; do	982	for f in $(find "$d" -name '*.po' -exec basename {} .po ';') ; do
1277	if [ "${op}" == "-i" ] ; then	983	if [[ ${op} == "-i" ]] ; then
1278	[ "${ls/ ${f} /}" != "${ls}" ] && newls="${newls} ${f}"	984	has ${f} ${ls} && newls="${newls} ${f}"
1279	else	985	else
1280	[ "${ls/ ${f} /}" == "${ls}" ] && newls="${newls} ${f}"	986	has ${f} ${ls} \|\| newls="${newls} ${f}"
1281	fi	987	fi
1282	done	988	done
1283	ls="${newls}"	989	ls=${newls}
1284	done	990	done
1285	ls="${ls//.po}"
1286	else	991	else
1287	ls="$@"	992	ls="$@"
1288	fi	993	fi
1289		994
1290	ls=" ${ls} "	995	nols=""
1291	newls=""	996	newls=""
1292	for f in ${LINGUAS} ; do	997	for f in ${LINGUAS} ; do
1293	if [ "${ls/ ${f} /}" != "${ls}" ] ; then	998	if has ${f} ${ls} ; then
1294	nl="${newls} ${f}"	999	newls="${newls} ${f}"
1295	else	1000	else
1296	ewarn "Sorry, but ${PN} does not support the ${f} LINGUA"	1001	nols="${nols} ${f}"
1297	fi	1002	fi
1298	done	1003	done
		1004	[[ -n ${nols} ]] \
		1005	&& einfo "Sorry, but ${PN} does not support the LINGUAS:" ${nols}
		1006	export LINGUAS=${newls:1}
		1007	}
		1008
		1009	# @FUNCTION: preserve_old_lib
		1010	# @USAGE: <libs to preserve> [more libs]
		1011	# @DESCRIPTION:
		1012	# These functions are useful when a lib in your package changes ABI SONAME.
		1013	# An example might be from libogg.so.0 to libogg.so.1. Removing libogg.so.0
		1014	# would break packages that link against it. Most people get around this
		1015	# by using the portage SLOT mechanism, but that is not always a relevant
		1016	# solution, so instead you can call this from pkg_preinst. See also the
		1017	# preserve_old_lib_notify function.
		1018	preserve_old_lib() {
		1019	if [[ ${EBUILD_PHASE} != "preinst" ]] ; then
		1020	eerror "preserve_old_lib() must be called from pkg_preinst() only"
		1021	die "Invalid preserve_old_lib() usage"
		1022	fi
		1023	[[ -z $1 ]] && die "Usage: preserve_old_lib <library to preserve> [more libraries to preserve]"
		1024
		1025	# let portage worry about it
		1026	has preserve-libs ${FEATURES} && return 0
		1027
		1028	local lib dir
		1029	for lib in "$@" ; do
		1030	[[ -e ${ROOT}/${lib} ]] \|\| continue
		1031	dir=${lib%/*}
		1032	dodir ${dir} \|\| die "dodir ${dir} failed"
		1033	cp "${ROOT}"/${lib} "${D}"/${lib} \|\| die "cp ${lib} failed"
		1034	touch "${D}"/${lib}
		1035	done
		1036	}
		1037
		1038	# @FUNCTION: preserve_old_lib_notify
		1039	# @USAGE: <libs to notify> [more libs]
		1040	# @DESCRIPTION:
		1041	# Spit helpful messages about the libraries preserved by preserve_old_lib.
		1042	preserve_old_lib_notify() {
		1043	if [[ ${EBUILD_PHASE} != "postinst" ]] ; then
		1044	eerror "preserve_old_lib_notify() must be called from pkg_postinst() only"
		1045	die "Invalid preserve_old_lib_notify() usage"
		1046	fi
		1047
		1048	# let portage worry about it
		1049	has preserve-libs ${FEATURES} && return 0
		1050
		1051	local lib notice=0
		1052	for lib in "$@" ; do
		1053	[[ -e ${ROOT}/${lib} ]] \|\| continue
		1054	if [[ ${notice} -eq 0 ]] ; then
		1055	notice=1
		1056	ewarn "Old versions of installed libraries were detected on your system."
		1057	ewarn "In order to avoid breaking packages that depend on these old libs,"
		1058	ewarn "the libraries are not being removed. You need to run revdep-rebuild"
		1059	ewarn "in order to remove these old dependencies. If you do not have this"
		1060	ewarn "helper program, simply emerge the 'gentoolkit' package."
		1061	ewarn
		1062	fi
		1063	# temp hack for #348634 #357225
		1064	[[ ${PN} == "mpfr" ]] && lib=${lib##*/}
		1065	ewarn " # revdep-rebuild --library '${lib}'"
		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
		1075	}
		1076
		1077	# @FUNCTION: built_with_use
		1078	# @USAGE: [--hidden] [--missing <action>] [-a\|-o] <DEPEND ATOM> <List of USE flags>
		1079	# @DESCRIPTION:
		1080	#
		1081	# Deprecated: Use EAPI 2 use deps in DEPEND\|RDEPEND and with has_version calls.
		1082	#
		1083	# A temporary hack until portage properly supports DEPENDing on USE
		1084	# flags being enabled in packages. This will check to see if the specified
		1085	# DEPEND atom was built with the specified list of USE flags. The
		1086	# --missing option controls the behavior if called on a package that does
		1087	# not actually support the defined USE flags (aka listed in IUSE).
		1088	# The default is to abort (call die). The -a and -o flags control
		1089	# the requirements of the USE flags. They correspond to "and" and "or"
		1090	# logic. So the -a flag means all listed USE flags must be enabled
		1091	# while the -o flag means at least one of the listed IUSE flags must be
		1092	# enabled. The --hidden option is really for internal use only as it
		1093	# means the USE flag we're checking is hidden expanded, so it won't be found
		1094	# in IUSE like normal USE flags.
		1095	#
		1096	# Remember that this function isn't terribly intelligent so order of optional
		1097	# flags matter.
		1098	built_with_use() {
		1099	local hidden="no"
		1100	if [[ $1 == "--hidden" ]] ; then
		1101	hidden="yes"
		1102	shift
		1103	fi
		1104
		1105	local missing_action="die"
		1106	if [[ $1 == "--missing" ]] ; then
		1107	missing_action=$2
		1108	shift ; shift
		1109	case ${missing_action} in
		1110	true\|false\|die) ;;
		1111	*) die "unknown action '${missing_action}'";;
		1112	esac
		1113	fi
		1114
		1115	local opt=$1
		1116	[[ ${opt:0:1} = "-" ]] && shift \|\| opt="-a"
		1117
		1118	local PKG=$(best_version $1)
		1119	[[ -z ${PKG} ]] && die "Unable to resolve $1 to an installed package"
		1120	shift
		1121
		1122	local USEFILE=${ROOT}/var/db/pkg/${PKG}/USE
		1123	local IUSEFILE=${ROOT}/var/db/pkg/${PKG}/IUSE
		1124
		1125	# if the IUSE file doesn't exist, the read will error out, we need to handle
		1126	# this gracefully
		1127	if [[ ! -e ${USEFILE} ]] \|\| [[ ! -e ${IUSEFILE} && ${hidden} == "no" ]] ; then
		1128	case ${missing_action} in
		1129	true) return 0;;
		1130	false) return 1;;
		1131	die) die "Unable to determine what USE flags $PKG was built with";;
		1132	esac
		1133	fi
		1134
		1135	if [[ ${hidden} == "no" ]] ; then
		1136	local IUSE_BUILT=( $(<"${IUSEFILE}") )
		1137	# Don't check USE_EXPAND #147237
		1138	local expand
		1139	for expand in $(echo ${USE_EXPAND} \| tr '[:upper:]' '[:lower:]') ; do
		1140	if [[ $1 == ${expand}_* ]] ; then
		1141	expand=""
		1142	break
		1143	fi
		1144	done
		1145	if [[ -n ${expand} ]] ; then
		1146	if ! has $1 ${IUSE_BUILT[@]#[-+]} ; then
		1147	case ${missing_action} in
		1148	true) return 0;;
		1149	false) return 1;;
		1150	die) die "$PKG does not actually support the $1 USE flag!";;
		1151	esac
		1152	fi
		1153	fi
		1154	fi
		1155
		1156	local USE_BUILT=$(<${USEFILE})
		1157	while [[ $# -gt 0 ]] ; do
		1158	if [[ ${opt} = "-o" ]] ; then
		1159	has $1 ${USE_BUILT} && return 0
		1160	else
		1161	has $1 ${USE_BUILT} \|\| return 1
		1162	fi
		1163	shift
		1164	done
		1165	[[ ${opt} = "-a" ]]
		1166	}
		1167
		1168	# @FUNCTION: epunt_cxx
		1169	# @USAGE: [dir to scan]
		1170	# @DESCRIPTION:
		1171	# Many configure scripts wrongly bail when a C++ compiler could not be
		1172	# detected. If dir is not specified, then it defaults to ${S}.
		1173	#
		1174	# http://bugs.gentoo.org/73450
		1175	epunt_cxx() {
		1176	local dir=$1
		1177	[[ -z ${dir} ]] && dir=${S}
		1178	ebegin "Removing useless C++ checks"
		1179	local f
		1180	find "${dir}" -name configure \| while read f ; do
		1181	patch --no-backup-if-mismatch -p0 "${f}" "${PORTDIR}/eclass/ELT-patches/nocxx/nocxx.patch" > /dev/null
		1182	done
		1183	eend 0
		1184	}
		1185
		1186	# @FUNCTION: make_wrapper
		1187	# @USAGE: <wrapper> <target> [chdir] [libpaths] [installpath]
		1188	# @DESCRIPTION:
		1189	# Create a shell wrapper script named wrapper in installpath
		1190	# (defaults to the bindir) to execute target (default of wrapper) by
		1191	# first optionally setting LD_LIBRARY_PATH to the colon-delimited
		1192	# libpaths followed by optionally changing directory to chdir.
		1193	make_wrapper() {
		1194	local wrapper=$1 bin=$2 chdir=$3 libdir=$4 path=$5
		1195	local tmpwrapper=$(emktemp)
		1196	# We don't want to quote ${bin} so that people can pass complex
		1197	# things as $bin ... "./someprog --args"
		1198	cat << EOF > "${tmpwrapper}"
		1199	#!/bin/sh
		1200	cd "${chdir:-.}"
1299	if [ -z "${newls}" ] ; then	1201	if [ -n "${libdir}" ] ; then
1300	unset LINGUAS	1202	if [ "\${LD_LIBRARY_PATH+set}" = "set" ] ; then
		1203	export LD_LIBRARY_PATH="\${LD_LIBRARY_PATH}:${libdir}"
1301	else	1204	else
1302	export LINGUAS="${newls}"	1205	export LD_LIBRARY_PATH="${libdir}"
		1206	fi
1303	fi	1207	fi
		1208	exec ${bin} "\$@"
		1209	EOF
		1210	chmod go+rx "${tmpwrapper}"
		1211	if [[ -n ${path} ]] ; then
		1212	(
		1213	exeinto "${path}"
		1214	newexe "${tmpwrapper}" "${wrapper}"
		1215	) \|\| die
		1216	else
		1217	newbin "${tmpwrapper}" "${wrapper}" \|\| die
		1218	fi
1304	}	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	check_license() { die "you no longer need this as portage supports ACCEPT_LICENSE itself"; }
		1286
		1287	fi

 Legend:



Removed from v.1.92
 


changed lines


 
Added in v.1.388
 Legend:



Removed from v.1.92
 


changed lines


 
Added in v.1.388
-Removed from v.1.92
+Added in v.1.388

	ViewVC Help
Powered by ViewVC 1.1.20