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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

Revision 1.125		Revision 1.363
1	# Copyright 1999-2004 Gentoo Foundation	1	# Copyright 1999-2011 Gentoo Foundation
2	# Distributed under the terms of the GNU General Public License v2	2	# Distributed under the terms of the GNU General Public License v2
3	# $Header: /var/cvsroot/gentoo-x86/eclass/eutils.eclass,v 1.125 2004/12/07 01:32:01 vapier Exp $	3	# $Header: /var/cvsroot/gentoo-x86/eclass/eutils.eclass,v 1.363 2011/09/12 20:44:01 mgorny 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	inherit multilib portability
16		19
17	DESCRIPTION="Based on the ${ECLASS} eclass"	20	DESCRIPTION="Based on the ${ECLASS} eclass"
18		21
19	# Wait for the supplied number of seconds. If no argument is supplied, defaults	22	if has "${EAPI:-0}" 0 1 2; then
20	# to five seconds. If the EPAUSE_IGNORE env var is set, don't wait. If we're not	23
21	# outputting to a terminal, don't wait. For compatability purposes, the argument	24	# @FUNCTION: epause
22	# must be an integer greater than zero.	25	# @USAGE: [seconds]
23	# Bug 62950, Ciaran McCreesh <ciaranm@gentoo.org> (05 Sep 2004)	26	# @DESCRIPTION:
		27	# Sleep for the specified number of seconds (default of 5 seconds). Useful when
		28	# printing a message the user should probably be reading and often used in
		29	# conjunction with the ebeep function. If the EPAUSE_IGNORE env var is set,
		30	# don't wait at all. Defined in EAPIs 0 1 and 2.
24	epause() {	31	epause() {
25	if [ -z "$EPAUSE_IGNORE" ] && [ -t 1 ] ; then	32	[[ -z ${EPAUSE_IGNORE} ]] && sleep ${1:-5}
26	sleep ${1:-5}
27	fi
28	}	33	}
29		34
30	# Beep the specified number of times (defaults to five). If our output	35	# @FUNCTION: ebeep
31	# is not a terminal, don't beep. If the EBEEP_IGNORE env var is set,	36	# @USAGE: [number of beeps]
32	# don't beep.	37	# @DESCRIPTION:
33	# Bug 62950, Ciaran McCreesh <ciaranm@gentoo.org> (05 Sep 2004)	38	# Issue the specified number of beeps (default of 5 beeps). Useful when
		39	# printing a message the user should probably be reading and often used in
		40	# conjunction with the epause function. If the EBEEP_IGNORE env var is set,
		41	# don't beep at all. Defined in EAPIs 0 1 and 2.
34	ebeep() {	42	ebeep() {
35	local n	43	local n
36	if [ -z "$EBEEP_IGNORE" ] && [ -t 1 ] ; then	44	if [[ -z ${EBEEP_IGNORE} ]] ; then
37	for ((n=1 ; n <= ${1:-5} ; n++)) ; do	45	for ((n=1 ; n <= ${1:-5} ; n++)) ; do
38	echo -ne "\a"	46	echo -ne "\a"
39	sleep 0.1 &>/dev/null ; sleep 0,1 &>/dev/null	47	sleep 0.1 &>/dev/null ; sleep 0,1 &>/dev/null
40	echo -ne "\a"	48	echo -ne "\a"
41	sleep 1	49	sleep 1
42	done	50	done
43	fi	51	fi
44	}	52	}
45		53
46	# This function simply returns the desired lib directory. With portage	54	else
47	# 2.0.51, we now have support for installing libraries to lib32/lib64	55
48	# to accomidate the needs of multilib systems. It's no longer a good idea	56	ebeep() {
49	# to assume all libraries will end up in lib. Replace any (sane) instances	57	ewarn "QA Notice: ebeep is not defined in EAPI=${EAPI}, please file a bug at http://bugs.gentoo.org"
50	# where lib is named directly with $(get_libdir) if possible.	58	}
51	#	59
52	# Travis Tilley <lv@gentoo.org> (24 Aug 2004)	60	epause() {
53	get_libdir() {	61	ewarn "QA Notice: epause is not defined in EAPI=${EAPI}, please file a bug at http://bugs.gentoo.org"
54	LIBDIR_TEST=$(type econf)	62	}
55	if [ ! -z "${CONF_LIBDIR_OVERRIDE}" ] ; then	63
56	# if there is an override, we want to use that... always.
57	CONF_LIBDIR="${CONF_LIBDIR_OVERRIDE}"
58	# We don't need to know the verison of portage. We only need to know
59	# if there is support for CONF_LIBDIR in econf and co.
60	# Danny van Dyk <kugelfang@gentoo.org> 2004/17/09
61	#elif portageq has_version / '<sys-apps/portage-2.0.51_pre20' ; then
62	# # and if there isnt an override, and we're using a version of
63	# # portage without CONF_LIBDIR support, force the use of lib. dolib
64	# # and friends from portage 2.0.50 wont be too happy otherwise.
65	# CONF_LIBDIR="lib"
66	#fi
67	elif [ "${LIBDIR_TEST/CONF_LIBDIR}" == "${LIBDIR_TEST}" ]; then # we don't have CONF_LIBDIR support
68	# will be <portage-2.0.51_pre20
69	CONF_LIBDIR="lib"
70	fi	64	fi
71	# and of course, default to lib if CONF_LIBDIR isnt set
72	echo ${CONF_LIBDIR:=lib}
73	unset LIBDIR_TEST
74	}
75		65
		66	# @FUNCTION: eqawarn
		67	# @USAGE: [message]
		68	# @DESCRIPTION:
		69	# Proxy to ewarn for package managers that don't provide eqawarn and use the PM
		70	# implementation if available. Reuses PORTAGE_ELOG_CLASSES as set by the dev
		71	# profile.
		72	if ! declare -F eqawarn >/dev/null ; then
		73	eqawarn() {
		74	has qa ${PORTAGE_ELOG_CLASSES} && ewarn "$@"
		75	}
		76	fi
76		77
77	get_multilibdir() {	78	# @FUNCTION: ecvs_clean
78	echo ${CONF_MULTILIBDIR:=lib32}	79	# @USAGE: [list of dirs]
		80	# @DESCRIPTION:
		81	# Remove CVS directories recursiveley. Useful when a source tarball contains
		82	# internal CVS directories. Defaults to $PWD.
		83	ecvs_clean() {
		84	[[ -z $* ]] && set -- .
		85	find "$@" -type d -name 'CVS' -prune -print0 \| xargs -0 rm -rf
		86	find "$@" -type f -name '.cvs*' -print0 \| xargs -0 rm -rf
79	}	87	}
80		88
81		89	# @FUNCTION: esvn_clean
82	# Sometimes you need to override the value returned by get_libdir. A good	90	# @USAGE: [list of dirs]
83	# example of this is xorg-x11, where lib32 isnt a supported configuration,	91	# @DESCRIPTION:
84	# and where lib64 -must- be used on amd64 (for applications that need lib	92	# Remove .svn directories recursiveley. Useful when a source tarball contains
85	# to be 32bit, such as adobe acrobat). Note that this override also bypasses	93	# internal Subversion directories. Defaults to $PWD.
86	# portage version sanity checking.	94	esvn_clean() {
87	# get_libdir_override expects one argument, the result get_libdir should	95	[[ -z $* ]] && set -- .
88	# return:	96	find "$@" -type d -name '.svn' -prune -print0 \| xargs -0 rm -rf
89	#
90	# get_libdir_override lib64
91	#
92	# Travis Tilley <lv@gentoo.org> (31 Aug 2004)
93	get_libdir_override() {
94	CONF_LIBDIR="$1"
95	CONF_LIBDIR_OVERRIDE="$1"
96	}	97	}
97		98
98	# This function generate linker scripts in /usr/lib for dynamic	99	# @FUNCTION: eshopts_push
99	# libs in /lib. This is to fix linking problems when you have	100	# @USAGE: [options to `set` or `shopt`]
100	# the .so in /lib, and the .a in /usr/lib. What happens is that	101	# @DESCRIPTION:
101	# in some cases when linking dynamic, the .a in /usr/lib is used	102	# Often times code will want to enable a shell option to change code behavior.
102	# instead of the .so in /lib due to gcc/libtool tweaking ld's	103	# Since changing shell options can easily break other pieces of code (which
103	# library search path. This cause many builds to fail.	104	# assume the default state), eshopts_push is used to (1) push the current shell
104	# See bug #4411 for more info.	105	# options onto a stack and (2) pass the specified arguments to set.
105	#	106	#
106	# To use, simply call:	107	# If the first argument is '-s' or '-u', we assume you want to call `shopt`
		108	# rather than `set` as there are some options only available via that.
