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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

Revision 1.92		Revision 1.375
1	# Copyright 1999-2004 Gentoo Foundation	1	# Copyright 1999-2011 Gentoo Foundation
2	# Distributed under the terms of the GNU General Public License v2	2	# Distributed under the terms of the GNU General Public License v2
3	# $Header: /var/cvsroot/gentoo-x86/eclass/eutils.eclass,v 1.92 2004/08/03 17:24:52 vapier Exp $	3	# $Header: /var/cvsroot/gentoo-x86/eclass/eutils.eclass,v 1.375 2011/12/17 04:55:41 vapier Exp $
4	#
5	# Author: Martin Schlemmer <azarah@gentoo.org>
6	#
7	# This eclass is for general purpose functions that most ebuilds
8	# have to implement themselves.
9	#
10	# NB: If you add anything, please comment it!
11		4
12	ECLASS=eutils	5	# @ECLASS: eutils.eclass
13	INHERITED="$INHERITED $ECLASS"	6	# @MAINTAINER:
		7	# base-system@gentoo.org
		8	# @BLURB: many extra (but common) functions that are used in ebuilds
		9	# @DESCRIPTION:
		10	# The eutils eclass contains a suite of functions that complement
		11	# the ones that ebuild.sh already contain. The idea is that the functions
		12	# are not required in all ebuilds but enough utilize them to have a common
		13	# home rather than having multiple ebuilds implementing the same thing.
		14	#
		15	# Due to the nature of this eclass, some functions may have maintainers
		16	# different from the overall eclass!
14		17
15	DEPEND="!bootstrap? ( sys-devel/patch )"	18	if [[ ${___ECLASS_ONCE_EUTILS} != "recur -_+^+_- spank" ]] ; then
		19	___ECLASS_ONCE_EUTILS="recur -_+^+_- spank"
		20
		21	inherit multilib 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 "${FUNCNAME}: bad options to shopt: $*"
		182	else
		183	__ESHOPTS_SAVE__[$i]=$-
		184	[[ $# -eq 0 ]] && return 0
		185	set "$@" \|\| die "${FUNCNAME}: 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 "${FUNCNAME} 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 "${FUNCNAME}: sanity: invalid shopt options: ${s}"
		202	else
		203	set +$- \|\| die "${FUNCNAME}: sanity: invalid shell settings: $-"
		204	set -${s} \|\| die "${FUNCNAME}: 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
166	else
167	local EPATCH_SOURCE="$1/*.${EPATCH_SUFFIX}"
168	fi
169	else
170	if [ ! -d ${EPATCH_SOURCE} ]
171	then
172	if [ -n "$1" -a "${EPATCH_SOURCE}" = "${WORKDIR}/patch" ]
173	then
174	EPATCH_SOURCE="$1"
175	fi	377	fi
176		378
177	echo	379	# Let people filter things dynamically
178	eerror "Cannot find \$EPATCH_SOURCE! Value for \$EPATCH_SOURCE is:"
179	eerror
180	eerror " ${EPATCH_SOURCE}"
181	echo
182	die "Cannot find \$EPATCH_SOURCE!"
183	fi
184
185	local EPATCH_SOURCE="${EPATCH_SOURCE}/*.${EPATCH_SUFFIX}"
186	fi
187
188	case ${EPATCH_SUFFIX##*\.} in
189	bz2)
190	PIPE_CMD="bzip2 -dc"
191	PATCH_SUFFIX="bz2"
192	;;
193	gz\|Z\|z)
194	PIPE_CMD="gzip -dc"
195	PATCH_SUFFIX="gz"
196	;;
197	ZIP\|zip)
198	PIPE_CMD="unzip -p"
199	PATCH_SUFFIX="zip"
200	;;
201	*)
202	PIPE_CMD="cat"
203	PATCH_SUFFIX="patch"
204	;;
205	esac
206
207	if [ "${SINGLE_PATCH}" = "no" ]
208	then
209	einfo "Applying various patches (bugfixes/updates)..."
210	fi
211	for x in ${EPATCH_SOURCE}
212	do
213	# New ARCH dependant patch naming scheme...
214	#
215	# ???_arch_foo.patch
216	#
217	if [ -f ${x} ] && \
218	([ "${SINGLE_PATCH}" = "yes" -o "${x/_all_}" != "${x}" -o "`eval echo \$\{x/_${ARCH}_\}`" != "${x}" ] \|\| \
219	[ "${EPATCH_FORCE}" = "yes" ])
220	then
221	local count=0
222	local popts="${EPATCH_OPTS}"
223
224	if [ -n "${EPATCH_EXCLUDE}" ]	380	if [[ -n ${EPATCH_EXCLUDE} ]] ; then
225	then	381	# let people use globs in the exclude
226	if [ "`eval echo \$\{EPATCH_EXCLUDE/${x##*/}\}`" != "${EPATCH_EXCLUDE}" ]	382	eshopts_push -o noglob
227	then	383
		384	local ex
		385	for ex in ${EPATCH_EXCLUDE} ; do
		386	if [[ ${patchname} == ${ex} ]] ; then
		387	eshopts_pop
228	continue	388	continue 2
229	fi	389	fi
		390	done
		391
		392	eshopts_pop
