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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.71
 


changed lines


 
Added in v.1.374
 Legend:



Removed from v.1.71
 


changed lines


 
Added in v.1.374
-Removed from v.1.71
+Added in v.1.374

	ViewVC Help
Powered by ViewVC 1.1.13