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

Diff of /eclass/eutils.eclass

Parent Directory | Revision Log | View Patch Patch

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

 Legend:



Removed from v.1.73
 


changed lines


 
Added in v.1.368
 Legend:



Removed from v.1.73
 


changed lines


 
Added in v.1.368
-Removed from v.1.73
+Added in v.1.368

	ViewVC Help
Powered by ViewVC 1.1.13