107	#	109	#
108	# gen_usr_ldscript libfoo.so	110	# A common example is to disable shell globbing so that special meaning/care
109	#	111	# may be used with variables/arguments to custom functions. That would be:
110	# Note that you should in general use the unversioned name of	112	# @CODE
111	# the library, as ldconfig should usually update it correctly	113	# eshopts_push -o noglob
112	# to point to the latest version of the library present.	114	# for x in ${foo} ; do
113	#	115	# if ...some check... ; then
114	# <azarah@gentoo.org> (26 Oct 2002)	116	# eshopts_pop
115	#
116	gen_usr_ldscript() {
117	local libdir="$(get_libdir)"
118	# Just make sure it exists
119	dodir /usr/${libdir}
120
121	cat > "${D}/usr/${libdir}/${1}" << END_LDSCRIPT
122	/* GNU ld script
123	Because Gentoo have critical dynamic libraries
124	in /lib, and the static versions in /usr/lib, we
125	need to have a "fake" dynamic lib in /usr/lib,
126	otherwise we run into linking problems.
127	See bug #4411 on http://bugs.gentoo.org/ for
128	more info. */
129	GROUP ( /${libdir}/${1} )
130	END_LDSCRIPT
131	fperms a+x "/usr/${libdir}/${1}"
132	}
133
134	# Simple function to draw a line consisting of '=' the same length as $*
135	#
136	# <azarah@gentoo.org> (11 Nov 2002)
137	#
138	draw_line() {
139	local i=0
140	local str_length=""
141
142	# Handle calls that do not have args, or wc not being installed ...
143	if [ -z "$1" -o ! -x "$(which wc 2>/dev/null)" ]
144	then
145	echo "==============================================================="
146	return 0	117	# return 0
147	fi	118	# fi
148
149	# Get the length of $*
150	str_length="$(echo -n "$*" \| wc -m)"
151
152	while [ "$i" -lt "${str_length}" ]
153	do
154	echo -n "="
155
156	i=$((i + 1))
157	done	119	# done
158		120	# eshopts_pop
159	echo	121	# @CODE
160		122	eshopts_push() {
161	return 0	123	# have to assume __ESHOPTS_SAVE__ isn't screwed with
		124	# as a `declare -a` here will reset its value
		125	local i=${#__ESHOPTS_SAVE__[@]}
		126	if [[ $1 == -[su] ]] ; then
		127	__ESHOPTS_SAVE__[$i]=$(shopt -p)
		128	[[ $# -eq 0 ]] && return 0
		129	shopt "$@" \|\| die "eshopts_push: bad options to shopt: $*"
		130	else
		131	__ESHOPTS_SAVE__[$i]=$-
		132	[[ $# -eq 0 ]] && return 0
		133	set "$@" \|\| die "eshopts_push: bad options to set: $*"
		134	fi
162	}	135	}
163		136
164	# Default directory where patches are located	137	# @FUNCTION: eshopts_pop
		138	# @USAGE:
		139	# @DESCRIPTION:
		140	# Restore the shell options to the state saved with the corresponding
		141	# eshopts_push call. See that function for more details.
		142	eshopts_pop() {
		143	[[ $# -ne 0 ]] && die "eshopts_pop takes no arguments"
		144	local i=$(( ${#__ESHOPTS_SAVE__[@]} - 1 ))
		145	[[ ${i} -eq -1 ]] && die "eshopts_{push,pop}: unbalanced pair"
		146	local s=${__ESHOPTS_SAVE__[$i]}
		147	unset __ESHOPTS_SAVE__[$i]
		148	if [[ ${s} == "shopt -"* ]] ; then
		149	eval "${s}" \|\| die "eshopts_pop: sanity: invalid shopt options: ${s}"
		150	else
		151	set +$- \|\| die "eshopts_pop: sanity: invalid shell settings: $-"
		152	set -${s} \|\| die "eshopts_pop: sanity: unable to restore saved shell settings: ${s}"
		153	fi
		154	}
		155
		156	# @VARIABLE: EPATCH_SOURCE
		157	# @DESCRIPTION:
		158	# Default directory to search for patches.
165	EPATCH_SOURCE="${WORKDIR}/patch"	159	EPATCH_SOURCE="${WORKDIR}/patch"
166	# Default extension for patches	160	# @VARIABLE: EPATCH_SUFFIX
		161	# @DESCRIPTION:
		162	# Default extension for patches (do not prefix the period yourself).
167	EPATCH_SUFFIX="patch.bz2"	163	EPATCH_SUFFIX="patch.bz2"
		164	# @VARIABLE: EPATCH_OPTS
		165	# @DESCRIPTION:
168	# Default options for patch	166	# Default options for patch:
		167	# @CODE
169	# Set -g0 to keep RCS, ClearCase, Perforce and SCCS happy. Bug #24571	168	# -g0 - keep RCS, ClearCase, Perforce and SCCS happy #24571
170	EPATCH_OPTS="-g0"	169	# --no-backup-if-mismatch - do not leave .orig files behind
		170	# -E - automatically remove empty files
		171	# @CODE
		172	EPATCH_OPTS="-g0 -E --no-backup-if-mismatch"
		173	# @VARIABLE: EPATCH_EXCLUDE
		174	# @DESCRIPTION:
171	# List of patches not to apply. Not this is only file names,	175	# List of patches not to apply. Note this is only file names,
172	# and not the full path ..	176	# and not the full path. Globs accepted.
173	EPATCH_EXCLUDE=""	177	EPATCH_EXCLUDE=""
		178	# @VARIABLE: EPATCH_SINGLE_MSG
		179	# @DESCRIPTION:
174	# Change the printed message for a single patch.	180	# Change the printed message for a single patch.
175	EPATCH_SINGLE_MSG=""	181	EPATCH_SINGLE_MSG=""
176	# Force applying bulk patches even if not following the style:	182	# @VARIABLE: EPATCH_MULTI_MSG
177	#	183	# @DESCRIPTION:
178	# ??_${ARCH}_foo.${EPATCH_SUFFIX}	184	# Change the printed message for multiple patches.
179	#	185	EPATCH_MULTI_MSG="Applying various patches (bugfixes/updates) ..."
		186	# @VARIABLE: EPATCH_FORCE
		187	# @DESCRIPTION:
		188	# Only require patches to match EPATCH_SUFFIX rather than the extended
		189	# arch naming style.
180	EPATCH_FORCE="no"	190	EPATCH_FORCE="no"
181		191
182	# This function is for bulk patching, or in theory for just one	192	# @FUNCTION: epatch
183	# or two patches.	193	# @USAGE: [patches] [dirs of patches]
		194	# @DESCRIPTION:
		195	# epatch is designed to greatly simplify the application of patches. It can
		196	# process patch files directly, or directories of patches. The patches may be
		197	# compressed (bzip/gzip/etc...) or plain text. You generally need not specify
		198	# the -p option as epatch will automatically attempt -p0 to -p5 until things
		199	# apply successfully.
184	#	200	#
185	# It should work with .bz2, .gz, .zip and plain text patches.	201	# If you do not specify any options, then epatch will default to the directory
186	# Currently all patches should be the same format.	202	# specified by EPATCH_SOURCE.
187	#	203	#
188	# You do not have to specify '-p' option to patch, as it will	204	# When processing directories, epatch will apply all patches that match:
189	# try with -p0 to -p5 until it succeed, or fail at -p5.	205	# @CODE
190	#	206	# if ${EPATCH_FORCE} != "yes"
191	# Above EPATCH_* variables can be used to control various defaults,
192	# bug they should be left as is to ensure an ebuild can rely on
193	# them for.
194	#
195	# Patches are applied in current directory.
196	#
197	# Bulk Patches should preferibly have the form of:
198	#
199	# ??_${ARCH}_foo.${EPATCH_SUFFIX}	207	# ??_${ARCH}_foo.${EPATCH_SUFFIX}
		208	# else
		209	# *.${EPATCH_SUFFIX}
		210	# @CODE
		211	# The leading ?? are typically numbers used to force consistent patch ordering.
		212	# The arch field is used to apply patches only for the host architecture with
		213	# the special value of "all" means apply for everyone. Note that using values
		214	# other than "all" is highly discouraged -- you should apply patches all the
		215	# time and let architecture details be detected at configure/compile time.
200	#	216	#
201	# For example:	217	# If EPATCH_SUFFIX is empty, then no period before it is implied when searching
		218	# for patches to apply.
202	#	219	#
203	# 01_all_misc-fix.patch.bz2	220	# Refer to the other EPATCH_xxx variables for more customization of behavior.
204	# 02_sparc_another-fix.patch.bz2
205	#
206	# This ensures that there are a set order, and you can have ARCH
207	# specific patches.
208	#
209	# If you however give an argument to epatch(), it will treat it as a
210	# single patch that need to be applied if its a file. If on the other
211	# hand its a directory, it will set EPATCH_SOURCE to this.
212	#
213	# <azarah@gentoo.org> (10 Nov 2002)
214	#
215	epatch() {	221	epatch() {
216	local PIPE_CMD=""	222	_epatch_draw_line() {
217	local STDERR_TARGET="${T}/$$.out"	223	# create a line of same length as input string
218	local PATCH_TARGET="${T}/$$.patch"	224	[[ -z $1 ]] && set "$(printf "%65s" '')"
219	local PATCH_SUFFIX=""	225	echo "${1//?/=}"
220	local SINGLE_PATCH="no"	226	}
221	local x=""
222		227
223	if [ "$#" -gt 1 ]	228	unset P4CONFIG P4PORT P4USER # keep perforce at bay #56402
224	then	229
		230	# Let the rest of the code process one user arg at a time --
		231	# each arg may expand into multiple patches, and each arg may
		232	# need to start off with the default global EPATCH_xxx values
		233	if [[ $# -gt 1 ]] ; then
225	local m=""	234	local m
226	einfo "${#} patches to apply ..."
227	for m in "$@" ; do	235	for m in "$@" ; do
228	epatch "${m}"	236	epatch "${m}"
229	done	237	done
230	return 0	238	return 0
231	fi	239	fi
232		240
233	if [ -n "$1" -a -f "$1" ]	241	local SINGLE_PATCH="no"
234	then	242	# no args means process ${EPATCH_SOURCE}
		243	[[ $# -eq 0 ]] && set -- "${EPATCH_SOURCE}"
		244
		245	if [[ -f $1 ]] ; then
235	SINGLE_PATCH="yes"	246	SINGLE_PATCH="yes"
236		247	set -- "$1"
237	local EPATCH_SOURCE="$1"	248	# Use the suffix from the single patch (localize it); the code
		249	# below will find the suffix for us
238	local EPATCH_SUFFIX="${1##*\.}"	250	local EPATCH_SUFFIX=$1
239		251
240	elif [ -n "$1" -a -d "$1" ]	252	elif [[ -d $1 ]] ; then
241	then	253	# Some people like to make dirs of patches w/out suffixes (vim)
242	# Allow no extension if EPATCH_FORCE=yes ... used by vim for example ...	254	set -- "$1"/*${EPATCH_SUFFIX:+."${EPATCH_SUFFIX}"}
243	if [ "${EPATCH_FORCE}" = "yes" ] && [ -z "${EPATCH_SUFFIX}" ]	255
		256	elif [[ -f ${EPATCH_SOURCE}/$1 ]] ; then
		257	# Re-use EPATCH_SOURCE as a search dir
		258	epatch "${EPATCH_SOURCE}/$1"
		259	return $?
		260
		261	else
		262	# sanity check ... if it isn't a dir or file, wtf man ?
		263	[[ $# -ne 0 ]] && EPATCH_SOURCE=$1
		264	echo
		265	eerror "Cannot find \$EPATCH_SOURCE! Value for \$EPATCH_SOURCE is:"
		266	eerror
		267	eerror " ${EPATCH_SOURCE}"
		268	eerror " ( ${EPATCH_SOURCE##*/} )"
		269	echo
		270	die "Cannot find \$EPATCH_SOURCE!"
		271	fi
		272
		273	local PIPE_CMD
		274	case ${EPATCH_SUFFIX##*\.} in
		275	xz) PIPE_CMD="xz -dc" ;;
		276	lzma) PIPE_CMD="lzma -dc" ;;
		277	bz2) PIPE_CMD="bzip2 -dc" ;;
		278	gz\|Z\|z) PIPE_CMD="gzip -dc" ;;
		279	ZIP\|zip) PIPE_CMD="unzip -p" ;;
		280	*) ;;
		281	esac
		282
		283	[[ ${SINGLE_PATCH} == "no" ]] && einfo "${EPATCH_MULTI_MSG}"
		284
		285	local x
		286	for x in "$@" ; do
		287	# If the patch dir given contains subdirs, or our EPATCH_SUFFIX
		288	# didn't match anything, ignore continue on
		289	[[ ! -f ${x} ]] && continue
		290
		291	local patchname=${x##*/}
		292
		293	# Apply single patches, or forced sets of patches, or
		294	# patches with ARCH dependant names.
		295	# ???_arch_foo.patch
		296	# Else, skip this input altogether
		297	local a=${patchname#*_} # strip the ???_
		298	a=${a%%_*} # strip the _foo.patch
		299	if ! [[ ${SINGLE_PATCH} == "yes" \|\| \
		300	${EPATCH_FORCE} == "yes" \|\| \
		301	${a} == all \|\| \
		302	${a} == ${ARCH} ]]
244	then	303	then
245	local EPATCH_SOURCE="$1/*"	304	continue
		305	fi
		306
		307	# Let people filter things dynamically
		308	if [[ -n ${EPATCH_EXCLUDE} ]] ; then
		309	# let people use globs in the exclude
		310	eshopts_push -o noglob
		311
		312	local ex
		313	for ex in ${EPATCH_EXCLUDE} ; do
		314	if [[ ${patchname} == ${ex} ]] ; then
		315	eshopts_pop
		316	continue 2
		317	fi
		318	done
		319
		320	eshopts_pop
		321	fi
		322
		323	if [[ ${SINGLE_PATCH} == "yes" ]] ; then
		324	if [[ -n ${EPATCH_SINGLE_MSG} ]] ; then
		325	einfo "${EPATCH_SINGLE_MSG}"
		326	else
		327	einfo "Applying ${patchname} ..."
		328	fi
246	else	329	else
247	local EPATCH_SOURCE="$1/*.${EPATCH_SUFFIX}"	330	einfo " ${patchname} ..."
248	fi	331	fi
249	else	332
250	if [ ! -d ${EPATCH_SOURCE} ] \|\| [ -n "$1" ]	333	# most of the time, there will only be one run per unique name,
251	then	334	# but if there are more, make sure we get unique log filenames
252	if [ -n "$1" -a "${EPATCH_SOURCE}" = "${WORKDIR}/patch" ]	335	local STDERR_TARGET="${T}/${patchname}.out"
253	then	336	if [[ -e ${STDERR_TARGET} ]] ; then
254	EPATCH_SOURCE="$1"	337	STDERR_TARGET="${T}/${patchname}-$$.out"
		338	fi
		339
		340	printf "*** %s ***\n\n" "${patchname}" > "${STDERR_TARGET}"
		341
		342	# Decompress the patch if need be
		343	local count=0
		344	local PATCH_TARGET
		345	if [[ -n ${PIPE_CMD} ]] ; then
		346	PATCH_TARGET="${T}/$$.patch"
		347	echo "PIPE_COMMAND: ${PIPE_CMD} ${x} > ${PATCH_TARGET}" >> "${STDERR_TARGET}"
		348
		349	if ! (${PIPE_CMD} "${x}" > "${PATCH_TARGET}") >> "${STDERR_TARGET}" 2>&1 ; then
		350	echo
		351	eerror "Could not extract patch!"
		352	#die "Could not extract patch!"
		353	count=5
		354	break
255	fi	355	fi
		356	else
		357	PATCH_TARGET=${x}
		358	fi
256		359
		360	# Check for absolute paths in patches. If sandbox is disabled,
		361	# people could (accidently) patch files in the root filesystem.
		362	# Or trigger other unpleasantries #237667. So disallow -p0 on
		363	# such patches.
		364	local abs_paths=$(egrep -n '^[-+]{3} /' "${PATCH_TARGET}" \| awk '$2 != "/dev/null" { print }')
		365	if [[ -n ${abs_paths} ]] ; then
		366	count=1
		367	printf "NOTE: skipping -p0 due to absolute paths in patch:\n%s\n" "${abs_paths}" >> "${STDERR_TARGET}"
		368	fi
		369	# Similar reason, but with relative paths.
		370	local rel_paths=$(egrep -n '^[-+]{3} [^ ]*[.][.]/' "${PATCH_TARGET}")
		371	if [[ -n ${rel_paths} ]] ; then
		372	eqawarn "QA Notice: Your patch uses relative paths '../'."
		373	eqawarn " In the future this will cause a failure."
		374	eqawarn "${rel_paths}"
		375	fi
		376
		377	# Dynamically detect the correct -p# ... i'm lazy, so shoot me :/
		378	while [[ ${count} -lt 5 ]] ; do
		379	# Generate some useful debug info ...
		380	(
		381	_epatch_draw_line "*** ${patchname} ***"
257	echo	382	echo
258	eerror "Cannot find \$EPATCH_SOURCE! Value for \$EPATCH_SOURCE is:"	383	echo "PATCH COMMAND: patch -p${count} ${EPATCH_OPTS} < '${PATCH_TARGET}'"
		384	echo
		385	_epatch_draw_line "*** ${patchname} ***"
		386	patch -p${count} ${EPATCH_OPTS} --dry-run -f < "${PATCH_TARGET}" 2>&1
		387	ret=$?
		388	echo
		389	echo "patch program exited with status ${ret}"
		390	exit ${ret}
		391	) >> "${STDERR_TARGET}"
		392
		393	if [ $? -eq 0 ] ; then
		394	(
		395	_epatch_draw_line "*** ${patchname} ***"
		396	echo
		397	echo "ACTUALLY APPLYING ${patchname} ..."
		398	echo
		399	_epatch_draw_line "*** ${patchname} ***"
		400	patch -p${count} ${EPATCH_OPTS} < "${PATCH_TARGET}" 2>&1
		401	ret=$?
		402	echo
		403	echo "patch program exited with status ${ret}"
		404	exit ${ret}
		405	) >> "${STDERR_TARGET}"
		406
		407	if [ $? -ne 0 ] ; then
		408	echo
		409	eerror "A dry-run of patch command succeeded, but actually"
		410	eerror "applying the patch failed!"
		411	#die "Real world sux compared to the dreamworld!"
		412	count=5
		413	fi
		414	break
		415	fi
		416
		417	: $(( count++ ))
		418	done
		419
		420	# if we had to decompress the patch, delete the temp one
		421	if [[ -n ${PIPE_CMD} ]] ; then
		422	rm -f "${PATCH_TARGET}"
		423	fi
		424
		425	if [[ ${count} -ge 5 ]] ; then
		426	echo
		427	eerror "Failed Patch: ${patchname} !"
		428	eerror " ( ${PATCH_TARGET} )"
259	eerror	429	eerror
260	eerror " ${EPATCH_SOURCE}"	430	eerror "Include in your bugreport the contents of:"
		431	eerror
		432	eerror " ${STDERR_TARGET}"
261	echo	433	echo
262	die "Cannot find \$EPATCH_SOURCE!"	434	die "Failed Patch: ${patchname}!"
263	fi
264
265	local EPATCH_SOURCE="${EPATCH_SOURCE}/*.${EPATCH_SUFFIX}"
266	fi
267
268	case ${EPATCH_SUFFIX##*\.} in
269	bz2)
270	PIPE_CMD="bzip2 -dc"
271	PATCH_SUFFIX="bz2"
272	;;
273	gz\|Z\|z)
274	PIPE_CMD="gzip -dc"
275	PATCH_SUFFIX="gz"
276	;;
277	ZIP\|zip)
278	PIPE_CMD="unzip -p"
279	PATCH_SUFFIX="zip"
280	;;
281	*)
282	PIPE_CMD="cat"
283	PATCH_SUFFIX="patch"
284	;;
285	esac
286
287	if [ "${SINGLE_PATCH}" = "no" ]
288	then
289	einfo "Applying various patches (bugfixes/updates) ..."
290	fi
291	for x in ${EPATCH_SOURCE}
292	do
293	# New ARCH dependant patch naming scheme ...
294	#
295	# ???_arch_foo.patch
296	#
297	if [ -f ${x} ] && \
298	([ "${SINGLE_PATCH}" = "yes" -o "${x/_all_}" != "${x}" -o "`eval echo \$\{x/_${ARCH}_\}`" != "${x}" ] \|\| \
299	[ "${EPATCH_FORCE}" = "yes" ])
300	then
301	local count=0
302	local popts="${EPATCH_OPTS}"
303
304	if [ -n "${EPATCH_EXCLUDE}" ]
305	then
306	if [ "`eval echo \$\{EPATCH_EXCLUDE/${x##*/}\}`" != "${EPATCH_EXCLUDE}" ]
307	then
308	continue
309	fi
310	fi	435	fi
311		436
312	if [ "${SINGLE_PATCH}" = "yes" ]	437	# if everything worked, delete the patch log
313	then	438	rm -f "${STDERR_TARGET}"
314	if [ -n "${EPATCH_SINGLE_MSG}" ]
315	then
316	einfo "${EPATCH_SINGLE_MSG}"
317	else
318	einfo "Applying ${x##*/} ..."
319	fi
320	else
321	einfo " ${x##*/} ..."
322	fi
323
324	echo "***** ${x##/} ***" > ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}
325	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
326
327	# Allow for prefix to differ ... im lazy, so shoot me :/
328	while [ "${count}" -lt 5 ]
329	do
330	# Generate some useful debug info ...
331	draw_line "***** ${x##/} ***" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}
332	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
333
334	if [ "${PATCH_SUFFIX}" != "patch" ]
335	then
336	echo -n "PIPE_COMMAND: " >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
337	echo "${PIPE_CMD} ${x} > ${PATCH_TARGET}" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
338	else
339	PATCH_TARGET="${x}"
340	fi
341
342	echo -n "PATCH COMMAND: " >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
343	echo "patch -p${count} ${popts} < ${PATCH_TARGET}" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
344
345	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
346	draw_line "***** ${x##/} ***" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}
347
348	if [ "${PATCH_SUFFIX}" != "patch" ]
349	then
350	if ! (${PIPE_CMD} ${x} > ${PATCH_TARGET}) >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/} 2>&1
351	then
352	echo
353	eerror "Could not extract patch!"
354	#die "Could not extract patch!"
355	count=5
356	break
357	fi
358	fi
359
360	if (cat ${PATCH_TARGET} \| patch -p${count} ${popts} --dry-run -f) >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/} 2>&1
361	then
362	draw_line "***** ${x##/} ***" > ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}.real
363	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}.real
364	echo "ACTUALLY APPLYING ${x##/} ..." >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}.real
365	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}.real
366	draw_line "***** ${x##/} ***" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}.real
367
368	cat ${PATCH_TARGET} \| patch -p${count} ${popts} >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}.real 2>&1
369
370	if [ "$?" -ne 0 ]
371	then
372	cat ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}.real >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}
373	echo
374	eerror "A dry-run of patch command succeeded, but actually"
375	eerror "applying the patch failed!"
376	#die "Real world sux compared to the dreamworld!"
377	count=5
378	fi
379
380	rm -f ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}.real
381
382	break
383	fi
384
385	count=$((count + 1))
386	done
387
388	if [ "${PATCH_SUFFIX}" != "patch" ]
389	then
390	rm -f ${PATCH_TARGET}
391	fi
392
393	if [ "${count}" -eq 5 ]
394	then
395	echo
396	eerror "Failed Patch: ${x##*/}!"
397	eerror
398	eerror "Include in your bugreport the contents of:"
399	eerror
400	eerror " ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}"
401	echo
402	die "Failed Patch: ${x##*/}!"
403	fi
404
405	rm -f ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
406
407	eend 0	439	eend 0
408	fi
409	done	440	done
410	if [ "${SINGLE_PATCH}" = "no" ]
411	then
412	einfo "Done with patching"
413	fi
414	}
415		441
416	# This function return true if we are using the NPTL pthreads	442	[[ ${SINGLE_PATCH} == "no" ]] && einfo "Done with patching"
417	# implementation.	443	: # everything worked
418	#	444	}
419	# <azarah@gentoo.org> (06 March 2003)
420	#
421	have_NPTL() {
422	cat > ${T}/test-nptl.c <<-"END"
423	#define _XOPEN_SOURCE
424	#include <unistd.h>
425	#include <stdio.h>
426		445
427	int main()	446	# @FUNCTION: epatch_user
428	{	447	# @USAGE:
429	char buf[255];	448	# @DESCRIPTION:
430	char *str = buf;	449	# Applies user-provided patches to the source tree. The patches are
		450	# taken from /etc/portage/patches/<CATEGORY>/<PF\|P\|PN>/, where the first
		451	# of these three directories to exist will be the one to use, ignoring
		452	# any more general directories which might exist as well.
		453	#
		454	# User patches are intended for quick testing of patches without ebuild
		455	# modifications, as well as for permanent customizations a user might
		456	# desire. Obviously, there can be no official support for arbitrarily
		457	# patched ebuilds. So whenever a build log in a bug report mentions that
		458	# user patches were applied, the user should be asked to reproduce the
		459	# problem without these.
		460	#
		461	# Not all ebuilds do call this function, so placing patches in the
		462	# stated directory might or might not work, depending on the package and
		463	# the eclasses it inherits and uses. It is safe to call the function
		464	# repeatedly, so it is always possible to add a call at the ebuild
		465	# level. The first call is the time when the patches will be
		466	# applied.
		467	#
		468	# Ideally, this function should be called after gentoo-specific patches
		469	# have been applied, so that their code can be modified as well, but
		470	# before calls to e.g. eautoreconf, as the user patches might affect
		471	# autotool input files as well.
		472	epatch_user() {
		473	[[ $# -ne 0 ]] && die "epatch_user takes no options"
431		474
432	confstr(_CS_GNU_LIBPTHREAD_VERSION, str, 255);	475	# Allow multiple calls to this function; ignore all but the first
433	if (NULL != str) {	476	local applied="${T}/epatch_user.applied"
434	printf("%s\n", str);	477	[[ -e ${applied} ]] && return 2
435	if (NULL != strstr(str, "NPTL"))
436	return 0;
437	}
438		478
439	return 1;	479	# don't clobber any EPATCH vars that the parent might want
440	}	480	local EPATCH_SOURCE check base=${PORTAGE_CONFIGROOT%/}/etc/portage/patches
441	END	481	for check in {${CATEGORY}/${PF},${CATEGORY}/${P},${CATEGORY}/${PN}}; do
442		482	EPATCH_SOURCE=${base}/${CTARGET}/${check}
443	einfon "Checking for _CS_GNU_LIBPTHREAD_VERSION support in glibc ..."	483	[[ -r ${EPATCH_SOURCE} ]] \|\| EPATCH_SOURCE=${base}/${CHOST}/${check}
444	if gcc -o ${T}/nptl ${T}/test-nptl.c &> /dev/null	484	[[ -r ${EPATCH_SOURCE} ]] \|\| EPATCH_SOURCE=${base}/${check}
445	then	485	if [[ -d ${EPATCH_SOURCE} ]] ; then
446	echo "yes"	486	EPATCH_SOURCE=${EPATCH_SOURCE} \
447	einfon "Checking what PTHREADS implementation we have ..."	487	EPATCH_SUFFIX="patch" \
448	if ${T}/nptl	488	EPATCH_FORCE="yes" \
449	then	489	EPATCH_MULTI_MSG="Applying user patches from ${EPATCH_SOURCE} ..." \
		490	epatch
		491	echo "${EPATCH_SOURCE}" > "${applied}"
450	return 0	492	return 0
451	else
452	return 1
453	fi
454	else
455	echo "no"
456	fi	493	fi
457		494	done
		495	echo "none" > "${applied}"
458	return 1	496	return 1
459	}	497	}
460		498
461	# This function check how many cpu's are present, and then set	499	# @FUNCTION: emktemp
462	# -j in MAKEOPTS accordingly.	500	# @USAGE: [temp dir]
463	#	501	# @DESCRIPTION:
464	# Thanks to nall <nall@gentoo.org> for this.
465	#
466	get_number_of_jobs() {
467	local jobs=0
468
469	if [ ! -r /proc/cpuinfo ]
470	then
471	return 1
472	fi
473
474	# This bit is from H?kan Wessberg <nacka-gentoo@refug.org>, bug #13565.
475	if [ "`egrep "^[[:space:]]*MAKEOPTS=" /etc/make.conf \| wc -l`" -gt 0 ]
476	then
477	ADMINOPTS="`egrep "^[[:space:]]*MAKEOPTS=" /etc/make.conf \| cut -d= -f2 \| sed 's/\"//g'`"
478	ADMINPARAM="`echo ${ADMINOPTS} \| gawk '{match($0, /-j [0-9]/, opt); print opt[0]}'`"
479	ADMINPARAM="${ADMINPARAM/-j}"
480	fi
481
482	export MAKEOPTS="`echo ${MAKEOPTS} \| sed -e 's:-j [0-9]::g'`"
483
484	if [ "${ARCH}" = "amd64" -o "${ARCH}" = "x86" -o "${ARCH}" = "hppa" -o \
485	"${ARCH}" = "arm" -o "${ARCH}" = "mips" -o "${ARCH}" = "ia64" ]
486	then
487	# these archs will always have "[Pp]rocessor"
488	jobs="$((`grep -c ^[Pp]rocessor /proc/cpuinfo` * 2))"
489
490	elif [ "${ARCH}" = "sparc" -o "${ARCH}" = "sparc64" ]
491	then
492	# sparc always has "ncpus active"
493	jobs="$((`grep "^ncpus active" /proc/cpuinfo \| sed -e "s/^.: //"` 2))"
494
495	elif [ "${ARCH}" = "alpha" ]
496	then
497	# alpha has "cpus active", but only when compiled with SMP
498	if [ "`grep -c "^cpus active" /proc/cpuinfo`" -eq 1 ]
499	then
500	jobs="$((`grep "^cpus active" /proc/cpuinfo \| sed -e "s/^.: //"` 2))"
501	else
502	jobs=2
503	fi
504
505	elif [ "${ARCH}" = "ppc" -o "${ARCH}" = "ppc64" ]
506	then
507	# ppc has "processor", but only when compiled with SMP
508	if [ "`grep -c "^processor" /proc/cpuinfo`" -eq 1 ]
509	then
510	jobs="$((`grep -c ^processor /proc/cpuinfo` * 2))"
511	else
512	jobs=2
513	fi
514	elif [ "${ARCH}" = "s390" ]
515	then
516	# s390 has "# processors : "
517	jobs="$((`grep "^\# processors" /proc/cpuinfo \| sed -e "s/^.: //"` 2))"
518	else
519	jobs="$((`grep -c ^cpu /proc/cpuinfo` * 2))"
520	die "Unknown ARCH -- ${ARCH}!"
521	fi
522
523	# Make sure the number is valid ...
524	if [ "${jobs}" -lt 1 ]
525	then
526	jobs=1
527	fi
528
529	if [ -n "${ADMINPARAM}" ]
530	then
531	if [ "${jobs}" -gt "${ADMINPARAM}" ]
532	then
533	einfo "Setting make jobs to \"-j${ADMINPARAM}\" to ensure successful merge ..."
534	export MAKEOPTS="${MAKEOPTS} -j${ADMINPARAM}"
535	else
536	einfo "Setting make jobs to \"-j${jobs}\" to ensure successful merge ..."
537	export MAKEOPTS="${MAKEOPTS} -j${jobs}"
538	fi
539	fi
540	}
541
542	# Cheap replacement for when debianutils (and thus mktemp)	502	# Cheap replacement for when debianutils (and thus mktemp)
543	# does not exist on the users system	503	# does not exist on the users system.
544	# vapier@gentoo.org
545	#
546	# Takes just 1 optional parameter (the directory to create tmpfile in)
547	emktemp() {	504	emktemp() {
548	local exe="touch"	505	local exe="touch"
549	[ "$1" == "-d" ] && exe="mkdir" && shift	506	[[ $1 == -d ]] && exe="mkdir" && shift
550	local topdir="$1"	507	local topdir=$1
551		508
552	if [ -z "${topdir}" ]	509	if [[ -z ${topdir} ]] ; then
553	then
554	[ -z "${T}" ] \	510	[[ -z ${T} ]] \
555	&& topdir="/tmp" \	511	&& topdir="/tmp" \
556	\|\| topdir="${T}"	512	\|\| topdir=${T}
557	fi	513	fi
558		514
559	if [ -z "$(type -p mktemp)" ]	515	if ! type -P mktemp > /dev/null ; then
560	then	516	# system lacks `mktemp` so we have to fake it
561	local tmp=/	517	local tmp=/
562	while [ -e "${tmp}" ] ; do	518	while [[ -e ${tmp} ]] ; do
563	tmp="${topdir}/tmp.${RANDOM}.${RANDOM}.${RANDOM}"	519	tmp=${topdir}/tmp.${RANDOM}.${RANDOM}.${RANDOM}
564	done	520	done
565	${exe} "${tmp}"	521	${exe} "${tmp}" \|\| ${exe} -p "${tmp}"
566	echo "${tmp}"	522	echo "${tmp}"
567	else	523	else
568	[ "${exe}" == "touch" ] \	524	# the args here will give slightly wierd names on BSD,
569	&& exe="-p" \	525	# but should produce a usable file on all userlands
570	\|\| exe="-d"	526	if [[ ${exe} == "touch" ]] ; then
571	mktemp ${exe} "${topdir}"	527	TMPDIR="${topdir}" mktemp -t tmp.XXXXXXXXXX
		528	else
		529	TMPDIR="${topdir}" mktemp -dt tmp.XXXXXXXXXX
572	fi	530	fi
		531	fi
573	}	532	}
574		533
		534	# @FUNCTION: egetent
		535	# @USAGE: <database> <key>
		536	# @MAINTAINER:
		537	# base-system@gentoo.org (Linux)
		538	# Joe Jezak <josejx@gmail.com> (OS X)
		539	# usata@gentoo.org (OS X)
		540	# Aaron Walker <ka0ttic@gentoo.org> (FreeBSD)
		541	# @DESCRIPTION:
575	# Small wrapper for getent (Linux), nidump (Mac OS X),	542	# Small wrapper for getent (Linux),
		543	# nidump (< Mac OS X 10.5), dscl (Mac OS X 10.5),
576	# and pw (FreeBSD) used in enewuser()/enewgroup()	544	# and pw (FreeBSD) used in enewuser()/enewgroup()
577	# Joe Jezak <josejx@gmail.com> and usata@gentoo.org
578	# FBSD stuff: Aaron Walker <ka0ttic@gentoo.org>
579	#
580	# egetent(database, key)
581	egetent() {	545	egetent() {
582	if useq ppc-macos ; then	546	case ${CHOST} in
		547	*-darwin[678])
583	case "$2" in	548	case "$2" in
584	[!0-9]) # Non numeric	549	[!0-9]) # Non numeric
585	nidump $1 . \| awk -F":" "{ if (\$1 ~ /^$2$/) {print \$0;exit;} }"	550	nidump $1 . \| awk -F":" "{ if (\$1 ~ /^$2\$/) {print \$0;exit;} }"
586	;;	551	;;
587	*) # Numeric	552	*) # Numeric
588	nidump $1 . \| awk -F":" "{ if (\$3 == $2) {print \$0;exit;} }"	553	nidump $1 . \| awk -F":" "{ if (\$3 == $2) {print \$0;exit;} }"
589	;;	554	;;
590	esac	555	esac
591	elif useq x86-fbsd ; then	556	;;
592	local action	557	-darwin)
593	if [ "$1" == "passwd" ]	558	local mytype=$1
594	then	559	[[ "passwd" == $mytype ]] && mytype="Users"
595	action="user"	560	[[ "group" == $mytype ]] && mytype="Groups"
596	else	561	case "$2" in
597	action="group"	562	[!0-9]) # Non numeric
		563	dscl . -read /$mytype/$2 2>/dev/null \|grep RecordName
		564	;;
		565	*) # Numeric
		566	local mykey="UniqueID"
		567	[[ $mytype == "Groups" ]] && mykey="PrimaryGroupID"
		568	dscl . -search /$mytype $mykey $2 2>/dev/null
		569	;;
		570	esac
		571	;;
		572	-freebsd\|-dragonfly)
		573	local opts action="user"
		574	[[ $1 == "passwd" ]] \|\| action="group"
		575
		576	# lookup by uid/gid
		577	if [[ $2 == [[:digit:]]* ]] ; then
		578	[[ ${action} == "user" ]] && opts="-u" \|\| opts="-g"
