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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.97
 


changed lines


 
Added in v.1.385
 Legend:



Removed from v.1.97
 


changed lines


 
Added in v.1.385
-Removed from v.1.97
+Added in v.1.385

	ViewVC Help
Powered by ViewVC 1.1.20