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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.96
 


changed lines


 
Added in v.1.363
 Legend:



Removed from v.1.96
 


changed lines


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

	ViewVC Help
Powered by ViewVC 1.1.13