598	fi	579	fi
		580
599	pw show "${action}" "$2" -q	581	pw show ${action} ${opts} "$2" -q
600	else	582	;;
		583	-netbsd\|-openbsd)
		584	grep "$2:\*:" /etc/$1
		585	;;
		586	*)
601	which nscd >& /dev/null && nscd -i "$1"	587	type -p nscd >& /dev/null && nscd -i "$1"
602	getent "$1" "$2"	588	getent "$1" "$2"
603	fi	589	;;
		590	esac
604	}	591	}
605		592
606	# Simplify/standardize adding users to the system	593	# @FUNCTION: enewuser
607	# vapier@gentoo.org	594	# @USAGE: <user> [uid] [shell] [homedir] [groups] [params]
608	#	595	# @DESCRIPTION:
609	# enewuser(username, uid, shell, homedir, groups, extra options)	596	# Same as enewgroup, you are not required to understand how to properly add
610	#	597	# a user to the system. The only required parameter is the username.
611	# Default values if you do not specify any:	598	# Default uid is (pass -1 for this) next available, default shell is
612	# username: REQUIRED !	599	# /bin/false, default homedir is /dev/null, there are no default groups,
613	# uid: next available (see useradd(8))	600	# and default params sets the comment as 'added by portage for ${PN}'.
614	# note: pass -1 to get default behavior
615	# shell: /bin/false
616	# homedir: /dev/null
617	# groups: none
618	# extra: comment of 'added by portage for ${PN}'
619	enewuser() {	601	enewuser() {
		602	case ${EBUILD_PHASE} in
		603	unpack\|compile\|test\|install)
		604	eerror "'enewuser()' called from '${EBUILD_PHASE}()' which is not a pkg_* function."
		605	eerror "Package fails at QA and at life. Please file a bug."
		606	die "Bad package! enewuser is only for use in pkg_* functions!"
		607	esac
		608
620	# get the username	609	# get the username
621	local euser="$1"; shift	610	local euser=$1; shift
622	if [ -z "${euser}" ]	611	if [[ -z ${euser} ]] ; then
623	then
624	eerror "No username specified !"	612	eerror "No username specified !"
625	die "Cannot call enewuser without a username"	613	die "Cannot call enewuser without a username"
626	fi	614	fi
627		615
628	# lets see if the username already exists	616	# lets see if the username already exists
629	if [ "${euser}" == "`egetent passwd \"${euser}\" \| cut -d: -f1`" ]	617	if [[ -n $(egetent passwd "${euser}") ]] ; then
630	then
631	return 0	618	return 0
632	fi	619	fi
633	einfo "Adding user '${euser}' to your system ..."	620	einfo "Adding user '${euser}' to your system ..."
634		621
635	# options to pass to useradd	622	# options to pass to useradd
636	local opts=	623	local opts=
637		624
638	# handle uid	625	# handle uid
639	local euid="$1"; shift	626	local euid=$1; shift
640	if [ ! -z "${euid}" ] && [ "${euid}" != "-1" ]	627	if [[ -n ${euid} && ${euid} != -1 ]] ; then
641	then
642	if [ "${euid}" -gt 0 ]	628	if [[ ${euid} -gt 0 ]] ; then
643	then
644	if [ ! -z "`egetent passwd ${euid}`" ]	629	if [[ -n $(egetent passwd ${euid}) ]] ; then
645	then
646	euid="next"	630	euid="next"
647	fi	631	fi
648	else	632	else
649	eerror "Userid given but is not greater than 0 !"	633	eerror "Userid given but is not greater than 0 !"
650	die "${euid} is not a valid UID"	634	die "${euid} is not a valid UID"
651	fi	635	fi
652	else	636	else
653	euid="next"	637	euid="next"
654	fi	638	fi
655	if [ "${euid}" == "next" ]	639	if [[ ${euid} == "next" ]] ; then
656	then	640	for ((euid = 101; euid <= 999; euid++)); do
657	local pwrange
658	if [ "${USERLAND}" == "BSD" ] ; then
659	pwrange="`jot 898 101`"
660	else
661	pwrange="`seq 101 999`"
662	fi
663	for euid in ${pwrange} ; do
664	[ -z "`egetent passwd ${euid}`" ] && break	641	[[ -z $(egetent passwd ${euid}) ]] && break
665	done	642	done
666	fi	643	fi
667	opts="${opts} -u ${euid}"	644	opts="${opts} -u ${euid}"
668	einfo " - Userid: ${euid}"	645	einfo " - Userid: ${euid}"
669		646
670	# handle shell	647	# handle shell
671	local eshell="$1"; shift	648	local eshell=$1; shift
672	if [ ! -z "${eshell}" ] && [ "${eshell}" != "-1" ]	649	if [[ ! -z ${eshell} ]] && [[ ${eshell} != "-1" ]] ; then
673	then	650	if [[ ! -e ${ROOT}${eshell} ]] ; then
674	if [ ! -e "${eshell}" ]
675	then
676	eerror "A shell was specified but it does not exist !"	651	eerror "A shell was specified but it does not exist !"
677	die "${eshell} does not exist"	652	die "${eshell} does not exist in ${ROOT}"
		653	fi
		654	if [[ ${eshell} == /false \|\| ${eshell} == /nologin ]] ; then
		655	eerror "Do not specify ${eshell} yourself, use -1"
		656	die "Pass '-1' as the shell parameter"
678	fi	657	fi
679	else	658	else
680	if [ "${USERLAND}" == "BSD" ]	659	for shell in /sbin/nologin /usr/sbin/nologin /bin/false /usr/bin/false /dev/null ; do
681	then	660	[[ -x ${ROOT}${shell} ]] && break
682	eshell="/usr/bin/false"	661	done
683	else	662
		663	if [[ ${shell} == "/dev/null" ]] ; then
		664	eerror "Unable to identify the shell to use, proceeding with userland default."
		665	case ${USERLAND} in
684	eshell="/bin/false"	666	GNU) shell="/bin/false" ;;
		667	BSD) shell="/sbin/nologin" ;;
		668	Darwin) shell="/usr/sbin/nologin" ;;
		669	*) die "Unable to identify the default shell for userland ${USERLAND}"
		670	esac