230	fi	393	fi
231		394
232	if [ "${SINGLE_PATCH}" = "yes" ]	395	if [[ ${SINGLE_PATCH} == "yes" ]] ; then
233	then
234	if [ -n "${EPATCH_SINGLE_MSG}" ]	396	if [[ -n ${EPATCH_SINGLE_MSG} ]] ; then
235	then
236	einfo "${EPATCH_SINGLE_MSG}"	397	einfo "${EPATCH_SINGLE_MSG}"
237	else
238	einfo "Applying ${x##*/}..."
239	fi
240	else	398	else
241	einfo " ${x##*/}..."	399	einfo "Applying ${patchname} ..."
242	fi
243
244	echo "***** ${x##/} ***" > ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}
245	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
246
247	# Allow for prefix to differ ... im lazy, so shoot me :/
248	while [ "${count}" -lt 5 ]
249	do
250	# Generate some useful debug info ...
251	draw_line "***** ${x##/} ***" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}
252	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
253
254	if [ "${PATCH_SUFFIX}" != "patch" ]
255	then
256	echo -n "PIPE_COMMAND: " >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
257	echo "${PIPE_CMD} ${x} > ${PATCH_TARGET}" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
258	else
259	PATCH_TARGET="${x}"
260	fi
261
262	echo -n "PATCH COMMAND: " >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
263	echo "patch -p${count} ${popts} < ${PATCH_TARGET}" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
264
265	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
266	draw_line "***** ${x##/} ***" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}
267
268	if [ "${PATCH_SUFFIX}" != "patch" ]
269	then
270	if ! (${PIPE_CMD} ${x} > ${PATCH_TARGET}) >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/} 2>&1
271	then
272	echo
273	eerror "Could not extract patch!"
274	#die "Could not extract patch!"
275	count=5
276	break
277	fi
278	fi
279
280	if (cat ${PATCH_TARGET} \| patch -p${count} ${popts} --dry-run -f) >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/} 2>&1
281	then
282	draw_line "***** ${x##/} ***" > ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}.real
283	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}.real
284	echo "ACTUALLY APPLYING ${x##/}..." >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}.real
285	echo >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}.real
286	draw_line "***** ${x##/} ***" >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}.real
287
288	cat ${PATCH_TARGET} \| patch -p${count} ${popts} >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}.real 2>&1
289
290	if [ "$?" -ne 0 ]
291	then
292	cat ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}.real >> ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##/}
293	echo
294	eerror "A dry-run of patch command succeeded, but actually"
295	eerror "applying the patch failed!"
296	#die "Real world sux compared to the dreamworld!"
297	count=5
298	fi
299
300	rm -f ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}.real
301
302	break
303	fi
304
305	count=$((count + 1))
306	done
307
308	if [ "${PATCH_SUFFIX}" != "patch" ]
309	then
310	rm -f ${PATCH_TARGET}
311	fi
312
313	if [ "${count}" -eq 5 ]
314	then
315	echo
316	eerror "Failed Patch: ${x##*/}!"
317	eerror
318	eerror "Include in your bugreport the contents of:"
319	eerror
320	eerror " ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}"
321	echo
322	die "Failed Patch: ${x##*/}!"
323	fi
324
325	rm -f ${STDERR_TARGET%/}/${x##/}-${STDERR_TARGET##*/}
326
327	eend 0
328	fi
329	done
330	if [ "${SINGLE_PATCH}" = "no" ]
331	then
332	einfo "Done with patching"
333	fi
334	}
335
336	# This function return true if we are using the NPTL pthreads
337	# implementation.
338	#
339	# <azarah@gentoo.org> (06 March 2003)
340	#
341
342	have_NPTL() {
343
344	cat > ${T}/test-nptl.c <<-"END"
345	#define _XOPEN_SOURCE
346	#include <unistd.h>
347	#include <stdio.h>
348
349	int main()
350	{
351	char buf[255];
352	char *str = buf;
353
354	confstr(_CS_GNU_LIBPTHREAD_VERSION, str, 255);
355	if (NULL != str) {
356	printf("%s\n", str);
357	if (NULL != strstr(str, "NPTL"))
358	return 0;
359	}
360
361	return 1;
362	}
363	END
364
365	einfon "Checking for _CS_GNU_LIBPTHREAD_VERSION support in glibc ... "
366	if gcc -o ${T}/nptl ${T}/test-nptl.c &> /dev/null
367	then
368	echo "yes"
369	einfon "Checking what PTHREADS implementation we have ... "
370	if ${T}/nptl
371	then
372	return 0
373	else
374	return 1
375	fi
376	else
377	echo "no"
378	fi
379
380	return 1
381	}
382
383	# This function check how many cpu's are present, and then set
384	# -j in MAKEOPTS accordingly.
385	#
386	# Thanks to nall <nall@gentoo.org> for this.
387	#
388	get_number_of_jobs() {
389	local jobs=0
390
391	if [ ! -r /proc/cpuinfo ]
392	then
393	return 1
394	fi
395
396	# This bit is from H?kan Wessberg <nacka-gentoo@refug.org>, bug #13565.
397	if [ "`egrep "^[[:space:]]*MAKEOPTS=" /etc/make.conf \| wc -l`" -gt 0 ]
398	then
399	ADMINOPTS="`egrep "^[[:space:]]*MAKEOPTS=" /etc/make.conf \| cut -d= -f2 \| sed 's/\"//g'`"
400	ADMINPARAM="`echo ${ADMINOPTS} \| gawk '{match($0, /-j [0-9]/, opt); print opt[0]}'`"
401	ADMINPARAM="${ADMINPARAM/-j}"
402	fi
403
404	export MAKEOPTS="`echo ${MAKEOPTS} \| sed -e 's:-j [0-9]::g'`"
405
406	if [ "${ARCH}" = "amd64" -o "${ARCH}" = "x86" -o "${ARCH}" = "hppa" -o \
407	"${ARCH}" = "arm" -o "${ARCH}" = "mips" -o "${ARCH}" = "ia64" ]
408	then
409	# these archs will always have "[Pp]rocessor"
410	jobs="$((`grep -c ^[Pp]rocessor /proc/cpuinfo` * 2))"
411
412	elif [ "${ARCH}" = "sparc" -o "${ARCH}" = "sparc64" ]
413	then
414	# sparc always has "ncpus active"
415	jobs="$((`grep "^ncpus active" /proc/cpuinfo \| sed -e "s/^.: //"` 2))"
416
417	elif [ "${ARCH}" = "alpha" ]
418	then
419	# alpha has "cpus active", but only when compiled with SMP
420	if [ "`grep -c "^cpus active" /proc/cpuinfo`" -eq 1 ]
421	then
422	jobs="$((`grep "^cpus active" /proc/cpuinfo \| sed -e "s/^.: //"` 2))"
423	else
424	jobs=2
425	fi
426
427	elif [ "${ARCH}" = "ppc" -o "${ARCH}" = "ppc64" ]
428	then
429	# ppc has "processor", but only when compiled with SMP
430	if [ "`grep -c "^processor" /proc/cpuinfo`" -eq 1 ]
431	then
432	jobs="$((`grep -c ^processor /proc/cpuinfo` * 2))"
433	else
434	jobs=2
435	fi
436	elif [ "${ARCH}" = "s390" ]
437	then
438	# s390 has "# processors : "
439	jobs="$((`grep "^\# processors" /proc/cpuinfo \| sed -e "s/^.: //"` 2))"
440	else
441	jobs="$((`grep -c ^cpu /proc/cpuinfo` * 2))"
442	die "Unknown ARCH -- ${ARCH}!"
443	fi
444
445	# Make sure the number is valid ...
446	if [ "${jobs}" -lt 1 ]
447	then
448	jobs=1
449	fi
450
451	if [ -n "${ADMINPARAM}" ]
452	then
453	if [ "${jobs}" -gt "${ADMINPARAM}" ]
454	then
455	einfo "Setting make jobs to \"-j${ADMINPARAM}\" to ensure successful merge..."
456	export MAKEOPTS="${MAKEOPTS} -j${ADMINPARAM}"
457	else
458	einfo "Setting make jobs to \"-j${jobs}\" to ensure successful merge..."
459	export MAKEOPTS="${MAKEOPTS} -j${jobs}"
460	fi
461	fi
462	}
463
464	# Cheap replacement for when debianutils (and thus mktemp)
465	# does not exist on the users system
466	# vapier@gentoo.org
467	#
468	# Takes just 1 parameter (the directory to create tmpfile in)
469	mymktemp() {
470	local topdir="$1"
471
472	[ -z "${topdir}" ] && topdir=/tmp
473	if [ "`which mktemp 2>/dev/null`" ]
474	then
475	mktemp -p ${topdir}
476	else
477	local tmp="${topdir}/tmp.${RANDOM}.${RANDOM}.${RANDOM}"
478	touch ${tmp}
479	echo ${tmp}
480	fi
481	}
482
483	# Small wrapper for getent (Linux) and nidump (Mac OS X)
484	# used in enewuser()/enewgroup()
485	# Joe Jezak <josejx@gmail.com> and usata@gentoo.org
486	#
487	# egetent(database, key)
488	egetent() {
489	if [ "${ARCH}" == "macos" ] ; then
490	case "$2" in
491	[!0-9]) # Non numeric
492	nidump $1 . \| awk -F":" "{ if (\$1 ~ /^$2$/) {print \$0;exit;} }"
493	;;
494	*) # Numeric
495	nidump $1 . \| awk -F":" "{ if (\$3 == $2) {print \$0;exit;} }"
496	;;
497	esac
498	else
499	getent $1 $2
500	fi
501	}
502
503	# Simplify/standardize adding users to the system
504	# vapier@gentoo.org
505	#
506	# enewuser(username, uid, shell, homedir, groups, extra options)
507	#
508	# Default values if you do not specify any:
509	# username: REQUIRED !
510	# uid: next available (see useradd(8))
511	# note: pass -1 to get default behavior
512	# shell: /bin/false
513	# homedir: /dev/null
514	# groups: none
515	# extra: comment of 'added by portage for ${PN}'
516	enewuser() {
517	# get the username
518	local euser="$1"; shift
519	if [ -z "${euser}" ]
520	then
521	eerror "No username specified !"
522	die "Cannot call enewuser without a username"
523	fi
524
525	# lets see if the username already exists
526	if [ "${euser}" == "`egetent passwd \"${euser}\" \| cut -d: -f1`" ]
527	then
528	return 0
529	fi
530	einfo "Adding user '${euser}' to your system ..."
531
532	# options to pass to useradd
533	local opts=
534
535	# handle uid
536	local euid="$1"; shift
537	if [ ! -z "${euid}" ] && [ "${euid}" != "-1" ]
538	then
539	if [ "${euid}" -gt 0 ]
540	then
541	if [ ! -z "`egetent passwd ${euid}`" ]
542	then
543	euid="next"
544	fi	400	fi
545	else	401	else
546	eerror "Userid given but is not greater than 0 !"	402	einfo " ${patchname} ..."
547	die "${euid} is not a valid UID"	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
548	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}"
549	else	595	else
550	euid="next"	596	# the args here will give slightly wierd names on BSD,
551	fi	597	# but should produce a usable file on all userlands
552	if [ "${euid}" == "next" ]	598	if [[ ${exe} == "touch" ]] ; then
553	then	599	TMPDIR="${topdir}" mktemp -t tmp.XXXXXXXXXX
554	local pwrange
555	if [ "${ARCH}" == "macos" ] ; then
556	pwrange="`jot 898 101`"
557	else	600	else
558	pwrange="`seq 101 999`"	601	TMPDIR="${topdir}" mktemp -dt tmp.XXXXXXXXXX
		602	fi
