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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.279
 


changed lines


 
Added in v.1.381
 Legend:



Removed from v.1.279
 


changed lines


 
Added in v.1.381
-Removed from v.1.279
+Added in v.1.381

	ViewVC Help
Powered by ViewVC 1.1.13