685	fi	671	fi
		672
		673	eshell=${shell}
686	fi	674	fi
687	einfo " - Shell: ${eshell}"	675	einfo " - Shell: ${eshell}"
688	opts="${opts} -s ${eshell}"	676	opts="${opts} -s ${eshell}"
689		677
690	# handle homedir	678	# handle homedir
691	local ehome="$1"; shift	679	local ehome=$1; shift
692	if [ -z "${ehome}" ] && [ "${eshell}" != "-1" ]	680	if [[ -z ${ehome} ]] \|\| [[ ${ehome} == "-1" ]] ; then
693	then
694	ehome="/dev/null"	681	ehome="/dev/null"
695	fi	682	fi
696	einfo " - Home: ${ehome}"	683	einfo " - Home: ${ehome}"
697	opts="${opts} -d ${ehome}"	684	opts="${opts} -d ${ehome}"
698		685
699	# handle groups	686	# handle groups
700	local egroups="$1"; shift	687	local egroups=$1; shift
701	if [ ! -z "${egroups}" ]	688	if [[ ! -z ${egroups} ]] ; then
702	then
703	local oldifs="${IFS}"	689	local oldifs=${IFS}
704	local defgroup="" exgroups=""	690	local defgroup="" exgroups=""
705		691
706	export IFS=","	692	export IFS=","
707	for g in ${egroups}	693	for g in ${egroups} ; do
708	do
709	export IFS="${oldifs}"	694	export IFS=${oldifs}
710	if [ -z "`egetent group \"${g}\"`" ]	695	if [[ -z $(egetent group "${g}") ]] ; then
711	then
712	eerror "You must add group ${g} to the system first"	696	eerror "You must add group ${g} to the system first"
713	die "${g} is not a valid GID"	697	die "${g} is not a valid GID"
714	fi	698	fi
715	if [ -z "${defgroup}" ]	699	if [[ -z ${defgroup} ]] ; then
716	then
717	defgroup="${g}"	700	defgroup=${g}
718	else	701	else
719	exgroups="${exgroups},${g}"	702	exgroups="${exgroups},${g}"
720	fi	703	fi
721	export IFS=","	704	export IFS=","
722	done	705	done
723	export IFS="${oldifs}"	706	export IFS=${oldifs}
724		707
725	opts="${opts} -g ${defgroup}"	708	opts="${opts} -g ${defgroup}"
726	if [ ! -z "${exgroups}" ]	709	if [[ ! -z ${exgroups} ]] ; then
727	then
728	opts="${opts} -G ${exgroups:1}"	710	opts="${opts} -G ${exgroups:1}"
729	fi	711	fi
730	else	712	else
731	egroups="(none)"	713	egroups="(none)"
732	fi	714	fi
733	einfo " - Groups: ${egroups}"	715	einfo " - Groups: ${egroups}"
734		716
735	# handle extra and add the user	717	# handle extra and add the user
736	local eextra="$@"
737	local oldsandbox="${SANDBOX_ON}"	718	local oldsandbox=${SANDBOX_ON}
738	export SANDBOX_ON="0"	719	export SANDBOX_ON="0"
739	if useq ppc-macos	720	case ${CHOST} in
740	then	721	-darwin)
741	### Make the user	722	### Make the user
742	if [ -z "${eextra}" ]	723	if [[ -z $@ ]] ; then
743	then
744	dscl . create /users/${euser} uid ${euid}	724	dscl . create /users/${euser} uid ${euid}
745	dscl . create /users/${euser} shell ${eshell}	725	dscl . create /users/${euser} shell ${eshell}
746	dscl . create /users/${euser} home ${ehome}	726	dscl . create /users/${euser} home ${ehome}
747	dscl . create /users/${euser} realname "added by portage for ${PN}"	727	dscl . create /users/${euser} realname "added by portage for ${PN}"
748	### Add the user to the groups specified	728	### Add the user to the groups specified
749	local oldifs="${IFS}"	729	local oldifs=${IFS}
750	export IFS=","	730	export IFS=","
751	for g in ${egroups}	731	for g in ${egroups} ; do
752	do
753	dscl . merge /groups/${g} users ${euser}	732	dscl . merge /groups/${g} users ${euser}
754	done	733	done
755	export IFS="${oldifs}"	734	export IFS=${oldifs}
756	else	735	else
757	einfo "Extra options are not supported on macos yet"	736	einfo "Extra options are not supported on Darwin yet"
758	einfo "Please report the ebuild along with the info below"	737	einfo "Please report the ebuild along with the info below"
759	einfo "eextra: ${eextra}"	738	einfo "eextra: $@"
760	die "Required function missing"	739	die "Required function missing"
761	fi	740	fi
762	elif use x86-fbsd ; then	741	;;
763	if [ -z "${eextra}" ]	742	-freebsd\|-dragonfly)
764	then	743	if [[ -z $@ ]] ; then
765	pw useradd ${euser} ${opts} \	744	pw useradd ${euser} ${opts} \
766	-c "added by portage for ${PN}" \	745	-c "added by portage for ${PN}" \
767	die "enewuser failed"	746	die "enewuser failed"
768	else	747	else
769	einfo " - Extra: ${eextra}"	748	einfo " - Extra: $@"
770	pw useradd ${euser} ${opts} \	749	pw useradd ${euser} ${opts} \
771	-c ${eextra} \|\| die "enewuser failed"	750	"$@" \|\| die "enewuser failed"
772	fi	751	fi
		752	;;
		753
		754	-netbsd)
		755	if [[ -z $@ ]] ; then
		756	useradd ${opts} ${euser} \|\| die "enewuser failed"
773	else	757	else
774	if [ -z "${eextra}" ]	758	einfo " - Extra: $@"
775	then	759	useradd ${opts} ${euser} "$@" \|\| die "enewuser failed"
		760	fi
		761	;;
		762
		763	-openbsd)
		764	if [[ -z $@ ]] ; then
		765	useradd -u ${euid} -s ${eshell} \
		766	-d ${ehome} -c "Added by portage for ${PN}" \
		767	-g ${egroups} ${euser} \|\| die "enewuser failed"
		768	else
		769	einfo " - Extra: $@"
		770	useradd -u ${euid} -s ${eshell} \
		771	-d ${ehome} -c "Added by portage for ${PN}" \
		772	-g ${egroups} ${euser} "$@" \|\| die "enewuser failed"
		773	fi
		774	;;
		775
		776	*)
		777	if [[ -z $@ ]] ; then
776	useradd ${opts} ${euser} \	778	useradd -r ${opts} \
777	-c "added by portage for ${PN}" \	779	-c "added by portage for ${PN}" \
		780	${euser} \
778	\|\| die "enewuser failed"	781	\|\| die "enewuser failed"
779	else	782	else
780	einfo " - Extra: ${eextra}"	783	einfo " - Extra: $@"
781	useradd ${opts} ${euser} ${eextra} \	784	useradd -r ${opts} "$@" \
		785	${euser} \
782	\|\| die "enewuser failed"	786	\|\| die "enewuser failed"
783	fi	787	fi
		788	;;
		789	esac
		790
		791	if [[ ! -e ${ROOT}/${ehome} ]] ; then
		792	einfo " - Creating ${ehome} in ${ROOT}"
		793	mkdir -p "${ROOT}/${ehome}"
		794	chown ${euser} "${ROOT}/${ehome}"
		795	chmod 755 "${ROOT}/${ehome}"
784	fi	796	fi
		797
785	export SANDBOX_ON="${oldsandbox}"	798	export SANDBOX_ON=${oldsandbox}
786
787	if [ ! -e "${ehome}" ] && [ ! -e "${D}/${ehome}" ]
788	then
789	einfo " - Creating ${ehome} in ${D}"
790	dodir ${ehome}
791	fowners ${euser} ${ehome}
792	fperms 755 ${ehome}
793	fi
794	}	799	}
795		800
796	# Simplify/standardize adding groups to the system	801	# @FUNCTION: enewgroup
797	# vapier@gentoo.org	802	# @USAGE: <group> [gid]
798	#	803	# @DESCRIPTION:
799	# enewgroup(group, gid)	804	# This function does not require you to understand how to properly add a
800	#	805	# group to the system. Just give it a group name to add and enewgroup will
801	# Default values if you do not specify any:	806	# do the rest. You may specify the gid for the group or allow the group to
802	# groupname: REQUIRED !	807	# allocate the next available one.
803	# gid: next available (see groupadd(8))
804	# extra: none
805	enewgroup() {	808	enewgroup() {
		809	case ${EBUILD_PHASE} in
		810	unpack\|compile\|test\|install)
		811	eerror "'enewgroup()' called from '${EBUILD_PHASE}()' which is not a pkg_* function."
		812	eerror "Package fails at QA and at life. Please file a bug."
		813	die "Bad package! enewgroup is only for use in pkg_* functions!"
		814	esac
		815
806	# get the group	816	# get the group
807	local egroup="$1"; shift	817	local egroup="$1"; shift
808	if [ -z "${egroup}" ]	818	if [ -z "${egroup}" ]
809	then	819	then
810	eerror "No group specified !"	820	eerror "No group specified !"
811	die "Cannot call enewgroup without a group"	821	die "Cannot call enewgroup without a group"
812	fi	822	fi
813		823
814	# see if group already exists	824	# see if group already exists
815	if [ "${egroup}" == "`egetent group \"${egroup}\" \| cut -d: -f1`" ]	825	if [[ -n $(egetent group "${egroup}") ]]; then
816	then
817	return 0	826	return 0
818	fi	827	fi
819	einfo "Adding group '${egroup}' to your system ..."	828	einfo "Adding group '${egroup}' to your system ..."
820		829
821	# options to pass to useradd	830	# options to pass to useradd
…		…
827	then	836	then
828	if [ "${egid}" -gt 0 ]	837	if [ "${egid}" -gt 0 ]
829	then	838	then
830	if [ -z "`egetent group ${egid}`" ]	839	if [ -z "`egetent group ${egid}`" ]
831	then	840	then
832	if useq ppc-macos ; then	841	if [[ "${CHOST}" == -darwin ]]; then
833	opts="${opts} ${egid}"	842	opts="${opts} ${egid}"
834	else	843	else
835	opts="${opts} -g ${egid}"	844	opts="${opts} -g ${egid}"
836	fi	845	fi
837	else	846	else
…		…
851	opts="${opts} ${eextra}"	860	opts="${opts} ${eextra}"
852		861
853	# add the group	862	# add the group
854	local oldsandbox="${SANDBOX_ON}"	863	local oldsandbox="${SANDBOX_ON}"
855	export SANDBOX_ON="0"	864	export SANDBOX_ON="0"
856	if useq ppc-macos ; then	865	case ${CHOST} in
		866	-darwin)
857	if [ ! -z "${eextra}" ];	867	if [ ! -z "${eextra}" ];
858	then	868	then
859	einfo "Extra options are not supported on macos yet"	869	einfo "Extra options are not supported on Darwin/OS X yet"
860	einfo "Please report the ebuild along with the info below"	870	einfo "Please report the ebuild along with the info below"
861	einfo "eextra: ${eextra}"	871	einfo "eextra: ${eextra}"
862	die "Required function missing"	872	die "Required function missing"
863	fi	873	fi
864		874
865	# If we need the next available	875	# If we need the next available
866	case ${egid} in	876	case ${egid} in
867	[!0-9]) # Non numeric	877	[!0-9]) # Non numeric
868	for egid in `jot 898 101`; do	878	for ((egid = 101; egid <= 999; egid++)); do
869	[ -z "`egetent group ${egid}`" ] && break	879	[[ -z $(egetent group ${egid}) ]] && break
870	done	880	done
871	esac	881	esac
872	dscl . create /groups/${egroup} gid ${egid}	882	dscl . create /groups/${egroup} gid ${egid}
873	dscl . create /groups/${egroup} passwd '*'	883	dscl . create /groups/${egroup} passwd '*'
874	elif use x86-fbsd ; then	884	;;
		885
		886	-freebsd\|-dragonfly)
875	case ${egid} in	887	case ${egid} in
876	[!0-9]) # Non numeric	888	[!0-9]) # Non numeric
877	for egid in `jot 898 101`; do	889	for ((egid = 101; egid <= 999; egid++)); do
878	[ -z "`egetent group ${egid}`" ] && break	890	[[ -z $(egetent group ${egid}) ]] && break
879	done	891	done
880	esac	892	esac
881	pw groupadd ${egroup} -g ${egid} \|\| die "enewgroup failed"	893	pw groupadd ${egroup} -g ${egid} \|\| die "enewgroup failed"
882	else	894	;;
		895
		896	-netbsd)
		897	case ${egid} in
		898	[!0-9]) # Non numeric
		899	for ((egid = 101; egid <= 999; egid++)); do
		900	[[ -z $(egetent group ${egid}) ]] && break
		901	done
		902	esac
		903	groupadd -g ${egid} ${egroup} \|\| die "enewgroup failed"
		904	;;
		905
		906	*)
		907	# We specify -r so that we get a GID in the system range from login.defs
883	groupadd ${opts} ${egroup} \|\| die "enewgroup failed"	908	groupadd -r ${opts} ${egroup} \|\| die "enewgroup failed"
884	fi	909	;;
		910	esac
885	export SANDBOX_ON="${oldsandbox}"	911	export SANDBOX_ON="${oldsandbox}"
886	}	912	}
887		913
888	# Simple script to replace 'dos2unix' binaries	914	# @FUNCTION: edos2unix
889	# vapier@gentoo.org	915	# @USAGE: <file> [more files ...]
890	#	916	# @DESCRIPTION:
891	# edos2unix(file, <more files> ...)	917	# A handy replacement for dos2unix, recode, fixdos, etc... This allows you
		918	# to remove all of these text utilities from DEPEND variables because this
		919	# is a script based solution. Just give it a list of files to convert and
		920	# they will all be changed from the DOS CRLF format to the UNIX LF format.