559	fi	603	fi
560	for euid in ${pwrange} ; do	604	}
561	[ -z "`egetent passwd ${euid}`" ] && break	605
		606	# @FUNCTION: edos2unix
		607	# @USAGE: <file> [more files ...]
		608	# @DESCRIPTION:
		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.
		613	edos2unix() {
		614	[[ $# -eq 0 ]] && return 0
		615	sed -i 's/\r$//' -- "$@" \|\| die
		616	}
		617
		618	# Make a desktop file !
		619	# Great for making those icons in kde/gnome startmenu !
		620	# Amaze your friends ! Get the women ! Join today !
		621	#
		622	# make_desktop_entry(<command>, [name], [icon], [type], [fields])
		623	#
		624	# binary: what command does the app run with ?
		625	# name: the name that will show up in the menu
		626	# icon: give your little like a pretty little icon ...
		627	# this can be relative (to /usr/share/pixmaps) or
		628	# a full path to an icon
		629	# type: what kind of application is this ? for categories:
		630	# http://standards.freedesktop.org/menu-spec/latest/apa.html
		631	# fields: extra fields to append to the desktop file; a printf string
		632	make_desktop_entry() {
		633	[[ -z $1 ]] && die "make_desktop_entry: You must specify the executable"
		634
		635	local exec=${1}
		636	local name=${2:-${PN}}
		637	local icon=${3:-${PN}}
		638	local type=${4}
		639	local fields=${5}
		640
		641	if [[ -z ${type} ]] ; then
		642	local catmaj=${CATEGORY%%-*}
		643	local catmin=${CATEGORY##*-}
		644	case ${catmaj} in
		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
		703	;;
		704	*)
		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}"
		712	;;
		713	esac
		714	;;
		715
		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
		728	type="Network;${type}"
		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
		757	*)
		758	type=
		759	;;
		760	esac
		761	fi
		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
		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}"
		782	[Desktop Entry]
		783	Name=${name}
		784	Type=Application
		785	Comment=${DESCRIPTION}
		786	Exec=${exec}
		787	TryExec=${exec%% *}
		788	Icon=${icon}
		789	Categories=${type}
		790	EOF
		791
		792	if [[ ${fields:-=} != = ]] ; 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
		802	insinto /usr/share/applications
		803	doins "${desktop}"
		804	) \|\| die "installing desktop file failed"
		805	}
		806
		807	# @FUNCTION: validate_desktop_entries
		808	# @USAGE: [directories]
		809	# @MAINTAINER:
		810	# Carsten Lohrke <carlo@gentoo.org>
		811	# @DESCRIPTION:
		812	# Validate desktop entries using desktop-file-utils
		813	validate_desktop_entries() {
		814	if [[ -x /usr/bin/desktop-file-validate ]] ; then
		815	einfo "Checking desktop entry validity"
		816	local directories=""
		817	for d in /usr/share/applications $@ ; do
		818	[[ -d ${D}${d} ]] && directories="${directories} ${D}${d}"
562	done	819	done
		820	if [[ -n ${directories} ]] ; then
		821	for FILE in $(find ${directories} -name "*\.desktop" \
		822	-not -path '.hidden' \| sort -u 2>/dev/null)
		823	do
		824	local temp=$(desktop-file-validate ${FILE} \| grep -v "warning:" \| \
		825	sed -e "s\|error: \|\|" -e "s\|${FILE}:\|--\|g" )
		826	[[ -n $temp ]] && elog ${temp/--/${FILE/${D}/}:}
		827	done
563	fi	828	fi
564	opts="${opts} -u ${euid}"	829	echo ""
565	einfo " - Userid: ${euid}"
566
567	# handle shell
568	local eshell="$1"; shift
569	if [ ! -z "${eshell}" ] && [ "${eshell}" != "-1" ]
570	then
571	if [ ! -e "${eshell}" ]
572	then
573	eerror "A shell was specified but it does not exist !"
574	die "${eshell} does not exist"
575	fi
576	else	830	else
577	eshell="/bin/false"	831	einfo "Passing desktop entry validity check. Install dev-util/desktop-file-utils, if you want to help to improve Gentoo."
578	fi
579	einfo " - Shell: ${eshell}"
580	opts="${opts} -s ${eshell}"
581
582	# handle homedir
583	local ehome="$1"; shift
584	if [ -z "${ehome}" ] && [ "${eshell}" != "-1" ]
585	then
586	ehome="/dev/null"
587	fi
588	einfo " - Home: ${ehome}"
589	opts="${opts} -d ${ehome}"
590
591	# handle groups
592	local egroups="$1"; shift
593	if [ ! -z "${egroups}" ]
594	then
595	local oldifs="${IFS}"
596	export IFS=","
597	for g in ${egroups}
598	do
599	if [ -z "`egetent group \"${g}\"`" ]
600	then
601	eerror "You must add group ${g} to the system first"
602	die "${g} is not a valid GID"
603	fi	832	fi
604	done	833	}
605	export IFS="${oldifs}"
606	opts="${opts} -g ${egroups}"
607	else
608	egroups="(none)"
609	fi
610	einfo " - Groups: ${egroups}"
611		834
612	# handle extra and add the user	835	# @FUNCTION: make_session_desktop
613	local eextra="$@"	836	# @USAGE: <title> <command> [command args...]
614	local oldsandbox="${SANDBOX_ON}"	837	# @DESCRIPTION:
615	export SANDBOX_ON="0"	838	# Make a GDM/KDM Session file. The title is the file to execute to start the
616	if [ "${ARCH}" == "macos" ];	839	# Window Manager. The command is the name of the Window Manager.
617	then	840	#
618	### Make the user	841	# You can set the name of the file via the ${wm} variable.
619	if [ -z "${eextra}" ]	842	make_session_desktop() {
620	then	843	[[ -z $1 ]] && eerror "$0: You must specify the title" && return 1
621	dscl . create /users/${euser} uid ${euid}	844	[[ -z $2 ]] && eerror "$0: You must specify the command" && return 1
622	dscl . create /users/${euser} shell ${eshell}	845
623	dscl . create /users/${euser} home ${ehome}	846	local title=$1
624	dscl . create /users/${euser} realname "added by portage for ${PN}"	847	local command=$2
625	### Add the user to the groups specified	848	local desktop=${T}/${wm:-${PN}}.desktop
626	for g in ${egroups}	849	shift 2
627	do	850
628	dscl . merge /groups/${g} users ${euser}	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+=$?))
629	done	887	done
630	else	888	else
631	einfo "Extra options are not supported on macos yet"	889	((++ret))
632	einfo "Please report the ebuild along with the info below"
633	einfo "eextra: ${eextra}"
634	die "Required function missing"
635	fi	890	fi
636	else	891	done
637	if [ -z "${eextra}" ]	892	exit ${ret}
638	then	893	)
639	useradd ${opts} ${euser} \	894	}
640	-c "added by portage for ${PN}" \	895
641	\|\| die "enewuser failed"	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	}
		908
		909	# @FUNCTION: doicon
		910	# @USAGE: <list of icons>
		911	# @DESCRIPTION:
		912	# Install the list of icons into the icon directory (/usr/share/pixmaps).
		913	# This is useful in conjunction with creating desktop/menu files.
		914	doicon() {
		915	(
		916	# wrap the env here so that the 'insinto' call
		917	# doesn't corrupt the env of the caller
		918	local i j ret
		919	insinto /usr/share/pixmaps
		920	for i in "$@" ; do
		921	if [[ -f ${i} ]] ; then
		922	doins "${i}"
		923	((ret+=$?))
		924	elif [[ -d ${i} ]] ; then
		925	for j in "${i}"/*.png ; do
		926	doins "${j}"
		927	((ret+=$?))
		928	done
642	else	929	else
643	einfo " - Extra: ${eextra}"	930	((++ret))
644	useradd ${opts} ${euser} ${eextra} \
645	\|\| die "enewuser failed"
646	fi
647	fi
648	export SANDBOX_ON="${oldsandbox}"
649
650	if [ ! -e "${ehome}" ] && [ ! -e "${D}/${ehome}" ]
651	then
652	einfo " - Creating ${ehome} in ${D}"
653	dodir ${ehome}
654	fowners ${euser} ${ehome}
655	fperms 755 ${ehome}
656	fi
657	}
658
659	# Simplify/standardize adding groups to the system
660	# vapier@gentoo.org
661	#
662	# enewgroup(group, gid)
663	#
664	# Default values if you do not specify any:
665	# groupname: REQUIRED !
666	# gid: next available (see groupadd(8))
667	# extra: none
668	enewgroup() {
669	# get the group
670	local egroup="$1"; shift
671	if [ -z "${egroup}" ]
672	then
673	eerror "No group specified !"
674	die "Cannot call enewgroup without a group"
675	fi
676
677	# see if group already exists
678	if [ "${egroup}" == "`egetent group \"${egroup}\" \| cut -d: -f1`" ]
679	then
680	return 0
681	fi
682	einfo "Adding group '${egroup}' to your system ..."
683
684	# options to pass to useradd
685	local opts=
686
687	# handle gid
688	local egid="$1"; shift
689	if [ ! -z "${egid}" ]
690	then
691	if [ "${egid}" -gt 0 ]
692	then
693	if [ -z "`egetent group ${egid}`" ]
694	then
695	if [ "${ARCH}" == "macos" ] ; then
696	opts="${opts} ${egid}"
697	else
698	opts="${opts} -g ${egid}"
699	fi
700	else
701	egid="next available; requested gid taken"
702	fi	931	fi
703	else
704	eerror "Groupid given but is not greater than 0 !"
705	die "${egid} is not a valid GID"
706	fi
707	else
708	egid="next available"
709	fi
710	einfo " - Groupid: ${egid}"
711
712	# handle extra
713	local eextra="$@"
714	opts="${opts} ${eextra}"
715
716	# add the group
717	local oldsandbox="${SANDBOX_ON}"
718	export SANDBOX_ON="0"
719	if [ "${ARCH}" == "macos" ];
720	then
721	if [ ! -z "${eextra}" ];
722	then
723	einfo "Extra options are not supported on macos yet"
724	einfo "Please report the ebuild along with the info below"
725	einfo "eextra: ${eextra}"
726	die "Required function missing"
727	fi
728
729	# If we need the next available
730	case ${egid} in
731	[!0-9]) # Non numeric
732	for egid in `jot 898 101`; do
733	[ -z "`egetent group ${egid}`" ] && break
734	done
735	esac
736	dscl . create /groups/${egroup} gid ${egid}
737	dscl . create /groups/${egroup} passwd '*'
738	else
739	groupadd ${opts} ${egroup} \|\| die "enewgroup failed"
740	fi
741	export SANDBOX_ON="${oldsandbox}"
742	}
743
744	# Simple script to replace 'dos2unix' binaries
745	# vapier@gentoo.org
746	#
747	# edos2unix(file, <more files>...)
748	edos2unix() {
749	for f in "$@"
750	do
751	cp "${f}" ${T}/edos2unix
752	sed 's/\r$//' ${T}/edos2unix > "${f}"
753	done	932	done
		933	exit ${ret}
		934	)
754	}	935	}
755		936
756	# Make a desktop file !	937	# @FUNCTION: newicon
757	# Great for making those icons in kde/gnome startmenu !	938	# @USAGE: <icon> <newname>
758	# Amaze your friends ! Get the women ! Join today !	939	# @DESCRIPTION:
759	# gnome2 /usr/share/applications	940	# Like all other new* functions, install the specified icon as newname.
760	# gnome1 /usr/share/gnome/apps/	941	newicon() {
761	# KDE ${KDEDIR}/share/applnk /usr/share/applnk	942	(
762	#	943	# wrap the env here so that the 'insinto' call
763	# make_desktop_entry(<binary>, [name], [icon], [type], [path])	944	# doesn't corrupt the env of the caller
764	#
765	# binary: what binary does the app run with ?
766	# name: the name that will show up in the menu
767	# icon: give your little like a pretty little icon ...
768	# this can be relative (to /usr/share/pixmaps) or
769	# a full path to an icon
770	# type: what kind of application is this ? for categories:
771	# http://www.freedesktop.org/standards/menu-spec/
772	# path: if your app needs to startup in a specific dir
773	make_desktop_entry() {
774	[ -z "$1" ] && eerror "You must specify the executable" && return 1
775
776	local exec="${1}"
777	local name="${2:-${PN}}"
778	local icon="${3:-${PN}.png}"
779	local type="${4}"
780	local subdir="${6}"
781	local path="${5:-${GAMES_PREFIX}}"
782	if [ -z "${type}" ]
783	then
784	case ${CATEGORY} in
785	"app-emulation")
786	type=Emulator
787	subdir="Emulation"
788	;;
789	"games-"*)
790	type=Game
791	subdir="Games"
792	;;
793	"net-"*)
794	type=Network
795	subdir="${type}"
796	;;
797	*)
798	type=
799	subdir=
800	;;
801	esac
802	fi
803	local desktop="${T}/${exec}.desktop"
804
805	echo "[Desktop Entry]
806	Encoding=UTF-8
807	Version=0.9.2
808	Name=${name}
809	Type=Application
810	Comment=${DESCRIPTION}
811	Exec=${exec}
812	Path=${path}
813	Icon=${icon}
814	Categories=Application;${type};" > ${desktop}
815
816	if [ -d "/usr/share/applications" ]
817	then
818	insinto /usr/share/applications	945	insinto /usr/share/pixmaps
819	doins ${desktop}	946	newins "$@"
820	fi	947	)
821
822	#if [ -d "/usr/share/gnome/apps" ]
823	#then
824	# insinto /usr/share/gnome/apps/Games
825	# doins ${desktop}
826	#fi
827
828	#if [ ! -z "`ls /usr/kde/* 2>/dev/null`" ]
829	#then
830	# for ver in /usr/kde/*
831	# do
832	# insinto ${ver}/share/applnk/Games
833	# doins ${desktop}
834	# done
835	#fi
836
837	if [ -d "/usr/share/applnk" ]
838	then
839	insinto /usr/share/applnk/${subdir}
840	doins ${desktop}
841	fi
842
843	return 0
844	}	948	}
845		949
846	# for internal use only (unpack_pdv and unpack_makeself)	950	# for internal use only (unpack_pdv and unpack_makeself)
847	find_unpackable_file() {	951	find_unpackable_file() {
848	local src="$1"	952	local src=$1
849	if [ -z "${src}" ]	953	if [[ -z ${src} ]] ; then
850	then
851	src="${DISTDIR}/${A}"	954	src=${DISTDIR}/${A}
852	else	955	else
853	if [ -e "${DISTDIR}/${src}" ]	956	if [[ -e ${DISTDIR}/${src} ]] ; then
854	then
855	src="${DISTDIR}/${src}"	957	src=${DISTDIR}/${src}
856	elif [ -e "${PWD}/${src}" ]	958	elif [[ -e ${PWD}/${src} ]] ; then
857	then
858	src="${PWD}/${src}"	959	src=${PWD}/${src}
859	elif [ -e "${src}" ]	960	elif [[ -e ${src} ]] ; then
860	then
861	src="${src}"	961	src=${src}
862	fi
863	fi	962	fi
864	[ ! -e "${src}" ] && die "Could not find requested archive ${src}"	963	fi
		964	[[ ! -e ${src} ]] && return 1
865	echo "${src}"	965	echo "${src}"
866	}	966	}
867		967
		968	# @FUNCTION: unpack_pdv
		969	# @USAGE: <file to unpack> <size of off_t>
		970	# @DESCRIPTION:
868	# Unpack those pesky pdv generated files ...	971	# Unpack those pesky pdv generated files ...
869	# They're self-unpacking programs with the binary package stuffed in	972	# They're self-unpacking programs with the binary package stuffed in
870	# the middle of the archive. Valve seems to use it a lot ... too bad	973	# the middle of the archive. Valve seems to use it a lot ... too bad
871	# it seems to like to segfault a lot :(. So lets take it apart ourselves.	974	# it seems to like to segfault a lot :(. So lets take it apart ourselves.
872	#	975	#
873	# Usage: unpack_pdv [file to unpack] [size of off_t]
874	# - you have to specify the off_t size ... i have no idea how to extract that	976	# You have to specify the off_t size ... I have no idea how to extract that
875	# information out of the binary executable myself. basically you pass in	977	# information out of the binary executable myself. Basically you pass in
876	# the size of the off_t type (in bytes) on the machine that built the pdv	978	# the size of the off_t type (in bytes) on the machine that built the pdv
		979	# archive.
		980	#
877	# 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
878	# strings <pdv archive> \| grep lseek	984	# strings <pdv archive> \| grep lseek
879	# strace -elseek <pdv archive>	985	# strace -elseek <pdv archive>
		986	# @CODE
		987	#
880	# 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
881	# 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
882	# parameter. here is an example:	990	# parameter. Here is an example:
		991	#
		992	# @CODE
883	# root@vapier 0 pdv_unpack # strings hldsupdatetool.bin \| grep lseek	993	# vapier@vapier 0 pdv_unpack # strings hldsupdatetool.bin \| grep lseek
884	# lseek	994	# lseek
885	# root@vapier 0 pdv_unpack # strace -elseek ./hldsupdatetool.bin	995	# vapier@vapier 0 pdv_unpack # strace -elseek ./hldsupdatetool.bin
886	# lseek(3, -4, SEEK_END) = 2981250	996	# lseek(3, -4, SEEK_END) = 2981250
		997	# @CODE
		998	#
887	# 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.
888	unpack_pdv() {	1000	unpack_pdv() {
889	local src="`find_unpackable_file $1`"	1001	local src=$(find_unpackable_file "$1")
890	local sizeoff_t="$2"	1002	local sizeoff_t=$2
891		1003
		1004	[[ -z ${src} ]] && die "Could not locate source for '$1'"
892	[ -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 :("
893		1006
894	local shrtsrc="`basename ${src}`"	1007	local shrtsrc=$(basename "${src}")
895	echo ">>> Unpacking ${shrtsrc} to ${PWD}"	1008	echo ">>> Unpacking ${shrtsrc} to ${PWD}"
896	local metaskip=`tail -c ${sizeoff_t} ${src} \| hexdump -e \"%i\"`	1009	local metaskip=$(tail -c ${sizeoff_t} "${src}" \| hexdump -e \"%i\")
897	local tailskip=`tail -c $((${sizeoff_t}*2)) ${src} \| head -c ${sizeoff_t} \| hexdump -e \"%i\"`	1010	local tailskip=$(tail -c $((${sizeoff_t}*2)) "${src}" \| head -c ${sizeoff_t} \| hexdump -e \"%i\")
898		1011
899	# grab metadata for debug reasons	1012	# grab metadata for debug reasons
900	local metafile="`mymktemp ${T}`"	1013	local metafile=$(emktemp)
901	tail -c +$((${metaskip}+1)) ${src} > ${metafile}	1014	tail -c +$((${metaskip}+1)) "${src}" > "${metafile}"
902		1015
903	# rip out the final file name from the metadata	1016	# rip out the final file name from the metadata
904	local datafile="`tail -c +$((${metaskip}+1)) ${src} \| strings \| head -n 1`"	1017	local datafile=$(tail -c +$((${metaskip}+1)) "${src}" \| strings \| head -n 1)
905	datafile="`basename ${datafile}`"	1018	datafile=$(basename "${datafile}")
906		1019
907	# now lets uncompress/untar the file if need be	1020	# now lets uncompress/untar the file if need be
908	local tmpfile="`mymktemp ${T}`"	1021	local tmpfile=$(emktemp)
909	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}
910		1023
911	local iscompressed="`file -b ${tmpfile}`"	1024	local iscompressed=$(file -b "${tmpfile}")
912	if [ "${iscompressed:0:8}" == "compress" ] ; then	1025	if [[ ${iscompressed:0:8} == "compress" ]] ; then
913	iscompressed=1	1026	iscompressed=1
914	mv ${tmpfile}{,.Z}	1027	mv ${tmpfile}{,.Z}
915	gunzip ${tmpfile}	1028	gunzip ${tmpfile}
916	else	1029	else
917	iscompressed=0	1030	iscompressed=0
918	fi	1031	fi
919	local istar="`file -b ${tmpfile}`"	1032	local istar=$(file -b "${tmpfile}")
920	if [ "${istar:0:9}" == "POSIX tar" ] ; then	1033	if [[ ${istar:0:9} == "POSIX tar" ]] ; then
921	istar=1	1034	istar=1
922	else	1035	else
923	istar=0	1036	istar=0
924	fi	1037	fi
925		1038
…		…
953	true	1066	true
954	#[ -s "${datafile}" ] \|\| die "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"	1067	#[ -s "${datafile}" ] \|\| die "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"
955	#assert "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"	1068	#assert "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"
956	}	1069	}
957		1070
		1071	# @FUNCTION: unpack_makeself
		1072	# @USAGE: [file to unpack] [offset] [tail\|dd]
		1073	# @DESCRIPTION:
958	# Unpack those pesky makeself generated files ...	1074	# Unpack those pesky makeself generated files ...
959	# They're shell scripts with the binary package tagged onto	1075	# They're shell scripts with the binary package tagged onto
960	# the end of the archive. Loki utilized the format as does	1076	# the end of the archive. Loki utilized the format as does
961	# many other game companies.	1077	# many other game companies.
962	#	1078	#
963	# Usage: unpack_makeself [file to unpack] [offset]	1079	# If the file is not specified, then ${A} is used. If the
964	# - If the file is not specified then unpack will utilize ${A}.
965	# - If the offset is not specified then we will attempt to extract	1080	# offset is not specified then we will attempt to extract
966	# the proper offset from the script itself.	1081	# the proper offset from the script itself.
967	unpack_makeself() {	1082	unpack_makeself() {
		1083	local src_input=${1:-${A}}
968	local src="`find_unpackable_file $1`"	1084	local src=$(find_unpackable_file "${src_input}")
969	local skip="$2"	1085	local skip=$2
		1086	local exe=$3
970		1087
		1088	[[ -z ${src} ]] && die "Could not locate source for '${src_input}'"
		1089
971	local shrtsrc="`basename ${src}`"	1090	local shrtsrc=$(basename "${src}")
972	echo ">>> Unpacking ${shrtsrc} to ${PWD}"	1091	echo ">>> Unpacking ${shrtsrc} to ${PWD}"
973	if [ -z "${skip}" ]	1092	if [[ -z ${skip} ]] ; then
974	then
975	local ver="`grep -a '#.*Makeself' ${src} \| awk '{print $NF}'`"	1093	local ver=$(grep -m1 -a '#.*Makeself' "${src}" \| awk '{print $NF}')
976	local skip=0	1094	local skip=0
		1095	exe=tail
977	case ${ver} in	1096	case ${ver} in
978	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
979	skip=`grep -a ^skip= ${src} \| cut -d= -f2`	1098	skip=$(grep -a ^skip= "${src}" \| cut -d= -f2)
980	;;	1099	;;
981	2.0\|2.0.1)	1100	2.0\|2.0.1)
982	skip=`grep -a ^$'\t'tail ${src} \| awk '{print $2}' \| cut -b2-`	1101	skip=$(grep -a ^$'\t'tail "${src}" \| awk '{print $2}' \| cut -b2-)
983	;;	1102	;;
984	2.1.1)	1103	2.1.1)
985	skip=`grep -a ^offset= ${src} \| awk '{print $2}' \| cut -b2-`	1104	skip=$(grep -a ^offset= "${src}" \| awk '{print $2}' \| cut -b2-)
986	let skip="skip + 1"	1105	(( skip++ ))
987	;;	1106	;;
988	2.1.2)	1107	2.1.2)
989	skip=`grep -a ^offset= ${src} \| awk '{print $3}' \| head -n 1`	1108	skip=$(grep -a ^offset= "${src}" \| awk '{print $3}' \| head -n 1)
990	let skip="skip + 1"	1109	(( skip++ ))
991	;;	1110	;;
992	2.1.3)	1111	2.1.3)
993	skip=`grep -a ^offset= ${src} \| awk '{print $3}'`	1112	skip=`grep -a ^offset= "${src}" \| awk '{print $3}'`
994	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"
995	;;	1119	;;
996	*)	1120	*)
997	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."
998	eerror "The version I detected was '${ver}'."	1122	eerror "The version I detected was '${ver}'."
999	eerror "Please file a bug about the file ${shrtsrc} at"	1123	eerror "Please file a bug about the file ${shrtsrc} at"
…		…
1001	die "makeself version '${ver}' not supported"	1125	die "makeself version '${ver}' not supported"
1002	;;	1126	;;
1003	esac	1127	esac
1004	debug-print "Detected Makeself version ${ver} ... using ${skip} as offset"	1128	debug-print "Detected Makeself version ${ver} ... using ${skip} as offset"
1005	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
1006		1135
1007	# 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
1008	local tmpfile="`mymktemp ${T}`"	1137	local filetype tmpfile=$(emktemp)
1009	tail -n +${skip} ${src} 2>/dev/null \| head -c 512 > ${tmpfile}	1138	eval ${exe} 2>/dev/null \| head -c 512 > "${tmpfile}"
1010	local filetype="`file -b ${tmpfile}`"	1139	filetype=$(file -b "${tmpfile}") \|\| die
1011	case ${filetype} in	1140	case ${filetype} in
1012	*tar\ archive)	1141	tar\ archive)
1013	tail -n +${skip} ${src} \| tar --no-same-owner -xf -	1142	eval ${exe} \| tar --no-same-owner -xf -
1014	;;	1143	;;
1015	bzip2*)	1144	bzip2*)
1016	tail -n +${skip} ${src} \| bzip2 -dc \| tar --no-same-owner -xf -	1145	eval ${exe} \| bzip2 -dc \| tar --no-same-owner -xf -
1017	;;	1146	;;
1018	gzip*)	1147	gzip*)
1019	tail -n +${skip} ${src} \| tar --no-same-owner -xzf -	1148	eval ${exe} \| tar --no-same-owner -xzf -
		1149	;;
		1150	compress*)
		1151	eval ${exe} \| gunzip \| tar --no-same-owner -xf -
1020	;;	1152	;;
1021	*)	1153	*)
		1154	eerror "Unknown filetype \"${filetype}\" ?"
1022	false	1155	false
1023	;;	1156	;;
1024	esac	1157	esac
1025	assert "failure unpacking (${filetype}) makeself ${shrtsrc} ('${ver}' +${skip})"	1158	assert "failure unpacking (${filetype}) makeself ${shrtsrc} ('${ver}' +${skip})"
1026	}	1159	}
1027		1160
1028	# Display a license for user to accept.	1161	# @FUNCTION: cdrom_get_cds
1029	#	1162	# @USAGE: <file on cd1> [file on cd2] [file on cd3] [...]
1030	# Usage: check_license [license]	1163	# @DESCRIPTION:
1031	# - If the file is not specified then ${LICENSE} is used.
1032	check_license() {
1033	local lic=$1
1034	if [ -z "${lic}" ] ; then
1035	lic="${PORTDIR}/licenses/${LICENSE}"
1036	else
1037	if [ -e "${PORTDIR}/licenses/${src}" ] ; then
1038	lic="${PORTDIR}/licenses/${src}"
1039	elif [ -e "${PWD}/${src}" ] ; then
1040	lic="${PWD}/${src}"
1041	elif [ -e "${src}" ] ; then
1042	lic="${src}"
1043	fi
1044	fi
1045	[ ! -f "${lic}" ] && die "Could not find requested license ${src}"
1046	local l="`basename ${lic}`"
1047
1048	# here is where we check for the licenses the user already
1049	# accepted ... if we don't find a match, we make the user accept
1050	local alic
1051	for alic in "${ACCEPT_LICENSE}" ; do
1052	[ "${alic}" == "*" ] && return 0
1053	[ "${alic}" == "${l}" ] && return 0
1054	done
1055
1056	local licmsg="`mymktemp ${T}`"
1057	cat << EOF > ${licmsg}
1058	**********************************************************
1059	The following license outlines the terms of use of this
1060	package. You MUST accept this license for installation to
1061	continue. When you are done viewing, hit 'q'. If you
1062	CTRL+C out of this, the install will not run!
1063	**********************************************************
1064
1065	EOF
1066	cat ${lic} >> ${licmsg}
1067	${PAGER:-less} ${licmsg} \|\| die "Could not execute pager (${PAGER}) to accept ${lic}"
1068	einfon "Do you accept the terms of this license (${l})? [yes/no] "
1069	read alic
1070	case ${alic} in
1071	yes\|Yes\|y\|Y)
1072	return 0
1073	;;
1074	*)
1075	echo;echo;echo
1076	eerror "You MUST accept the license to continue! Exiting!"
1077	die "Failed to accept license"
1078	;;
1079	esac
1080	}
1081
1082	# Aquire cd(s) for those lovely cd-based emerges. Yes, this violates	1164	# Aquire cd(s) for those lovely cd-based emerges. Yes, this violates
1083	# the whole 'non-interactive' policy, but damnit I want CD support !	1165	# the whole 'non-interactive' policy, but damnit I want CD support !
1084	#	1166	#
1085	# with these cdrom functions we handle all the user interaction and	1167	# With these cdrom functions we handle all the user interaction and
1086	# standardize everything. all you have to do is call cdrom_get_cds()	1168	# standardize everything. All you have to do is call cdrom_get_cds()
1087	# and when the function returns, you can assume that the cd has been	1169	# and when the function returns, you can assume that the cd has been
1088	# found at CDROM_ROOT.	1170	# found at CDROM_ROOT.
1089	#	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	#
1090	# normally the cdrom functions will refer to the cds as 'cd #1', 'cd #2',	1176	# Normally the cdrom functions will refer to the cds as 'cd #1', 'cd #2',
1091	# etc... if you want to give the cds better names, then just export	1177	# etc... If you want to give the cds better names, then just export
1092	# the CDROM_NAME_X variables before calling cdrom_get_cds().	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.
1093	#	1181	#
1094	# for those multi cd ebuilds, see the cdrom_load_next_cd() below.	1182	# For those multi cd ebuilds, see the cdrom_load_next_cd() function.
1095	#
1096	# Usage: cdrom_get_cds <file on cd1> [file on cd2] [file on cd3] [...]
1097	# - this will attempt to locate a cd based upon a file that is on
1098	# the cd ... the more files you give this function, the more cds
1099	# the cdrom functions will handle
1100	cdrom_get_cds() {	1183	cdrom_get_cds() {
1101	# first we figure out how many cds we're dealing with by	1184	# first we figure out how many cds we're dealing with by
1102	# the # of files they gave us	1185	# the # of files they gave us
1103	local cdcnt=0	1186	local cdcnt=0
1104	local f=	1187	local f=
1105	for f in "$@" ; do	1188	for f in "$@" ; do
1106	cdcnt=$((cdcnt + 1))	1189	((++cdcnt))
1107	export CDROM_CHECK_${cdcnt}="$f"	1190	export CDROM_CHECK_${cdcnt}="$f"
1108	done	1191	done
1109	export CDROM_TOTAL_CDS=${cdcnt}	1192	export CDROM_TOTAL_CDS=${cdcnt}
1110	export CDROM_CURRENT_CD=1	1193	export CDROM_CURRENT_CD=1
1111		1194
1112	# now we see if the user gave use CD_ROOT ...	1195	# now we see if the user gave use CD_ROOT ...
1113	# if they did, let's just believe them that it's correct	1196	# if they did, let's just believe them that it's correct
1114	if [ ! -z "${CD_ROOT}" ] ; then	1197	if [[ -n ${CD_ROOT}${CD_ROOT_1} ]] ; then
1115	export CDROM_ROOT="${CD_ROOT}"
1116	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
1117	return
1118	fi
1119	# do the same for CD_ROOT_X
1120	if [ ! -z "${CD_ROOT_1}" ] ; then
1121	local var=	1198	local var=
1122	cdcnt=0	1199	cdcnt=0
1123	while [ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ] ; do	1200	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
1124	cdcnt=$((cdcnt + 1))	1201	((++cdcnt))
1125	var="CD_ROOT_${cdcnt}"	1202	var="CD_ROOT_${cdcnt}"
		1203	[[ -z ${!var} ]] && var="CD_ROOT"
1126	if [ -z "${!var}" ] ; then	1204	if [[ -z ${!var} ]] ; then
1127	eerror "You must either use just the CD_ROOT"	1205	eerror "You must either use just the CD_ROOT"
1128	eerror "or specify ALL the CD_ROOT_X variables."	1206	eerror "or specify ALL the CD_ROOT_X variables."
1129	eerror "In this case, you will need ${CDROM_TOTAL_CDS} CD_ROOT_X variables."	1207	eerror "In this case, you will need ${CDROM_TOTAL_CDS} CD_ROOT_X variables."
1130	die "could not locate CD_ROOT_${cdcnt}"	1208	die "could not locate CD_ROOT_${cdcnt}"
1131	fi	1209	fi
1132	export CDROM_ROOTS_${cdcnt}="${!var}"
1133	done	1210	done
1134	export CDROM_ROOT=${CDROM_ROOTS_1}	1211	export CDROM_ROOT=${CD_ROOT_1:-${CD_ROOT}}
1135	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_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}
1136	return	1219	return
1137	fi	1220	fi
1138		1221
		1222	# User didn't help us out so lets make sure they know they can
		1223	# simplify the whole process ...
1139	if [ ${CDROM_TOTAL_CDS} -eq 1 ] ; then	1224	if [[ ${CDROM_TOTAL_CDS} -eq 1 ]] ; then
1140	einfon "This ebuild will need the "	1225	einfo "This ebuild will need the ${CDROM_NAME:-cdrom for ${PN}}"
1141	if [ -z "${CDROM_NAME}" ] ; then
1142	echo "cdrom for ${PN}."
1143	else
1144	echo "${CDROM_NAME}."
1145	fi
1146	echo	1226	echo
1147	einfo "If you do not have the CD, but have the data files"	1227	einfo "If you do not have the CD, but have the data files"
1148	einfo "mounted somewhere on your filesystem, just export"	1228	einfo "mounted somewhere on your filesystem, just export"
1149	einfo "the variable CD_ROOT so that it points to the"	1229	einfo "the variable CD_ROOT so that it points to the"
1150	einfo "directory containing the files."	1230	einfo "directory containing the files."
1151	echo	1231	echo
		1232	einfo "For example:"
		1233	einfo "export CD_ROOT=/mnt/cdrom"
		1234	echo
1152	else	1235	else
		1236	if [[ -n ${CDROM_NAME_SET} ]] ; then
		1237	# Translate the CDROM_NAME_SET array into CDROM_NAME_#
		1238	cdcnt=0
		1239	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
		1240	((++cdcnt))
		1241	export CDROM_NAME_${cdcnt}="${CDROM_NAME_SET[$((${cdcnt}-1))]}"
		1242	done
		1243	fi
		1244
1153	einfo "This package will need access to ${CDROM_TOTAL_CDS} cds."	1245	einfo "This package will need access to ${CDROM_TOTAL_CDS} cds."
1154	cdcnt=0	1246	cdcnt=0
1155	while [ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ] ; do	1247	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
1156	cdcnt=$((cdcnt + 1))	1248	((++cdcnt))
1157	var="CDROM_NAME_${cdcnt}"	1249	var="CDROM_NAME_${cdcnt}"
1158	[ ! -z "${!var}" ] && einfo " CD ${cdcnt}: ${!var}"	1250	[[ ! -z ${!var} ]] && einfo " CD ${cdcnt}: ${!var}"
1159	done	1251	done
1160	echo	1252	echo
1161	einfo "If you do not have the CDs, but have the data files"	1253	einfo "If you do not have the CDs, but have the data files"
1162	einfo "mounted somewhere on your filesystem, just export"	1254	einfo "mounted somewhere on your filesystem, just export"
1163	einfo "the following variables so they point to the right place:"	1255	einfo "the following variables so they point to the right place:"
1164	einfon ""	1256	einfon ""
1165	cdcnt=0	1257	cdcnt=0
1166	while [ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ] ; do	1258	while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
1167	cdcnt=$((cdcnt + 1))	1259	((++cdcnt))
1168	echo -n " CD_ROOT_${cdcnt}"	1260	echo -n " CD_ROOT_${cdcnt}"
1169	done	1261	done
1170	echo	1262	echo
1171	einfo "Or, if you have all the files in the same place, or"	1263	einfo "Or, if you have all the files in the same place, or"
1172	einfo "you only have one cdrom, you can export CD_ROOT"	1264	einfo "you only have one cdrom, you can export CD_ROOT"
1173	einfo "and that place will be used as the same data source"	1265	einfo "and that place will be used as the same data source"
1174	einfo "for all the CDs."	1266	einfo "for all the CDs."
1175	echo	1267	echo
		1268	einfo "For example:"
		1269	einfo "export CD_ROOT_1=/mnt/cdrom"
		1270	echo
1176	fi	1271	fi
		1272
		1273	export CDROM_SET=""
1177	export CDROM_CURRENT_CD=0	1274	export CDROM_CURRENT_CD=0
1178	cdrom_load_next_cd	1275	cdrom_load_next_cd
1179	}	1276	}
1180		1277
1181	# this is only used when you need access to more than one cd.	1278	# @FUNCTION: cdrom_load_next_cd
1182	# when you have finished using the first cd, just call this function.	1279	# @DESCRIPTION:
1183	# when it returns, CDROM_ROOT will be pointing to the second cd.	1280	# Some packages are so big they come on multiple CDs. When you're done reading
1184	# remember, you can only go forward in the cd chain, you can't go back.	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.
1185	cdrom_load_next_cd() {	1286	cdrom_load_next_cd() {
1186	export CDROM_CURRENT_CD=$((CDROM_CURRENT_CD + 1))
1187	local var=	1287	local var
1188		1288	((++CDROM_CURRENT_CD))
1189	if [ ! -z "${CD_ROOT}" ] ; then
1190	einfo "Using same root as before for CD #${CDROM_CURRENT_CD}"
1191	return
1192	fi
1193		1289
1194	unset CDROM_ROOT	1290	unset CDROM_ROOT
1195	var=CDROM_ROOTS_${CDROM_CURRENT_CD}	1291	var=CD_ROOT_${CDROM_CURRENT_CD}
		1292	[[ -z ${!var} ]] && var="CD_ROOT"
1196	if [ -z "${!var}" ] ; then	1293	if [[ -z ${!var} ]] ; then
1197	var="CDROM_CHECK_${CDROM_CURRENT_CD}"	1294	var="CDROM_CHECK_${CDROM_CURRENT_CD}"
1198	cdrom_locate_file_on_cd ${!var}	1295	_cdrom_locate_file_on_cd ${!var}
1199	else	1296	else
1200	export CDROM_ROOT="${!var}"	1297	export CDROM_ROOT=${!var}
1201	fi	1298	fi
1202		1299
1203	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"	1300	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
1204	}	1301	}
1205		1302
…		…
1208	# all it does is try to locate a give file on a cd ... if the cd isn't	1305	# all it does is try to locate a give file on a cd ... if the cd isn't
1209	# found, then a message asking for the user to insert the cdrom will be	1306	# found, then a message asking for the user to insert the cdrom will be
1210	# displayed and we'll hang out here until:	1307	# displayed and we'll hang out here until:
1211	# (1) the file is found on a mounted cdrom	1308	# (1) the file is found on a mounted cdrom
1212	# (2) the user hits CTRL+C	1309	# (2) the user hits CTRL+C
1213	cdrom_locate_file_on_cd() {	1310	_cdrom_locate_file_on_cd() {
1214	while [ -z "${CDROM_ROOT}" ] ; do
1215	local dir="$(dirname ${@})"
1216	local file="$(basename ${@})"
1217	local mline=""	1311	local mline=""
1218	local showedmsg=0	1312	local showedmsg=0 showjolietmsg=0
1219		1313
1220	for mline in `mount \| egrep -e '(iso\|cdrom)' \| awk '{print $3}'` ; do	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/ }
1221	[ -d "${mline}/${dir}" ] \|\| continue	1331	[[ ! -d ${point}/${dir} ]] && continue
1222	[ ! -z "$(find ${mline}/${dir} -iname ${file} -maxdepth 1)" ] \	1332	[[ -z $(find "${point}/${dir}" -maxdepth 1 -iname "${file}") ]] && continue
1223	&& export CDROM_ROOT=${mline}	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))
1224	done	1340	done
1225		1341
1226	if [ -z "${CDROM_ROOT}" ] ; then
1227	echo	1342	echo
1228	if [ ${showedmsg} -eq 0 ] ; then	1343	if [[ ${showedmsg} -eq 0 ]] ; then
1229	if [ ${CDROM_TOTAL_CDS} -eq 1 ] ; then	1344	if [[ ${CDROM_TOTAL_CDS} -eq 1 ]] ; then
1230	if [ -z "${CDROM_NAME}" ] ; then	1345	if [[ -z ${CDROM_NAME} ]] ; then
1231	einfo "Please insert the cdrom for ${PN} now !"	1346	einfo "Please insert+mount the cdrom for ${PN} now !"
1232	else
1233	einfo "Please insert the ${CDROM_NAME} cdrom now !"
1234	fi
1235	else	1347	else
1236	if [ -z "${CDROM_NAME_1}" ] ; then
1237	einfo "Please insert cd #${CDROM_CURRENT_CD} for ${PN} now !"
1238	else
1239	local var="CDROM_NAME_${CDROM_CURRENT_CD}"
1240	einfo "Please insert+mount the ${!var} cdrom now !"	1348	einfo "Please insert+mount the ${CDROM_NAME} cdrom now !"
1241	fi
1242	fi	1349	fi
1243	showedmsg=1	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
1244	fi	1357	fi
		1358	showedmsg=1
		1359	fi
1245	einfo "Press return to scan for the cd again"	1360	einfo "Press return to scan for the cd again"
1246	einfo "or hit CTRL+C to abort the emerge."	1361	einfo "or hit CTRL+C to abort the emerge."
1247	read	1362	echo
		1363	if [[ ${showjolietmsg} -eq 0 ]] ; then
		1364	showjolietmsg=1
		1365	else
		1366	ewarn "If you are having trouble with the detection"
		1367	ewarn "of your CD, it is possible that you do not have"
		1368	ewarn "Joliet support enabled in your kernel. Please"
		1369	ewarn "check that CONFIG_JOLIET is enabled in your kernel."
		1370	ebeep 5
1248	fi	1371	fi
		1372	read \|\| die "something is screwed with your system"
1249	done	1373	done
1250	}	1374	}
1251		1375
		1376	# @FUNCTION: strip-linguas
		1377	# @USAGE: [<allow LINGUAS>\|<-i\|-u> <directories of .po files>]
		1378	# @DESCRIPTION:
1252	# Make sure that LINGUAS only contains languages that	1379	# Make sure that LINGUAS only contains languages that
1253	# a package can support	1380	# a package can support. The first form allows you to
1254	#	1381	# specify a list of LINGUAS. The -i builds a list of po
1255	# usage: strip-linguas <allow LINGUAS>	1382	# files found in all the directories and uses the
1256	# strip-linguas -i <directories of .po files>	1383	# intersection of the lists. The -u builds a list of po
1257	# strip-linguas -u <directories of .po files>	1384	# files found in all the directories and uses the union
1258	#	1385	# of the lists.
1259	# The first form allows you to specify a list of LINGUAS.
1260	# The -i builds a list of po files found in all the
1261	# directories and uses the intersection of the lists.
1262	# The -u builds a list of po files found in all the
1263	# directories and uses the union of the lists.
1264	strip-linguas() {	1386	strip-linguas() {
1265	local ls newls	1387	local ls newls nols
1266	if [ "$1" == "-i" ] \|\| [ "$1" == "-u" ] ; then	1388	if [[ $1 == "-i" ]] \|\| [[ $1 == "-u" ]] ; then
1267	local op="$1"; shift	1389	local op=$1; shift
1268	ls=" $(find "$1" -name '*.po' -printf '%f ') "; shift	1390	ls=$(find "$1" -name '*.po' -exec basename {} .po ';'); shift
1269	local d f	1391	local d f
1270	for d in "$@" ; do	1392	for d in "$@" ; do
1271	if [ "${op}" == "-u" ] ; then	1393	if [[ ${op} == "-u" ]] ; then
1272	newls="${ls}"	1394	newls=${ls}
1273	else	1395	else
1274	newls=""	1396	newls=""
1275	fi	1397	fi
1276	for f in $(find "$d" -name '*.po' -printf '%f ') ; do	1398	for f in $(find "$d" -name '*.po' -exec basename {} .po ';') ; do
1277	if [ "${op}" == "-i" ] ; then	1399	if [[ ${op} == "-i" ]] ; then
1278	[ "${ls/ ${f} /}" != "${ls}" ] && newls="${newls} ${f}"	1400	has ${f} ${ls} && newls="${newls} ${f}"
1279	else	1401	else
1280	[ "${ls/ ${f} /}" == "${ls}" ] && newls="${newls} ${f}"	1402	has ${f} ${ls} \|\| newls="${newls} ${f}"
1281	fi	1403	fi
1282	done	1404	done
1283	ls="${newls}"	1405	ls=${newls}
1284	done	1406	done
1285	ls="${ls//.po}"
1286	else	1407	else
1287	ls="$@"	1408	ls="$@"
1288	fi	1409	fi
1289		1410
1290	ls=" ${ls} "	1411	nols=""
1291	newls=""	1412	newls=""
1292	for f in ${LINGUAS} ; do	1413	for f in ${LINGUAS} ; do
1293	if [ "${ls/ ${f} /}" != "${ls}" ] ; then	1414	if has ${f} ${ls} ; then
1294	nl="${newls} ${f}"	1415	newls="${newls} ${f}"
1295	else	1416	else
1296	ewarn "Sorry, but ${PN} does not support the ${f} LINGUA"	1417	nols="${nols} ${f}"
1297	fi	1418	fi
1298	done	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:-.}"
1299	if [ -z "${newls}" ] ; then	1617	if [ -n "${libdir}" ] ; then
1300	unset LINGUAS	1618	if [ "\${LD_LIBRARY_PATH+set}" = "set" ] ; then
		1619	export LD_LIBRARY_PATH="\${LD_LIBRARY_PATH}:${libdir}"
1301	else	1620	else
1302	export LINGUAS="${newls}"	1621	export LD_LIBRARY_PATH="${libdir}"
		1622	fi
1303	fi	1623	fi
		1624	exec ${bin} "\$@"
		1625	EOF
		1626	chmod go+rx "${tmpwrapper}"
		1627	if [[ -n ${path} ]] ; then
		1628	(
		1629	exeinto "${path}"
		1630	newexe "${tmpwrapper}" "${wrapper}"
		1631	) \|\| die
		1632	else
		1633	newbin "${tmpwrapper}" "${wrapper}" \|\| die
		1634	fi
1304	}	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
		1660	case ${opt} in
		1661	-a) return $(( r != 0 )) ;;
		1662	-o) return $(( r == $# )) ;;
		1663	esac
		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.92
 


changed lines


 
Added in v.1.375
 Legend:



Removed from v.1.92
 


changed lines


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

	ViewVC Help
Powered by ViewVC 1.1.20