892	edos2unix() {	921	edos2unix() {
893	for f in "$@"	922	echo "$@" \| xargs sed -i 's/\r$//'
894	do
895	cp "${f}" ${T}/edos2unix
896	sed 's/\r$//' ${T}/edos2unix > "${f}"
897	done
898	}	923	}
899		924
900	# Make a desktop file !	925	# Make a desktop file !
901	# Great for making those icons in kde/gnome startmenu !	926	# Great for making those icons in kde/gnome startmenu !
902	# Amaze your friends ! Get the women ! Join today !	927	# Amaze your friends ! Get the women ! Join today !
903	#	928	#
904	# make_desktop_entry(<binary>, [name], [icon], [type], [path])	929	# make_desktop_entry(<command>, [name], [icon], [type], [fields])
905	#	930	#
906	# binary: what binary does the app run with ?	931	# binary: what command does the app run with ?
907	# name: the name that will show up in the menu	932	# name: the name that will show up in the menu
908	# icon: give your little like a pretty little icon ...	933	# icon: give your little like a pretty little icon ...
909	# this can be relative (to /usr/share/pixmaps) or	934	# this can be relative (to /usr/share/pixmaps) or
910	# a full path to an icon	935	# a full path to an icon
911	# type: what kind of application is this ? for categories:	936	# type: what kind of application is this ? for categories:
912	# http://www.freedesktop.org/standards/menu-spec/	937	# http://standards.freedesktop.org/menu-spec/latest/apa.html
913	# path: if your app needs to startup in a specific dir	938	# fields: extra fields to append to the desktop file; a printf string
914	make_desktop_entry() {	939	make_desktop_entry() {
915	[ -z "$1" ] && eerror "make_desktop_entry: You must specify the executable" && return 1	940	[[ -z $1 ]] && die "make_desktop_entry: You must specify the executable"
916		941
917	local exec="${1}"	942	local exec=${1}
918	local name="${2:-${PN}}"	943	local name=${2:-${PN}}
919	local icon="${3:-${PN}.png}"	944	local icon=${3:-${PN}}
920	local type="${4}"	945	local type=${4}
921	local subdir="${6}"	946	local fields=${5}
922	local path="${5:-${GAMES_BINDIR}}"	947
923	if [ -z "${type}" ]	948	if [[ -z ${type} ]] ; then
924	then	949	local catmaj=${CATEGORY%%-*}
925	case ${CATEGORY} in	950	local catmin=${CATEGORY##*-}
926	"app-emulation")	951	case ${catmaj} in
927	type=Emulator	952	app)
928	subdir="Emulation"	953	case ${catmin} in
		954	accessibility) type=Accessibility;;
		955	admin) type=System;;
		956	antivirus) type=System;;
		957	arch) type=Archiving;;
		958	backup) type=Archiving;;
		959	cdr) type=DiscBurning;;
		960	dicts) type=Dictionary;;
		961	doc) type=Documentation;;
		962	editors) type=TextEditor;;
		963	emacs) type=TextEditor;;
		964	emulation) type=Emulator;;
		965	laptop) type=HardwareSettings;;
		966	office) type=Office;;
		967	pda) type=PDA;;
		968	vim) type=TextEditor;;
		969	xemacs) type=TextEditor;;
		970	esac
929	;;	971	;;
930	"games-"*)	972
931	type=Game	973	dev)
932	subdir="Games"	974	type="Development"
933	;;	975	;;
934	"net-"*)	976
935	type=Network	977	games)
936	subdir="${type}"	978	case ${catmin} in
		979	action\|fps) type=ActionGame;;
		980	arcade) type=ArcadeGame;;
		981	board) type=BoardGame;;
		982	emulation) type=Emulator;;
		983	kids) type=KidsGame;;
		984	puzzle) type=LogicGame;;
		985	roguelike) type=RolePlaying;;
		986	rpg) type=RolePlaying;;
		987	simulation) type=Simulation;;
		988	sports) type=SportsGame;;
		989	strategy) type=StrategyGame;;
		990	esac
		991	type="Game;${type}"
937	;;	992	;;
		993
		994	gnome)
		995	type="Gnome;GTK"
		996	;;
		997
		998	kde)
		999	type="KDE;Qt"
		1000	;;
		1001
		1002	mail)
		1003	type="Network;Email"
		1004	;;
		1005
		1006	media)
		1007	case ${catmin} in
		1008	gfx)
		1009	type=Graphics
		1010	;;
		1011	*)
		1012	case ${catmin} in
		1013	radio) type=Tuner;;
		1014	sound) type=Audio;;
		1015	tv) type=TV;;
		1016	video) type=Video;;
		1017	esac
		1018	type="AudioVideo;${type}"
		1019	;;
		1020	esac
		1021	;;
		1022
		1023	net)
		1024	case ${catmin} in
		1025	dialup) type=Dialup;;
		1026	ftp) type=FileTransfer;;
		1027	im) type=InstantMessaging;;
		1028	irc) type=IRCClient;;
		1029	mail) type=Email;;
		1030	news) type=News;;
		1031	nntp) type=News;;
		1032	p2p) type=FileTransfer;;
		1033	voip) type=Telephony;;
		1034	esac
		1035	type="Network;${type}"
		1036	;;
		1037
		1038	sci)
		1039	case ${catmin} in
		1040	astro*) type=Astronomy;;
		1041	bio*) type=Biology;;
		1042	calc*) type=Calculator;;
		1043	chem*) type=Chemistry;;
		1044	elec*) type=Electronics;;
		1045	geo*) type=Geology;;
		1046	math*) type=Math;;
		1047	physics) type=Physics;;
		1048	visual*) type=DataVisualization;;
		1049	esac
		1050	type="Education;Science;${type}"
		1051	;;
		1052
		1053	sys)
		1054	type="System"
		1055	;;
		1056
		1057	www)
		1058	case ${catmin} in
		1059	client) type=WebBrowser;;
		1060	esac
		1061	type="Network;${type}"
		1062	;;
		1063
938	*)	1064	*)
939	type=	1065	type=
940	subdir=
941	;;	1066	;;
942	esac	1067	esac
943	fi	1068	fi
944	local desktop="${T}/${exec}.desktop"	1069	if [ "${SLOT}" == "0" ] ; then
		1070	local desktop_name="${PN}"
		1071	else
		1072	local desktop_name="${PN}-${SLOT}"
		1073	fi
		1074	local desktop="${T}/$(echo ${exec} \| sed 's:[[:space:]/:]:_:g')-${desktop_name}.desktop"
		1075	#local desktop=${T}/${exec%% *:-${desktop_name}}.desktop
945		1076
		1077	# Don't append another ";" when a valid category value is provided.
		1078	type=${type%;}${type:+;}
		1079
		1080	eshopts_push -s extglob
		1081	if [[ -n ${icon} && ${icon} != /* ]] && [[ ${icon} == .xpm \|\| ${icon} == .png \|\| ${icon} == *.svg ]]; then
		1082	ewarn "As described in the Icon Theme Specification, icon file extensions are not"
		1083	ewarn "allowed in .desktop files if the value is not an absolute path."
		1084	icon=${icon%.@(xpm\|png\|svg)}
		1085	fi
		1086	eshopts_pop
		1087
		1088	cat <<-EOF > "${desktop}"
946	echo "[Desktop Entry]	1089	[Desktop Entry]
947	Encoding=UTF-8
948	Version=0.9.2
949	Name=${name}	1090	Name=${name}
950	Type=Application	1091	Type=Application
951	Comment=${DESCRIPTION}	1092	Comment=${DESCRIPTION}
952	Exec=${exec}	1093	Exec=${exec}
953	Path=${path}	1094	TryExec=${exec%% *}
954	Icon=${icon}	1095	Icon=${icon}
955	Categories=Application;${type};" > "${desktop}"	1096	Categories=${type}
		1097	EOF
956		1098
		1099	if [[ ${fields:-=} != = ]] ; then
		1100	# 5th arg used to be value to Path=
		1101	ewarn "make_desktop_entry: update your 5th arg to read Path=${fields}"
		1102	fields="Path=${fields}"
		1103	fi
		1104	[[ -n ${fields} ]] && printf '%b\n' "${fields}" >> "${desktop}"
		1105
		1106	(
		1107	# wrap the env here so that the 'insinto' call
		1108	# doesn't corrupt the env of the caller
		1109	insinto /usr/share/applications
		1110	doins "${desktop}"
		1111	) \|\| die "installing desktop file failed"
		1112	}
		1113
		1114	# @FUNCTION: validate_desktop_entries
		1115	# @USAGE: [directories]
		1116	# @MAINTAINER:
		1117	# Carsten Lohrke <carlo@gentoo.org>
		1118	# @DESCRIPTION:
		1119	# Validate desktop entries using desktop-file-utils
		1120	validate_desktop_entries() {
		1121	if [[ -x /usr/bin/desktop-file-validate ]] ; then
		1122	einfo "Checking desktop entry validity"
		1123	local directories=""
		1124	for d in /usr/share/applications $@ ; do
		1125	[[ -d ${D}${d} ]] && directories="${directories} ${D}${d}"
		1126	done
		1127	if [[ -n ${directories} ]] ; then
		1128	for FILE in $(find ${directories} -name "*\.desktop" \
		1129	-not -path '.hidden' \| sort -u 2>/dev/null)
		1130	do
		1131	local temp=$(desktop-file-validate ${FILE} \| grep -v "warning:" \| \
		1132	sed -e "s\|error: \|\|" -e "s\|${FILE}:\|--\|g" )
		1133	[[ -n $temp ]] && elog ${temp/--/${FILE/${D}/}:}
		1134	done
		1135	fi
		1136	echo ""
		1137	else
		1138	einfo "Passing desktop entry validity check. Install dev-util/desktop-file-utils, if you want to help to improve Gentoo."
		1139	fi
		1140	}
		1141
		1142	# @FUNCTION: make_session_desktop
		1143	# @USAGE: <title> <command> [command args...]
		1144	# @DESCRIPTION:
		1145	# Make a GDM/KDM Session file. The title is the file to execute to start the
		1146	# Window Manager. The command is the name of the Window Manager.
		1147	#
		1148	# You can set the name of the file via the ${wm} variable.
		1149	make_session_desktop() {
		1150	[[ -z $1 ]] && eerror "$0: You must specify the title" && return 1
		1151	[[ -z $2 ]] && eerror "$0: You must specify the command" && return 1
		1152
		1153	local title=$1
		1154	local command=$2
		1155	local desktop=${T}/${wm:-${PN}}.desktop
		1156	shift 2
		1157
		1158	cat <<-EOF > "${desktop}"
		1159	[Desktop Entry]
		1160	Name=${title}
		1161	Comment=This session logs you into ${title}
		1162	Exec=${command} $*
		1163	TryExec=${command}
		1164	Type=XSession
		1165	EOF
		1166
		1167	(
		1168	# wrap the env here so that the 'insinto' call
		1169	# doesn't corrupt the env of the caller
		1170	insinto /usr/share/xsessions
		1171	doins "${desktop}"
		1172	)
		1173	}
		1174
		1175	# @FUNCTION: domenu
		1176	# @USAGE: <menus>
		1177	# @DESCRIPTION:
		1178	# Install the list of .desktop menu files into the appropriate directory
		1179	# (/usr/share/applications).
		1180	domenu() {
		1181	(
		1182	# wrap the env here so that the 'insinto' call
		1183	# doesn't corrupt the env of the caller
		1184	local i j ret=0
957	insinto /usr/share/applications	1185	insinto /usr/share/applications
958	doins "${desktop}"	1186	for i in "$@" ; do
		1187	if [[ -f ${i} ]] ; then
		1188	doins "${i}"
		1189	((ret+=$?))
		1190	elif [[ -d ${i} ]] ; then
		1191	for j in "${i}"/*.desktop ; do
		1192	doins "${j}"
		1193	((ret+=$?))
		1194	done
		1195	else
		1196	((++ret))
		1197	fi
		1198	done
		1199	exit ${ret}
		1200	)
		1201	}
959		1202
960	return 0	1203	# @FUNCTION: newmenu
		1204	# @USAGE: <menu> <newname>
		1205	# @DESCRIPTION:
		1206	# Like all other new* functions, install the specified menu as newname.
		1207	newmenu() {
		1208	(
		1209	# wrap the env here so that the 'insinto' call
		1210	# doesn't corrupt the env of the caller
		1211	insinto /usr/share/applications
		1212	newins "$@"
		1213	)
		1214	}
		1215
		1216	# @FUNCTION: doicon
		1217	# @USAGE: <list of icons>
		1218	# @DESCRIPTION:
		1219	# Install the list of icons into the icon directory (/usr/share/pixmaps).
		1220	# This is useful in conjunction with creating desktop/menu files.
		1221	doicon() {
		1222	(
		1223	# wrap the env here so that the 'insinto' call
		1224	# doesn't corrupt the env of the caller
		1225	local i j ret
		1226	insinto /usr/share/pixmaps
		1227	for i in "$@" ; do
		1228	if [[ -f ${i} ]] ; then
		1229	doins "${i}"
		1230	((ret+=$?))
		1231	elif [[ -d ${i} ]] ; then
		1232	for j in "${i}"/*.png ; do
		1233	doins "${j}"
		1234	((ret+=$?))
		1235	done
		1236	else
		1237	((++ret))
		1238	fi
		1239	done
		1240	exit ${ret}
		1241	)
		1242	}
		1243
		1244	# @FUNCTION: newicon
		1245	# @USAGE: <icon> <newname>
		1246	# @DESCRIPTION:
		1247	# Like all other new* functions, install the specified icon as newname.
		1248	newicon() {
		1249	(
		1250	# wrap the env here so that the 'insinto' call
		1251	# doesn't corrupt the env of the caller
		1252	insinto /usr/share/pixmaps
		1253	newins "$@"
		1254	)
961	}	1255	}
962		1256
963	# for internal use only (unpack_pdv and unpack_makeself)	1257	# for internal use only (unpack_pdv and unpack_makeself)
964	find_unpackable_file() {	1258	find_unpackable_file() {
965	local src="$1"	1259	local src=$1
966	if [ -z "${src}" ]	1260	if [[ -z ${src} ]] ; then
967	then
968	src="${DISTDIR}/${A}"	1261	src=${DISTDIR}/${A}
969	else	1262	else
970	if [ -e "${DISTDIR}/${src}" ]	1263	if [[ -e ${DISTDIR}/${src} ]] ; then
971	then
972	src="${DISTDIR}/${src}"	1264	src=${DISTDIR}/${src}
973	elif [ -e "${PWD}/${src}" ]	1265	elif [[ -e ${PWD}/${src} ]] ; then
974	then
975	src="${PWD}/${src}"	1266	src=${PWD}/${src}
976	elif [ -e "${src}" ]	1267	elif [[ -e ${src} ]] ; then
977	then
978	src="${src}"	1268	src=${src}
979	fi
980	fi	1269	fi
981	[ ! -e "${src}" ] && die "Could not find requested archive ${src}"	1270	fi
		1271	[[ ! -e ${src} ]] && return 1
982	echo "${src}"	1272	echo "${src}"
983	}	1273	}
984		1274
		1275	# @FUNCTION: unpack_pdv
		1276	# @USAGE: <file to unpack> <size of off_t>
		1277	# @DESCRIPTION:
985	# Unpack those pesky pdv generated files ...	1278	# Unpack those pesky pdv generated files ...
986	# They're self-unpacking programs with the binary package stuffed in	1279	# They're self-unpacking programs with the binary package stuffed in
987	# the middle of the archive. Valve seems to use it a lot ... too bad	1280	# the middle of the archive. Valve seems to use it a lot ... too bad
988	# it seems to like to segfault a lot :(. So lets take it apart ourselves.	1281	# it seems to like to segfault a lot :(. So lets take it apart ourselves.
989	#	1282	#
990	# Usage: unpack_pdv [file to unpack] [size of off_t]
991	# - you have to specify the off_t size ... i have no idea how to extract that	1283	# You have to specify the off_t size ... I have no idea how to extract that
992	# information out of the binary executable myself. basically you pass in	1284	# information out of the binary executable myself. Basically you pass in
993	# the size of the off_t type (in bytes) on the machine that built the pdv	1285	# the size of the off_t type (in bytes) on the machine that built the pdv
		1286	# archive.
		1287	#
994	# archive. one way to determine this is by running the following commands:	1288	# One way to determine this is by running the following commands:
		1289	#
		1290	# @CODE
995	# strings <pdv archive> \| grep lseek	1291	# strings <pdv archive> \| grep lseek
996	# strace -elseek <pdv archive>	1292	# strace -elseek <pdv archive>
		1293	# @CODE
		1294	#
997	# basically look for the first lseek command (we do the strings/grep because	1295	# Basically look for the first lseek command (we do the strings/grep because
998	# sometimes the function call is _llseek or something) and steal the 2nd	1296	# sometimes the function call is _llseek or something) and steal the 2nd
999	# parameter. here is an example:	1297	# parameter. Here is an example:
		1298	#
		1299	# @CODE
1000	# root@vapier 0 pdv_unpack # strings hldsupdatetool.bin \| grep lseek	1300	# vapier@vapier 0 pdv_unpack # strings hldsupdatetool.bin \| grep lseek
1001	# lseek	1301	# lseek
1002	# root@vapier 0 pdv_unpack # strace -elseek ./hldsupdatetool.bin	1302	# vapier@vapier 0 pdv_unpack # strace -elseek ./hldsupdatetool.bin
1003	# lseek(3, -4, SEEK_END) = 2981250	1303	# lseek(3, -4, SEEK_END) = 2981250
		1304	# @CODE
		1305	#
1004	# thus we would pass in the value of '4' as the second parameter.	1306	# Thus we would pass in the value of '4' as the second parameter.
1005	unpack_pdv() {	1307	unpack_pdv() {
1006	local src="`find_unpackable_file $1`"	1308	local src=$(find_unpackable_file "$1")
1007	local sizeoff_t="$2"	1309	local sizeoff_t=$2
1008		1310
		1311	[[ -z ${src} ]] && die "Could not locate source for '$1'"
1009	[ -z "${sizeoff_t}" ] && die "No idea what off_t size was used for this pdv :("	1312	[[ -z ${sizeoff_t} ]] && die "No idea what off_t size was used for this pdv :("
1010		1313
1011	local shrtsrc="`basename ${src}`"	1314	local shrtsrc=$(basename "${src}")
1012	echo ">>> Unpacking ${shrtsrc} to ${PWD}"	1315	echo ">>> Unpacking ${shrtsrc} to ${PWD}"
1013	local metaskip=`tail -c ${sizeoff_t} ${src} \| hexdump -e \"%i\"`	1316	local metaskip=$(tail -c ${sizeoff_t} "${src}" \| hexdump -e \"%i\")
1014	local tailskip=`tail -c $((${sizeoff_t}*2)) ${src} \| head -c ${sizeoff_t} \| hexdump -e \"%i\"`	1317	local tailskip=$(tail -c $((${sizeoff_t}*2)) "${src}" \| head -c ${sizeoff_t} \| hexdump -e \"%i\")
1015		1318
1016	# grab metadata for debug reasons	1319	# grab metadata for debug reasons
1017	local metafile="$(emktemp)"	1320	local metafile=$(emktemp)
1018	tail -c +$((${metaskip}+1)) ${src} > ${metafile}	1321	tail -c +$((${metaskip}+1)) "${src}" > "${metafile}"
1019		1322
1020	# rip out the final file name from the metadata	1323	# rip out the final file name from the metadata
1021	local datafile="`tail -c +$((${metaskip}+1)) ${src} \| strings \| head -n 1`"	1324	local datafile=$(tail -c +$((${metaskip}+1)) "${src}" \| strings \| head -n 1)
1022	datafile="`basename ${datafile}`"	1325	datafile=$(basename "${datafile}")
1023		1326
1024	# now lets uncompress/untar the file if need be	1327	# now lets uncompress/untar the file if need be
1025	local tmpfile="$(emktemp)"	1328	local tmpfile=$(emktemp)
1026	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \| head -c 512 > ${tmpfile}	1329	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \| head -c 512 > ${tmpfile}
1027		1330
1028	local iscompressed="`file -b ${tmpfile}`"	1331	local iscompressed=$(file -b "${tmpfile}")
1029	if [ "${iscompressed:0:8}" == "compress" ] ; then	1332	if [[ ${iscompressed:0:8} == "compress" ]] ; then
1030	iscompressed=1	1333	iscompressed=1
1031	mv ${tmpfile}{,.Z}	1334	mv ${tmpfile}{,.Z}
1032	gunzip ${tmpfile}	1335	gunzip ${tmpfile}
1033	else	1336	else
1034	iscompressed=0	1337	iscompressed=0
1035	fi	1338	fi
1036	local istar="`file -b ${tmpfile}`"	1339	local istar=$(file -b "${tmpfile}")
1037	if [ "${istar:0:9}" == "POSIX tar" ] ; then	1340	if [[ ${istar:0:9} == "POSIX tar" ]] ; then
1038	istar=1	1341	istar=1
1039	else	1342	else
1040	istar=0	1343	istar=0
1041	fi	1344	fi
1042		1345
…		…
1070	true	1373	true
1071	#[ -s "${datafile}" ] \|\| die "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"	1374	#[ -s "${datafile}" ] \|\| die "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"
1072	#assert "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"	1375	#assert "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"
1073	}	1376	}
1074		1377
		1378	# @FUNCTION: unpack_makeself
		1379	# @USAGE: [file to unpack] [offset] [tail\|dd]
		1380	# @DESCRIPTION:
1075	# Unpack those pesky makeself generated files ...	1381	# Unpack those pesky makeself generated files ...
1076	# They're shell scripts with the binary package tagged onto	1382	# They're shell scripts with the binary package tagged onto
1077	# the end of the archive. Loki utilized the format as does	1383	# the end of the archive. Loki utilized the format as does
1078	# many other game companies.	1384	# many other game companies.
1079	#	1385	#
1080	# Usage: unpack_makeself [file to unpack] [offset] [tail\|dd]	1386	# If the file is not specified, then ${A} is used. If the
1081	# - If the file is not specified then unpack will utilize ${A}.
1082	# - If the offset is not specified then we will attempt to extract	1387	# offset is not specified then we will attempt to extract
1083	# the proper offset from the script itself.	1388	# the proper offset from the script itself.
1084	unpack_makeself() {	1389	unpack_makeself() {
		1390	local src_input=${1:-${A}}
1085	local src="$(find_unpackable_file "$1")"	1391	local src=$(find_unpackable_file "${src_input}")
1086	local skip="$2"	1392	local skip=$2
1087	local exe="$3"	1393	local exe=$3
1088		1394
		1395	[[ -z ${src} ]] && die "Could not locate source for '${src_input}'"
		1396
1089	local shrtsrc="$(basename "${src}")"	1397	local shrtsrc=$(basename "${src}")
1090	echo ">>> Unpacking ${shrtsrc} to ${PWD}"	1398	echo ">>> Unpacking ${shrtsrc} to ${PWD}"
1091	if [ -z "${skip}" ]	1399	if [[ -z ${skip} ]] ; then
1092	then
1093	local ver="`grep -a '#.*Makeself' ${src} \| awk '{print $NF}'`"	1400	local ver=$(grep -m1 -a '#.*Makeself' "${src}" \| awk '{print $NF}')
1094	local skip=0	1401	local skip=0
1095	exe=tail	1402	exe=tail
1096	case ${ver} in	1403	case ${ver} in
1097	1.5.*) # tested 1.5.{3,4,5} ... guessing 1.5.x series is same	1404	1.5.*\|1.6.0-nv) # tested 1.5.{3,4,5} ... guessing 1.5.x series is same
1098	skip=$(grep -a ^skip= "${src}" \| cut -d= -f2)	1405	skip=$(grep -a ^skip= "${src}" \| cut -d= -f2)
1099	;;	1406	;;
1100	2.0\|2.0.1)	1407	2.0\|2.0.1)
1101	skip=$(grep -a ^$'\t'tail "${src}" \| awk '{print $2}' \| cut -b2-)	1408	skip=$(grep -a ^$'\t'tail "${src}" \| awk '{print $2}' \| cut -b2-)
1102	;;	1409	;;
1103	2.1.1)	1410	2.1.1)
1104	skip=$(grep -a ^offset= "${src}" \| awk '{print $2}' \| cut -b2-)	1411	skip=$(grep -a ^offset= "${src}" \| awk '{print $2}' \| cut -b2-)
1105	let skip="skip + 1"	1412	(( skip++ ))
1106	;;	1413	;;
1107	2.1.2)	1414	2.1.2)
1108	skip=$(grep -a ^offset= "${src}" \| awk '{print $3}' \| head -n 1)	1415	skip=$(grep -a ^offset= "${src}" \| awk '{print $3}' \| head -n 1)
1109	let skip="skip + 1"	1416	(( skip++ ))
1110	;;	1417	;;
1111	2.1.3)	1418	2.1.3)
1112	skip=`grep -a ^offset= "${src}" \| awk '{print $3}'`	1419	skip=`grep -a ^offset= "${src}" \| awk '{print $3}'`
1113	let skip="skip + 1"	1420	(( skip++ ))
1114	;;	1421	;;
1115	2.1.4)	1422	2.1.4\|2.1.5)
1116	skip=$(grep -a offset=.head.wc "${src}" \| awk '{print $3}' \| head -n 1)	1423	skip=$(grep -a offset=.head.wc "${src}" \| awk '{print $3}' \| head -n 1)
1117	skip=$(head -n ${skip} "${src}" \| wc -c)	1424	skip=$(head -n ${skip} "${src}" \| wc -c)
1118	exe="dd"	1425	exe="dd"
1119	;;	1426	;;
1120	*)	1427	*)
…		…
1127	esac	1434	esac
1128	debug-print "Detected Makeself version ${ver} ... using ${skip} as offset"	1435	debug-print "Detected Makeself version ${ver} ... using ${skip} as offset"
1129	fi	1436	fi
1130	case ${exe} in	1437	case ${exe} in
1131	tail) exe="tail -n +${skip} '${src}'";;	1438	tail) exe="tail -n +${skip} '${src}'";;
1132	dd) exe="dd ibs=${skip} skip=1 obs=1024 conv=sync if='${src}'";;	1439	dd) exe="dd ibs=${skip} skip=1 if='${src}'";;
1133	*) die "makeself cant handle exe '${exe}'"	1440	*) die "makeself cant handle exe '${exe}'"
1134	esac	1441	esac
1135		1442
1136	# lets grab the first few bytes of the file to figure out what kind of archive it is	1443	# lets grab the first few bytes of the file to figure out what kind of archive it is
1137	local tmpfile="$(emktemp)"	1444	local filetype tmpfile=$(emktemp)
1138	eval ${exe} 2>/dev/null \| head -c 512 > "${tmpfile}"	1445	eval ${exe} 2>/dev/null \| head -c 512 > "${tmpfile}"
1139	local filetype="$(file -b "${tmpfile}")"	1446	filetype=$(file -b "${tmpfile}") \|\| die
1140	case ${filetype} in	1447	case ${filetype} in
1141	*tar\ archive)	1448	tar\ archive)
1142	eval ${exe} \| tar --no-same-owner -xf -	1449	eval ${exe} \| tar --no-same-owner -xf -
1143	;;	1450	;;
1144	bzip2*)	1451	bzip2*)
1145	eval ${exe} \| bzip2 -dc \| tar --no-same-owner -xf -	1452	eval ${exe} \| bzip2 -dc \| tar --no-same-owner -xf -
1146	;;	1453	;;
…		…
1156	;;	1463	;;
1157	esac	1464	esac
1158	assert "failure unpacking (${filetype}) makeself ${shrtsrc} ('${ver}' +${skip})"	1465	assert "failure unpacking (${filetype}) makeself ${shrtsrc} ('${ver}' +${skip})"
1159	}	1466	}
1160		1467
		1468	# @FUNCTION: check_license
		1469	# @USAGE: [license]
		1470	# @DESCRIPTION:
1161	# Display a license for user to accept.	1471	# Display a license for user to accept. If no license is
1162	#
1163	# Usage: check_license [license]
1164	# - If the file is not specified then ${LICENSE} is used.	1472	# specified, then ${LICENSE} is used.
1165	check_license() {	1473	check_license() {
1166	local lic=$1	1474	local lic=$1
1167	if [ -z "${lic}" ] ; then	1475	if [ -z "${lic}" ] ; then
1168	lic="${PORTDIR}/licenses/${LICENSE}"	1476	lic="${PORTDIR}/licenses/${LICENSE}"
1169	else	1477	else
1170	if [ -e "${PORTDIR}/licenses/${src}" ] ; then	1478	if [ -e "${PORTDIR}/licenses/${lic}" ] ; then
1171	lic="${PORTDIR}/licenses/${src}"	1479	lic="${PORTDIR}/licenses/${lic}"
1172	elif [ -e "${PWD}/${src}" ] ; then	1480	elif [ -e "${PWD}/${lic}" ] ; then
1173	lic="${PWD}/${src}"	1481	lic="${PWD}/${lic}"
1174	elif [ -e "${src}" ] ; then	1482	elif [ -e "${lic}" ] ; then
1175	lic="${src}"	1483	lic="${lic}"
1176	fi
1177	fi	1484	fi
1178	[ ! -f "${lic}" ] && die "Could not find requested license ${src}"	1485	fi
1179	local l="`basename ${lic}`"	1486	local l="`basename ${lic}`"
1180		1487
1181	# here is where we check for the licenses the user already	1488	# here is where we check for the licenses the user already
1182	# accepted ... if we don't find a match, we make the user accept	1489	# accepted ... if we don't find a match, we make the user accept
1183	local shopts=$-
1184	local alic	1490	local alic
1185	set -o noglob #so that bash doesn't expand "*"	1491	eshopts_push -o noglob # so that bash doesn't expand "*"
1186	for alic in ${ACCEPT_LICENSE} ; do	1492	for alic in ${ACCEPT_LICENSE} ; do
1187	if [[ ${alic} == * \|\| ${alic} == ${l} ]]; then	1493	if [[ ${alic} == ${l} ]]; then
1188	set +o noglob; set -${shopts} #reset old shell opts	1494	eshopts_pop
1189	return 0	1495	return 0
1190	fi	1496	fi
1191	done	1497	done
1192	set +o noglob; set -$shopts #reset old shell opts	1498	eshopts_pop
		1499	[ ! -f "${lic}" ] && die "Could not find requested license ${lic}"
1193		1500
1194	local licmsg="$(emktemp)"	1501	local licmsg=$(emktemp)
1195	cat << EOF > ${licmsg}	1502	cat <<-EOF > ${licmsg}
1196	**********************************************************	1503	**********************************************************
1197	The following license outlines the terms of use of this	1504	The following license outlines the terms of use of this
1198	package. You MUST accept this license for installation to	1505	package. You MUST accept this license for installation to
1199	continue. When you are done viewing, hit 'q'. If you	1506	continue. When you are done viewing, hit 'q'. If you
1200	CTRL+C out of this, the install will not run!	1507	CTRL+C out of this, the install will not run!
1201	**********************************************************	1508	**********************************************************
1202		1509
1203	EOF	1510	EOF
1204	cat ${lic} >> ${licmsg}	1511	cat ${lic} >> ${licmsg}
1205	${PAGER:-less} ${licmsg} \|\| die "Could not execute pager (${PAGER}) to accept ${lic}"	1512	${PAGER:-less} ${licmsg} \|\| die "Could not execute pager (${PAGER}) to accept ${lic}"
1206	einfon "Do you accept the terms of this license (${l})? [yes/no] "	1513	einfon "Do you accept the terms of this license (${l})? [yes/no] "
1207	read alic	1514	read alic
1208	case ${alic} in	1515	case ${alic} in
…		…
1215	die "Failed to accept license"	1522	die "Failed to accept license"
1216	;;	1523	;;
1217	esac	1524	esac
1218	}	1525	}
1219		1526
		1527	# @FUNCTION: cdrom_get_cds
		1528	# @USAGE: <file on cd1> [file on cd2] [file on cd3] [...]
		1529	# @DESCRIPTION:
1220	# Aquire cd(s) for those lovely cd-based emerges. Yes, this violates	1530	# Aquire cd(s) for those lovely cd-based emerges. Yes, this violates
1221	# the whole 'non-interactive' policy, but damnit I want CD support !	1531	# the whole 'non-interactive' policy, but damnit I want CD support !
1222	#	1532	#
1223	# with these cdrom functions we handle all the user interaction and	1533	# With these cdrom functions we handle all the user interaction and
1224	# standardize everything. all you have to do is call cdrom_get_cds()	1534	# standardize everything. All you have to do is call cdrom_get_cds()
1225	# and when the function returns, you can assume that the cd has been	1535	# and when the function returns, you can assume that the cd has been
1226	# found at CDROM_ROOT.	1536	# found at CDROM_ROOT.
1227	#	1537	#
		1538	# The function will attempt to locate a cd based upon a file that is on
		1539	# the cd. The more files you give this function, the more cds
		1540	# the cdrom functions will handle.
		1541	#
1228	# normally the cdrom functions will refer to the cds as 'cd #1', 'cd #2',	1542	# Normally the cdrom functions will refer to the cds as 'cd #1', 'cd #2',
1229	# etc... if you want to give the cds better names, then just export	1543	# etc... If you want to give the cds better names, then just export
1230	# the CDROM_NAME_X variables before calling cdrom_get_cds().	1544	# the appropriate CDROM_NAME variable before calling cdrom_get_cds().
		1545	# Use CDROM_NAME for one cd, or CDROM_NAME_# for multiple cds. You can
		1546	# also use the CDROM_NAME_SET bash array.
1231	#	1547	#
1232	# for those multi cd ebuilds, see the cdrom_load_next_cd() below.	1548	# For those multi cd ebuilds, see the cdrom_load_next_cd() function.
1233	#
1234	# Usage: cdrom_get_cds <file on cd1> [file on cd2] [file on cd3] [...]
1235	# - this will attempt to locate a cd based upon a file that is on
1236	# the cd ... the more files you give this function, the more cds
1237	# the cdrom functions will handle
1238	cdrom_get_cds() {	1549	cdrom_get_cds() {
1239	# first we figure out how many cds we're dealing with by	1550	# first we figure out how many cds we're dealing with by
1240	# the # of files they gave us	1551	# the # of files they gave us
1241	local cdcnt=0	1552	local cdcnt=0
1242	local f=	1553	local f=
1243	for f in "$@" ; do	1554	for f in "$@" ; do
1244	cdcnt=$((cdcnt + 1))	1555	((++cdcnt))
1245	export CDROM_CHECK_${cdcnt}="$f"	1556	export CDROM_CHECK_${cdcnt}="$f"
1246	done	1557	done
1247	export CDROM_TOTAL_CDS=${cdcnt}	1558	export CDROM_TOTAL_CDS=${cdcnt}
1248	export CDROM_CURRENT_CD=1	1559	export CDROM_CURRENT_CD=1
1249		1560
1250	# now we see if the user gave use CD_ROOT ...	1561	# now we see if the user gave use CD_ROOT ...
1251	# if they did, let's just believe them that it's correct	1562	# if they did, let's just believe them that it's correct
1252	if [ ! -z "${CD_ROOT}" ] ; then	1563	if [[ -n ${CD_ROOT}${CD_ROOT_1} ]] ; then
1253	export CDROM_ROOT="${CD_ROOT}"
1254	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
1255	return
1256	fi
1257	# do the same for CD_ROOT_X
1258	if [ ! -z "${CD_ROOT_1}" ] ; then
1259	local var=	1564	local var=
1260	cdcnt=0	1565	cdcnt=0
1261	while [ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ] ; do	1566	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
1262	cdcnt=$((cdcnt + 1))	1567	((++cdcnt))
1263	var="CD_ROOT_${cdcnt}"	1568	var="CD_ROOT_${cdcnt}"
		1569	[[ -z ${!var} ]] && var="CD_ROOT"
1264	if [ -z "${!var}" ] ; then	1570	if [[ -z ${!var} ]] ; then
1265	eerror "You must either use just the CD_ROOT"	1571	eerror "You must either use just the CD_ROOT"
1266	eerror "or specify ALL the CD_ROOT_X variables."	1572	eerror "or specify ALL the CD_ROOT_X variables."
1267	eerror "In this case, you will need ${CDROM_TOTAL_CDS} CD_ROOT_X variables."	1573	eerror "In this case, you will need ${CDROM_TOTAL_CDS} CD_ROOT_X variables."
1268	die "could not locate CD_ROOT_${cdcnt}"	1574	die "could not locate CD_ROOT_${cdcnt}"
1269	fi	1575	fi
1270	export CDROM_ROOTS_${cdcnt}="${!var}"
1271	done	1576	done
1272	export CDROM_ROOT=${CDROM_ROOTS_1}	1577	export CDROM_ROOT=${CD_ROOT_1:-${CD_ROOT}}
1273	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"	1578	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
		1579	export CDROM_SET=-1
		1580	for f in ${CDROM_CHECK_1//:/ } ; do
		1581	((++CDROM_SET))
		1582	[[ -e ${CDROM_ROOT}/${f} ]] && break
		1583	done
		1584	export CDROM_MATCH=${f}
1274	return	1585	return
1275	fi	1586	fi
1276		1587
		1588	# User didn't help us out so lets make sure they know they can
		1589	# simplify the whole process ...
1277	if [ ${CDROM_TOTAL_CDS} -eq 1 ] ; then	1590	if [[ ${CDROM_TOTAL_CDS} -eq 1 ]] ; then
1278	einfon "This ebuild will need the "	1591	einfo "This ebuild will need the ${CDROM_NAME:-cdrom for ${PN}}"
1279	if [ -z "${CDROM_NAME}" ] ; then
1280	echo "cdrom for ${PN}."
1281	else
1282	echo "${CDROM_NAME}."
1283	fi
1284	echo	1592	echo
1285	einfo "If you do not have the CD, but have the data files"	1593	einfo "If you do not have the CD, but have the data files"
1286	einfo "mounted somewhere on your filesystem, just export"	1594	einfo "mounted somewhere on your filesystem, just export"
1287	einfo "the variable CD_ROOT so that it points to the"	1595	einfo "the variable CD_ROOT so that it points to the"
1288	einfo "directory containing the files."	1596	einfo "directory containing the files."
1289	echo	1597	echo
		1598	einfo "For example:"
		1599	einfo "export CD_ROOT=/mnt/cdrom"
		1600	echo
1290	else	1601	else
		1602	if [[ -n ${CDROM_NAME_SET} ]] ; then
		1603	# Translate the CDROM_NAME_SET array into CDROM_NAME_#
		1604	cdcnt=0
		1605	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
		1606	((++cdcnt))
		1607	export CDROM_NAME_${cdcnt}="${CDROM_NAME_SET[$((${cdcnt}-1))]}"
		1608	done
		1609	fi
		1610
1291	einfo "This package will need access to ${CDROM_TOTAL_CDS} cds."	1611	einfo "This package will need access to ${CDROM_TOTAL_CDS} cds."
1292	cdcnt=0	1612	cdcnt=0
1293	while [ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ] ; do	1613	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
1294	cdcnt=$((cdcnt + 1))	1614	((++cdcnt))
1295	var="CDROM_NAME_${cdcnt}"	1615	var="CDROM_NAME_${cdcnt}"
1296	[ ! -z "${!var}" ] && einfo " CD ${cdcnt}: ${!var}"	1616	[[ ! -z ${!var} ]] && einfo " CD ${cdcnt}: ${!var}"
1297	done	1617	done
1298	echo	1618	echo
1299	einfo "If you do not have the CDs, but have the data files"	1619	einfo "If you do not have the CDs, but have the data files"
1300	einfo "mounted somewhere on your filesystem, just export"	1620	einfo "mounted somewhere on your filesystem, just export"
1301	einfo "the following variables so they point to the right place:"	1621	einfo "the following variables so they point to the right place:"
1302	einfon ""	1622	einfon ""
1303	cdcnt=0	1623	cdcnt=0
1304	while [ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ] ; do	1624	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
1305	cdcnt=$((cdcnt + 1))	1625	((++cdcnt))
1306	echo -n " CD_ROOT_${cdcnt}"	1626	echo -n " CD_ROOT_${cdcnt}"
1307	done	1627	done
1308	echo	1628	echo
1309	einfo "Or, if you have all the files in the same place, or"	1629	einfo "Or, if you have all the files in the same place, or"
1310	einfo "you only have one cdrom, you can export CD_ROOT"	1630	einfo "you only have one cdrom, you can export CD_ROOT"
1311	einfo "and that place will be used as the same data source"	1631	einfo "and that place will be used as the same data source"
1312	einfo "for all the CDs."	1632	einfo "for all the CDs."
1313	echo	1633	echo
		1634	einfo "For example:"
		1635	einfo "export CD_ROOT_1=/mnt/cdrom"
		1636	echo
1314	fi	1637	fi
		1638
		1639	export CDROM_SET=""
1315	export CDROM_CURRENT_CD=0	1640	export CDROM_CURRENT_CD=0
1316	cdrom_load_next_cd	1641	cdrom_load_next_cd
1317	}	1642	}
1318		1643
1319	# this is only used when you need access to more than one cd.	1644	# @FUNCTION: cdrom_load_next_cd
1320	# when you have finished using the first cd, just call this function.	1645	# @DESCRIPTION:
1321	# when it returns, CDROM_ROOT will be pointing to the second cd.	1646	# Some packages are so big they come on multiple CDs. When you're done reading
1322	# remember, you can only go forward in the cd chain, you can't go back.	1647	# files off a CD and want access to the next one, just call this function.
		1648	# Again, all the messy details of user interaction are taken care of for you.
		1649	# Once this returns, just read the variable CDROM_ROOT for the location of the
		1650	# mounted CD. Note that you can only go forward in the CD list, so make sure
		1651	# you only call this function when you're done using the current CD.
1323	cdrom_load_next_cd() {	1652	cdrom_load_next_cd() {
1324	export CDROM_CURRENT_CD=$((CDROM_CURRENT_CD + 1))
1325	local var=	1653	local var
1326		1654	((++CDROM_CURRENT_CD))
1327	if [ ! -z "${CD_ROOT}" ] ; then
1328	einfo "Using same root as before for CD #${CDROM_CURRENT_CD}"
1329	return
1330	fi
1331		1655
1332	unset CDROM_ROOT	1656	unset CDROM_ROOT
1333	var=CDROM_ROOTS_${CDROM_CURRENT_CD}	1657	var=CD_ROOT_${CDROM_CURRENT_CD}
		1658	[[ -z ${!var} ]] && var="CD_ROOT"
1334	if [ -z "${!var}" ] ; then	1659	if [[ -z ${!var} ]] ; then
1335	var="CDROM_CHECK_${CDROM_CURRENT_CD}"	1660	var="CDROM_CHECK_${CDROM_CURRENT_CD}"
1336	cdrom_locate_file_on_cd ${!var}	1661	_cdrom_locate_file_on_cd ${!var}
1337	else	1662	else
1338	export CDROM_ROOT="${!var}"	1663	export CDROM_ROOT=${!var}
1339	fi	1664	fi
1340		1665
1341	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"	1666	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
1342	}	1667	}
1343		1668
…		…
1346	# all it does is try to locate a give file on a cd ... if the cd isn't	1671	# all it does is try to locate a give file on a cd ... if the cd isn't
1347	# found, then a message asking for the user to insert the cdrom will be	1672	# found, then a message asking for the user to insert the cdrom will be
1348	# displayed and we'll hang out here until:	1673	# displayed and we'll hang out here until:
1349	# (1) the file is found on a mounted cdrom	1674	# (1) the file is found on a mounted cdrom
1350	# (2) the user hits CTRL+C	1675	# (2) the user hits CTRL+C
1351	cdrom_locate_file_on_cd() {	1676	_cdrom_locate_file_on_cd() {
1352	while [ -z "${CDROM_ROOT}" ] ; do
1353	local dir="$(dirname ${@})"
1354	local file="$(basename ${@})"
1355	local mline=""	1677	local mline=""
1356	local showedmsg=0	1678	local showedmsg=0 showjolietmsg=0
1357		1679
1358	for mline in `mount \| egrep -e '(iso\|cdrom)' \| awk '{print $3}'` ; do	1680	while [[ -z ${CDROM_ROOT} ]] ; do
		1681	local i=0
		1682	local -a cdset=(${*//:/ })
		1683	if [[ -n ${CDROM_SET} ]] ; then
		1684	cdset=(${cdset[${CDROM_SET}]})
		1685	fi
		1686
		1687	while [[ -n ${cdset[${i}]} ]] ; do
		1688	local dir=$(dirname ${cdset[${i}]})
		1689	local file=$(basename ${cdset[${i}]})
		1690
		1691	local point= node= fs= foo=
		1692	while read point node fs foo ; do
		1693	[[ " cd9660 iso9660 udf " != " ${fs} " ]] && \
		1694	! [[ ${fs} == "subfs" && ",${opts}," == ",fs=cdfss," ]] \
		1695	&& continue
		1696	point=${point//\040/ }
1359	[ -d "${mline}/${dir}" ] \|\| continue	1697	[[ ! -d ${point}/${dir} ]] && continue
1360	[ ! -z "$(find ${mline}/${dir} -iname ${file} -maxdepth 1)" ] \	1698	[[ -z $(find "${point}/${dir}" -maxdepth 1 -iname "${file}") ]] && continue
1361	&& export CDROM_ROOT=${mline}	1699	export CDROM_ROOT=${point}
		1700	export CDROM_SET=${i}
		1701	export CDROM_MATCH=${cdset[${i}]}
		1702	return
		1703	done <<< "$(get_mounts)"
		1704
		1705	((++i))
1362	done	1706	done
1363		1707
1364	if [ -z "${CDROM_ROOT}" ] ; then
1365	echo	1708	echo
1366	if [ ${showedmsg} -eq 0 ] ; then	1709	if [[ ${showedmsg} -eq 0 ]] ; then
1367	if [ ${CDROM_TOTAL_CDS} -eq 1 ] ; then	1710	if [[ ${CDROM_TOTAL_CDS} -eq 1 ]] ; then
1368	if [ -z "${CDROM_NAME}" ] ; then	1711	if [[ -z ${CDROM_NAME} ]] ; then
1369	einfo "Please insert the cdrom for ${PN} now !"	1712	einfo "Please insert+mount the cdrom for ${PN} now !"
1370	else
1371	einfo "Please insert the ${CDROM_NAME} cdrom now !"
1372	fi
1373	else	1713	else
1374	if [ -z "${CDROM_NAME_1}" ] ; then
1375	einfo "Please insert cd #${CDROM_CURRENT_CD} for ${PN} now !"
1376	else
1377	local var="CDROM_NAME_${CDROM_CURRENT_CD}"
1378	einfo "Please insert+mount the ${!var} cdrom now !"	1714	einfo "Please insert+mount the ${CDROM_NAME} cdrom now !"
1379	fi
1380	fi	1715	fi
1381	showedmsg=1	1716	else
		1717	if [[ -z ${CDROM_NAME_1} ]] ; then
		1718	einfo "Please insert+mount cd #${CDROM_CURRENT_CD} for ${PN} now !"
		1719	else
		1720	local var="CDROM_NAME_${CDROM_CURRENT_CD}"
		1721	einfo "Please insert+mount the ${!var} cdrom now !"
		1722	fi
1382	fi	1723	fi
		1724	showedmsg=1
		1725	fi
1383	einfo "Press return to scan for the cd again"	1726	einfo "Press return to scan for the cd again"
1384	einfo "or hit CTRL+C to abort the emerge."	1727	einfo "or hit CTRL+C to abort the emerge."
1385	read	1728	echo
		1729	if [[ ${showjolietmsg} -eq 0 ]] ; then
		1730	showjolietmsg=1
		1731	else
		1732	ewarn "If you are having trouble with the detection"
		1733	ewarn "of your CD, it is possible that you do not have"
		1734	ewarn "Joliet support enabled in your kernel. Please"
		1735	ewarn "check that CONFIG_JOLIET is enabled in your kernel."
		1736	ebeep 5
1386	fi	1737	fi
		1738	read \|\| die "something is screwed with your system"
1387	done	1739	done
1388	}	1740	}
1389		1741
		1742	# @FUNCTION: strip-linguas
		1743	# @USAGE: [<allow LINGUAS>\|<-i\|-u> <directories of .po files>]
		1744	# @DESCRIPTION:
1390	# Make sure that LINGUAS only contains languages that	1745	# Make sure that LINGUAS only contains languages that
1391	# a package can support	1746	# a package can support. The first form allows you to
1392	#	1747	# specify a list of LINGUAS. The -i builds a list of po
1393	# usage: strip-linguas <allow LINGUAS>	1748	# files found in all the directories and uses the
1394	# strip-linguas -i <directories of .po files>	1749	# intersection of the lists. The -u builds a list of po
1395	# strip-linguas -u <directories of .po files>	1750	# files found in all the directories and uses the union
1396	#	1751	# of the lists.
1397	# The first form allows you to specify a list of LINGUAS.
1398	# The -i builds a list of po files found in all the
1399	# directories and uses the intersection of the lists.
1400	# The -u builds a list of po files found in all the
1401	# directories and uses the union of the lists.
1402	strip-linguas() {	1752	strip-linguas() {
1403	local ls newls	1753	local ls newls nols
1404	if [ "$1" == "-i" ] \|\| [ "$1" == "-u" ] ; then	1754	if [[ $1 == "-i" ]] \|\| [[ $1 == "-u" ]] ; then
1405	local op="$1"; shift	1755	local op=$1; shift
1406	ls=" $(find "$1" -name '*.po' -printf '%f ') "; shift	1756	ls=$(find "$1" -name '*.po' -exec basename {} .po ';'); shift
1407	local d f	1757	local d f
1408	for d in "$@" ; do	1758	for d in "$@" ; do
1409	if [ "${op}" == "-u" ] ; then	1759	if [[ ${op} == "-u" ]] ; then
1410	newls="${ls}"	1760	newls=${ls}
1411	else	1761	else
1412	newls=""	1762	newls=""
1413	fi	1763	fi
1414	for f in $(find "$d" -name '*.po' -printf '%f ') ; do	1764	for f in $(find "$d" -name '*.po' -exec basename {} .po ';') ; do
1415	if [ "${op}" == "-i" ] ; then	1765	if [[ ${op} == "-i" ]] ; then
1416	[ "${ls/ ${f} /}" != "${ls}" ] && newls="${newls} ${f}"	1766	has ${f} ${ls} && newls="${newls} ${f}"
1417	else	1767	else
1418	[ "${ls/ ${f} /}" == "${ls}" ] && newls="${newls} ${f}"	1768	has ${f} ${ls} \|\| newls="${newls} ${f}"
1419	fi	1769	fi
1420	done	1770	done
1421	ls="${newls}"	1771	ls=${newls}
1422	done	1772	done
1423	ls="${ls//.po}"
1424	else	1773	else
1425	ls="$@"	1774	ls="$@"
1426	fi	1775	fi
1427		1776
1428	ls=" ${ls} "	1777	nols=""
1429	newls=""	1778	newls=""
1430	for f in ${LINGUAS} ; do	1779	for f in ${LINGUAS} ; do
1431	if [ "${ls/ ${f} /}" != "${ls}" ] ; then	1780	if has ${f} ${ls} ; then
1432	newls="${newls} ${f}"	1781	newls="${newls} ${f}"
1433	else	1782	else
1434	ewarn "Sorry, but ${PN} does not support the ${f} LINGUA"	1783	nols="${nols} ${f}"
1435	fi	1784	fi
1436	done	1785	done
1437	if [ -z "${newls}" ] ; then	1786	[[ -n ${nols} ]] \
1438	unset LINGUAS	1787	&& ewarn "Sorry, but ${PN} does not support the LINGUAS:" ${nols}
1439	else
1440	export LINGUAS="${newls}"	1788	export LINGUAS=${newls:1}
1441	fi
1442	}	1789	}
1443		1790
1444	# moved from kernel.eclass since they are generally useful outside of	1791	# @FUNCTION: preserve_old_lib
1445	# kernel.eclass -iggy (20041002)	1792	# @USAGE: <libs to preserve> [more libs]
1446		1793	# @DESCRIPTION:
1447	# the following functions are useful in kernel module ebuilds, etc.
1448	# for an example see ivtv or drbd ebuilds
1449
1450	# set's ARCH to match what the kernel expects
1451	set_arch_to_kernel() {
1452	export EUTILS_ECLASS_PORTAGE_ARCH="${ARCH}"
1453	case ${ARCH} in
1454	x86) export ARCH="i386";;
1455	amd64) export ARCH="x86_64";;
1456	hppa) export ARCH="parisc";;
1457	mips) export ARCH="mips";;
1458	*) export ARCH="${ARCH}";;
1459	esac
1460	}
1461
1462	# set's ARCH back to what portage expects
1463	set_arch_to_portage() {
1464	export ARCH="${EUTILS_ECLASS_PORTAGE_ARCH}"
1465	}
1466
1467	# Jeremy Huddleston <eradicator@gentoo.org>:
1468	# preserve_old_lib /path/to/libblah.so.0
1469	# preserve_old_lib_notify /path/to/libblah.so.0
1470	#
1471	# These functions are useful when a lib in your package changes --soname. Such	1794	# These functions are useful when a lib in your package changes ABI SONAME.
1472	# an example might be from libogg.so.0 to libogg.so.1. Removing libogg.so.0	1795	# An example might be from libogg.so.0 to libogg.so.1. Removing libogg.so.0
1473	# would break packages that link against it. Most people get around this	1796	# would break packages that link against it. Most people get around this
1474	# by using the portage SLOT mechanism, but that is not always a relevant	1797	# by using the portage SLOT mechanism, but that is not always a relevant
1475	# solution, so instead you can add the following to your ebuilds:	1798	# solution, so instead you can call this from pkg_preinst. See also the
1476	#	1799	# preserve_old_lib_notify function.
1477	# src_install() {
1478	# ...
1479	# preserve_old_lib /usr/$(get_libdir)/libogg.so.0
1480	# ...
1481	# }
1482	#
1483	# pkg_postinst() {
1484	# ...
1485	# preserve_old_lib_notify /usr/$(get_libdir)/libogg.so.0
1486	# ...
1487	# }
1488
1489	preserve_old_lib() {	1800	preserve_old_lib() {
1490	LIB=$1	1801	if [[ ${EBUILD_PHASE} != "preinst" ]] ; then
		1802	eerror "preserve_old_lib() must be called from pkg_preinst() only"
		1803	die "Invalid preserve_old_lib() usage"
		1804	fi
		1805	[[ -z $1 ]] && die "Usage: preserve_old_lib <library to preserve> [more libraries to preserve]"
1491		1806
1492	if [ -n "${LIB}" -a -f "${ROOT}${LIB}" ]; then	1807	# let portage worry about it
1493	SONAME=`basename ${LIB}`	1808	has preserve-libs ${FEATURES} && return 0
1494	DIRNAME=`dirname ${LIB}`
1495		1809
1496	dodir ${DIRNAME}	1810	local lib dir
1497	cp ${ROOT}${LIB} ${D}${DIRNAME}	1811	for lib in "$@" ; do
		1812	[[ -e ${ROOT}/${lib} ]] \|\| continue
		1813	dir=${lib%/*}
		1814	dodir ${dir} \|\| die "dodir ${dir} failed"
		1815	cp "${ROOT}"/${lib} "${D}"/${lib} \|\| die "cp ${lib} failed"
1498	touch ${D}${LIB}	1816	touch "${D}"/${lib}
1499	fi	1817	done
1500	}	1818	}
1501		1819
		1820	# @FUNCTION: preserve_old_lib_notify
		1821	# @USAGE: <libs to notify> [more libs]
		1822	# @DESCRIPTION:
		1823	# Spit helpful messages about the libraries preserved by preserve_old_lib.
1502	preserve_old_lib_notify() {	1824	preserve_old_lib_notify() {
1503	LIB=$1	1825	if [[ ${EBUILD_PHASE} != "postinst" ]] ; then
		1826	eerror "preserve_old_lib_notify() must be called from pkg_postinst() only"
		1827	die "Invalid preserve_old_lib_notify() usage"
		1828	fi
1504		1829
1505	if [ -n "${LIB}" -a -f "${ROOT}${LIB}" ]; then	1830	# let portage worry about it
1506	SONAME=`basename ${LIB}`	1831	has preserve-libs ${FEATURES} && return 0
1507		1832
		1833	local lib notice=0
		1834	for lib in "$@" ; do
		1835	[[ -e ${ROOT}/${lib} ]] \|\| continue
		1836	if [[ ${notice} -eq 0 ]] ; then
		1837	notice=1
1508	einfo "An old version of an installed library was detected on your system."	1838	ewarn "Old versions of installed libraries were detected on your system."
1509	einfo "In order to avoid breaking packages that link against is, this older version"	1839	ewarn "In order to avoid breaking packages that depend on these old libs,"
1510	einfo "is not being removed. In order to make full use of this newer version,"	1840	ewarn "the libraries are not being removed. You need to run revdep-rebuild"
1511	einfo "you will need to execute the following command:"	1841	ewarn "in order to remove these old dependencies. If you do not have this"
1512	einfo " revdep-rebuild --soname ${SONAME}"	1842	ewarn "helper program, simply emerge the 'gentoolkit' package."
1513	einfo	1843	ewarn
1514	einfo "After doing that, you can safely remove ${LIB}"	1844	fi
1515	einfo "Note: 'emerge gentoolkit' to get revdep-rebuild"	1845	# temp hack for #348634 #357225
1516	fi	1846	[[ ${PN} == "mpfr" ]] && lib=${lib##*/}
		1847	ewarn " # revdep-rebuild --library '${lib}'"
		1848	done
		1849	if [[ ${notice} -eq 1 ]] ; then
		1850	ewarn
		1851	ewarn "Once you've finished running revdep-rebuild, it should be safe to"
		1852	ewarn "delete the old libraries. Here is a copy & paste for the lazy:"
		1853	for lib in "$@" ; do
		1854	ewarn " # rm '${lib}'"
		1855	done
		1856	fi
1517	}	1857	}
1518		1858
1519	# Hack for people to figure out if a package was built with	1859	# @FUNCTION: built_with_use
1520	# certain USE flags	1860	# @USAGE: [--hidden] [--missing <action>] [-a\|-o] <DEPEND ATOM> <List of USE flags>
		1861	# @DESCRIPTION:
1521	#	1862	#
1522	# Usage: built_with_use <DEPEND ATOM> <List of USE flags>	1863	# Deprecated: Use EAPI 2 use deps in DEPEND\|RDEPEND and with has_version calls.
1523	# ex: built_with_use xchat gtk2	1864	#
		1865	# A temporary hack until portage properly supports DEPENDing on USE
		1866	# flags being enabled in packages. This will check to see if the specified
		1867	# DEPEND atom was built with the specified list of USE flags. The
		1868	# --missing option controls the behavior if called on a package that does
		1869	# not actually support the defined USE flags (aka listed in IUSE).
		1870	# The default is to abort (call die). The -a and -o flags control
		1871	# the requirements of the USE flags. They correspond to "and" and "or"
		1872	# logic. So the -a flag means all listed USE flags must be enabled
		1873	# while the -o flag means at least one of the listed IUSE flags must be
		1874	# enabled. The --hidden option is really for internal use only as it
		1875	# means the USE flag we're checking is hidden expanded, so it won't be found
		1876	# in IUSE like normal USE flags.
		1877	#
		1878	# Remember that this function isn't terribly intelligent so order of optional
		1879	# flags matter.
1524	built_with_use() {	1880	built_with_use() {
		1881	local hidden="no"
		1882	if [[ $1 == "--hidden" ]] ; then
		1883	hidden="yes"
		1884	shift
		1885	fi
		1886
		1887	local missing_action="die"
		1888	if [[ $1 == "--missing" ]] ; then
		1889	missing_action=$2
		1890	shift ; shift
		1891	case ${missing_action} in
		1892	true\|false\|die) ;;
		1893	*) die "unknown action '${missing_action}'";;
		1894	esac
		1895	fi
		1896
		1897	local opt=$1
		1898	[[ ${opt:0:1} = "-" ]] && shift \|\| opt="-a"
		1899
1525	local PKG=$(portageq best_version ${ROOT} $1)	1900	local PKG=$(best_version $1)
		1901	[[ -z ${PKG} ]] && die "Unable to resolve $1 to an installed package"
		1902	shift
		1903
1526	local USEFILE="${ROOT}/var/db/pkg/${PKG}/USE"	1904	local USEFILE=${ROOT}/var/db/pkg/${PKG}/USE
1527	[[ ! -e ${USEFILE} ]] && return 1	1905	local IUSEFILE=${ROOT}/var/db/pkg/${PKG}/IUSE
		1906
		1907	# if the IUSE file doesn't exist, the read will error out, we need to handle
		1908	# this gracefully
		1909	if [[ ! -e ${USEFILE} ]] \|\| [[ ! -e ${IUSEFILE} && ${hidden} == "no" ]] ; then
		1910	case ${missing_action} in
		1911	true) return 0;;
		1912	false) return 1;;
		1913	die) die "Unable to determine what USE flags $PKG was built with";;
		1914	esac
		1915	fi
		1916
		1917	if [[ ${hidden} == "no" ]] ; then
		1918	local IUSE_BUILT=( $(<"${IUSEFILE}") )
		1919	# Don't check USE_EXPAND #147237
		1920	local expand
		1921	for expand in $(echo ${USE_EXPAND} \| tr '[:upper:]' '[:lower:]') ; do
		1922	if [[ $1 == ${expand}_* ]] ; then
		1923	expand=""
		1924	break
		1925	fi
		1926	done
		1927	if [[ -n ${expand} ]] ; then
		1928	if ! has $1 ${IUSE_BUILT[@]#[-+]} ; then
		1929	case ${missing_action} in
		1930	true) return 0;;
		1931	false) return 1;;
		1932	die) die "$PKG does not actually support the $1 USE flag!";;
		1933	esac
		1934	fi
		1935	fi
		1936	fi
1528		1937
1529	local USE_BUILT=$(<${USEFILE})	1938	local USE_BUILT=$(<${USEFILE})
1530
1531	shift
1532	while [ $# -gt 0 ] ; do	1939	while [[ $# -gt 0 ]] ; do
		1940	if [[ ${opt} = "-o" ]] ; then
		1941	has $1 ${USE_BUILT} && return 0
		1942	else
1533	has $1 ${USE_BUILT} \|\| return 1	1943	has $1 ${USE_BUILT} \|\| return 1
		1944	fi
1534	shift	1945	shift
1535	done	1946	done
1536	return 0	1947	[[ ${opt} = "-a" ]]
1537	}	1948	}
		1949
		1950	# @FUNCTION: epunt_cxx
		1951	# @USAGE: [dir to scan]
		1952	# @DESCRIPTION:
		1953	# Many configure scripts wrongly bail when a C++ compiler could not be
		1954	# detected. If dir is not specified, then it defaults to ${S}.
		1955	#
		1956	# http://bugs.gentoo.org/73450
		1957	epunt_cxx() {
		1958	local dir=$1
		1959	[[ -z ${dir} ]] && dir=${S}
		1960	ebegin "Removing useless C++ checks"
		1961	local f
		1962	find "${dir}" -name configure \| while read f ; do
		1963	patch --no-backup-if-mismatch -p0 "${f}" "${PORTDIR}/eclass/ELT-patches/nocxx/nocxx.patch" > /dev/null
		1964	done
		1965	eend 0
		1966	}
		1967
		1968	# @FUNCTION: make_wrapper
		1969	# @USAGE: <wrapper> <target> [chdir] [libpaths] [installpath]
		1970	# @DESCRIPTION:
		1971	# Create a shell wrapper script named wrapper in installpath
		1972	# (defaults to the bindir) to execute target (default of wrapper) by
		1973	# first optionally setting LD_LIBRARY_PATH to the colon-delimited
		1974	# libpaths followed by optionally changing directory to chdir.
		1975	make_wrapper() {
		1976	local wrapper=$1 bin=$2 chdir=$3 libdir=$4 path=$5
		1977	local tmpwrapper=$(emktemp)
		1978	# We don't want to quote ${bin} so that people can pass complex
		1979	# things as $bin ... "./someprog --args"
		1980	cat << EOF > "${tmpwrapper}"
		1981	#!/bin/sh
		1982	cd "${chdir:-.}"
		1983	if [ -n "${libdir}" ] ; then
		1984	if [ "\${LD_LIBRARY_PATH+set}" = "set" ] ; then
		1985	export LD_LIBRARY_PATH="\${LD_LIBRARY_PATH}:${libdir}"
		1986	else
		1987	export LD_LIBRARY_PATH="${libdir}"
		1988	fi
		1989	fi
		1990	exec ${bin} "\$@"
		1991	EOF
		1992	chmod go+rx "${tmpwrapper}"
		1993	if [[ -n ${path} ]] ; then
		1994	(
		1995	exeinto "${path}"
		1996	newexe "${tmpwrapper}" "${wrapper}"
		1997	) \|\| die
		1998	else
		1999	newbin "${tmpwrapper}" "${wrapper}" \|\| die
		2000	fi
		2001	}
		2002
		2003	# @FUNCTION: path_exists
		2004	# @USAGE: [-a\|-o] <paths>
		2005	# @DESCRIPTION:
		2006	# Check if the specified paths exist. Works for all types of paths
		2007	# (files/dirs/etc...). The -a and -o flags control the requirements
		2008	# of the paths. They correspond to "and" and "or" logic. So the -a
		2009	# flag means all the paths must exist while the -o flag means at least
		2010	# one of the paths must exist. The default behavior is "and". If no
		2011	# paths are specified, then the return value is "false".
		2012	path_exists() {
		2013	local opt=$1
		2014	[[ ${opt} == -[ao] ]] && shift \|\| opt="-a"
		2015
		2016	# no paths -> return false
		2017	# same behavior as: [[ -e "" ]]
		2018	[[ $# -eq 0 ]] && return 1
		2019
		2020	local p r=0
		2021	for p in "$@" ; do
		2022	[[ -e ${p} ]]
		2023	: $(( r += $? ))
		2024	done
		2025
		2026	case ${opt} in
		2027	-a) return $(( r != 0 )) ;;
		2028	-o) return $(( r == $# )) ;;
		2029	esac
		2030	}

 Legend:



Removed from v.1.125
 


changed lines


 
Added in v.1.363
 Legend:



Removed from v.1.125
 


changed lines


 
Added in v.1.363
-Removed from v.1.125
+Added in v.1.363

	ViewVC Help
Powered by ViewVC 1.1.13