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

Diff of /eclass/eutils.eclass

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

Revision 1.323 Revision 1.332
1# Copyright 1999-2009 Gentoo Foundation 1# Copyright 1999-2009 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.323 2009/12/19 00:01:04 zmedico Exp $ 3# $Header: /var/cvsroot/gentoo-x86/eclass/eutils.eclass,v 1.332 2010/02/17 02:22:43 reavertm Exp $
4 4
5# @ECLASS: eutils.eclass 5# @ECLASS: eutils.eclass
6# @MAINTAINER: 6# @MAINTAINER:
7# base-system@gentoo.org 7# base-system@gentoo.org
8# @BLURB: many extra (but common) functions that are used in ebuilds 8# @BLURB: many extra (but common) functions that are used in ebuilds
17 17
18inherit multilib portability 18inherit multilib portability
19 19
20DESCRIPTION="Based on the ${ECLASS} eclass" 20DESCRIPTION="Based on the ${ECLASS} eclass"
21 21
22if has "${EAPI:-0}" 0 1 2; then
23
22# @FUNCTION: epause 24# @FUNCTION: epause
23# @USAGE: [seconds] 25# @USAGE: [seconds]
24# @DESCRIPTION: 26# @DESCRIPTION:
25# Sleep for the specified number of seconds (default of 5 seconds). Useful when 27# Sleep for the specified number of seconds (default of 5 seconds). Useful when
26# printing a message the user should probably be reading and often used in 28# printing a message the user should probably be reading and often used in
27# conjunction with the ebeep function. If the EPAUSE_IGNORE env var is set, 29# conjunction with the ebeep function. If the EPAUSE_IGNORE env var is set,
28# don't wait at all. 30# don't wait at all. Defined in EAPIs 0 1 and 2.
29epause() { 31epause() {
30 [[ -z ${EPAUSE_IGNORE} ]] && sleep ${1:-5} 32 [[ -z ${EPAUSE_IGNORE} ]] && sleep ${1:-5}
31} 33}
32 34
33# @FUNCTION: ebeep 35# @FUNCTION: ebeep
34# @USAGE: [number of beeps] 36# @USAGE: [number of beeps]
35# @DESCRIPTION: 37# @DESCRIPTION:
36# Issue the specified number of beeps (default of 5 beeps). Useful when 38# Issue the specified number of beeps (default of 5 beeps). Useful when
37# printing a message the user should probably be reading and often used in 39# printing a message the user should probably be reading and often used in
38# conjunction with the epause function. If the EBEEP_IGNORE env var is set, 40# conjunction with the epause function. If the EBEEP_IGNORE env var is set,
39# don't beep at all. 41# don't beep at all. Defined in EAPIs 0 1 and 2.
40ebeep() { 42ebeep() {
41 local n 43 local n
42 if [[ -z ${EBEEP_IGNORE} ]] ; then 44 if [[ -z ${EBEEP_IGNORE} ]] ; then
43 for ((n=1 ; n <= ${1:-5} ; n++)) ; do 45 for ((n=1 ; n <= ${1:-5} ; n++)) ; do
44 echo -ne "\a" 46 echo -ne "\a"
47 sleep 1 49 sleep 1
48 done 50 done
49 fi 51 fi
50} 52}
51 53
54else
55
56ebeep() {
57 eqawarn "QA Notice: ebeep is not defined in EAPI=3, please file a bug at http://bugs.gentoo.org"
58}
59
60epause() {
61 eqawarn "QA Notice: epause is not defined in EAPI=3, please file a bug at http://bugs.gentoo.org"
62}
63
64fi
65
52# @FUNCTION: ecvs_clean 66# @FUNCTION: ecvs_clean
53# @USAGE: [list of dirs] 67# @USAGE: [list of dirs]
54# @DESCRIPTION: 68# @DESCRIPTION:
55# Remove CVS directories recursiveley. Useful when a source tarball contains 69# Remove CVS directories recursiveley. Useful when a source tarball contains
56# internal CVS directories. Defaults to $PWD. 70# internal CVS directories. Defaults to $PWD.
69 [[ -z $* ]] && set -- . 83 [[ -z $* ]] && set -- .
70 find "$@" -type d -name '.svn' -prune -print0 | xargs -0 rm -rf 84 find "$@" -type d -name '.svn' -prune -print0 | xargs -0 rm -rf
71} 85}
72 86
73# @FUNCTION: eshopts_push 87# @FUNCTION: eshopts_push
74# @USAGE: [options to `set`] 88# @USAGE: [options to `set` or `shopt`]
75# @DESCRIPTION: 89# @DESCRIPTION:
76# Often times code will want to enable a shell option to change code behavior. 90# Often times code will want to enable a shell option to change code behavior.
77# Since changing shell options can easily break other pieces of code (which 91# Since changing shell options can easily break other pieces of code (which
78# assume the default state), eshopts_push is used to (1) push the current shell 92# assume the default state), eshopts_push is used to (1) push the current shell
79# options onto a stack and (2) pass the specified arguments to set. 93# options onto a stack and (2) pass the specified arguments to set.
94#
95# If the first argument is '-s' or '-u', we assume you want to call `shopt`
96# rather than `set` as there are some options only available via that.
80# 97#
81# A common example is to disable shell globbing so that special meaning/care 98# A common example is to disable shell globbing so that special meaning/care
82# may be used with variables/arguments to custom functions. That would be: 99# may be used with variables/arguments to custom functions. That would be:
83# @CODE 100# @CODE
84# eshopts_push -o noglob 101# eshopts_push -o noglob
92# @CODE 109# @CODE
93eshopts_push() { 110eshopts_push() {
94 # have to assume __ESHOPTS_SAVE__ isn't screwed with 111 # have to assume __ESHOPTS_SAVE__ isn't screwed with
95 # as a `declare -a` here will reset its value 112 # as a `declare -a` here will reset its value
96 local i=${#__ESHOPTS_SAVE__[@]} 113 local i=${#__ESHOPTS_SAVE__[@]}
114 if [[ $1 == -[su] ]] ; then
97 __ESHOPTS_SAVE__[$i]=$- 115 __ESHOPTS_SAVE__[$i]=$(shopt -p)
98 [[ $# -eq 0 ]] && return 0 116 [[ $# -eq 0 ]] && return 0
117 shopt "$@" || die "eshopts_push: bad options to shopt: $*"
118 else
119 __ESHOPTS_SAVE__[$i]=$-
120 [[ $# -eq 0 ]] && return 0
99 set "$@" || die "eshopts_push: bad options to set: $*" 121 set "$@" || die "eshopts_push: bad options to set: $*"
122 fi
100} 123}
101 124
102# @FUNCTION: eshopts_pop 125# @FUNCTION: eshopts_pop
103# @USAGE: 126# @USAGE:
104# @DESCRIPTION: 127# @DESCRIPTION:
108 [[ $# -ne 0 ]] && die "eshopts_pop takes no arguments" 131 [[ $# -ne 0 ]] && die "eshopts_pop takes no arguments"
109 local i=$(( ${#__ESHOPTS_SAVE__[@]} - 1 )) 132 local i=$(( ${#__ESHOPTS_SAVE__[@]} - 1 ))
110 [[ ${i} -eq -1 ]] && die "eshopts_{push,pop}: unbalanced pair" 133 [[ ${i} -eq -1 ]] && die "eshopts_{push,pop}: unbalanced pair"
111 local s=${__ESHOPTS_SAVE__[$i]} 134 local s=${__ESHOPTS_SAVE__[$i]}
112 unset __ESHOPTS_SAVE__[$i] 135 unset __ESHOPTS_SAVE__[$i]
136 if [[ ${s} == "shopt -"* ]] ; then
137 eval "${s}" || die "eshopts_pop: sanity: invalid shopt options: ${s}"
138 else
113 set +$- || die "eshopts_pop: sanity: invalid shell settings: $-" 139 set +$- || die "eshopts_pop: sanity: invalid shell settings: $-"
114 set -${s} || die "eshopts_pop: sanity: unable to restore saved shell settings: ${s}" 140 set -${s} || die "eshopts_pop: sanity: unable to restore saved shell settings: ${s}"
141 fi
115} 142}
116 143
117# Default directory where patches are located 144# @VARIABLE: EPATCH_SOURCE
145# @DESCRIPTION:
146# Default directory to search for patches.
118EPATCH_SOURCE="${WORKDIR}/patch" 147EPATCH_SOURCE="${WORKDIR}/patch"
119# Default extension for patches 148# @VARIABLE: EPATCH_SUFFIX
149# @DESCRIPTION:
150# Default extension for patches (do not prefix the period yourself).
120EPATCH_SUFFIX="patch.bz2" 151EPATCH_SUFFIX="patch.bz2"
152# @VARIABLE: EPATCH_OPTS
153# @DESCRIPTION:
121# Default options for patch 154# Default options for patch:
155# @CODE
122# Set -g0 to keep RCS, ClearCase, Perforce and SCCS happy. Bug #24571 156# -g0 - keep RCS, ClearCase, Perforce and SCCS happy #24571
123# Set --no-backup-if-mismatch so we don't leave '.orig' files behind. 157# --no-backup-if-mismatch - do not leave .orig files behind
124# Set -E to automatically remove empty files. 158# -E - automatically remove empty files
159# @CODE
125EPATCH_OPTS="-g0 -E --no-backup-if-mismatch" 160EPATCH_OPTS="-g0 -E --no-backup-if-mismatch"
161# @VARIABLE: EPATCH_EXCLUDE
162# @DESCRIPTION:
126# List of patches not to apply. Note this is only file names, 163# List of patches not to apply. Note this is only file names,
127# and not the full path .. 164# and not the full path. Globs accepted.
128EPATCH_EXCLUDE="" 165EPATCH_EXCLUDE=""
166# @VARIABLE: EPATCH_SINGLE_MSG
167# @DESCRIPTION:
129# Change the printed message for a single patch. 168# Change the printed message for a single patch.
130EPATCH_SINGLE_MSG="" 169EPATCH_SINGLE_MSG=""
170# @VARIABLE: EPATCH_MULTI_MSG
171# @DESCRIPTION:
131# Change the printed message for multiple patches. 172# Change the printed message for multiple patches.
132EPATCH_MULTI_MSG="Applying various patches (bugfixes/updates) ..." 173EPATCH_MULTI_MSG="Applying various patches (bugfixes/updates) ..."
133# Force applying bulk patches even if not following the style: 174# @VARIABLE: EPATCH_FORCE
134# 175# @DESCRIPTION:
135# ??_${ARCH}_foo.${EPATCH_SUFFIX} 176# Only require patches to match EPATCH_SUFFIX rather than the extended
136# 177# arch naming style.
137EPATCH_FORCE="no" 178EPATCH_FORCE="no"
138 179
139# This function is for bulk patching, or in theory for just one 180# @FUNCTION: epatch
140# or two patches. 181# @USAGE: [patches] [dirs of patches]
182# @DESCRIPTION:
183# epatch is designed to greatly simplify the application of patches. It can
184# process patch files directly, or directories of patches. The patches may be
185# compressed (bzip/gzip/etc...) or plain text. You generally need not specify
186# the -p option as epatch will automatically attempt -p0 to -p5 until things
187# apply successfully.
141# 188#
142# It should work with .bz2, .gz, .zip and plain text patches. 189# If you do not specify any options, then epatch will default to the directory
143# Currently all patches should be the same format. 190# specified by EPATCH_SOURCE.
144# 191#
145# You do not have to specify '-p' option to patch, as it will 192# When processing directories, epatch will apply all patches that match:
146# try with -p0 to -p5 until it succeed, or fail at -p5. 193# @CODE
147# 194# ${EPATCH_FORCE} == "yes"
148# Above EPATCH_* variables can be used to control various defaults,
149# bug they should be left as is to ensure an ebuild can rely on
150# them for.
151#
152# Patches are applied in current directory.
153#
154# Bulk Patches should preferably have the form of:
155#
156# ??_${ARCH}_foo.${EPATCH_SUFFIX} 195# ??_${ARCH}_foo.${EPATCH_SUFFIX}
196# else
197# *.${EPATCH_SUFFIX}
198# @CODE
199# The leading ?? are typically numbers used to force consistent patch ordering.
200# The arch field is used to apply patches only for the host architecture with
201# the special value of "all" means apply for everyone. Note that using values
202# other than "all" is highly discouraged -- you should apply patches all the
203# time and let architecture details be detected at configure/compile time.
157# 204#
158# For example: 205# If EPATCH_SUFFIX is empty, then no period before it is implied when searching
206# for patches to apply.
159# 207#
160# 01_all_misc-fix.patch.bz2 208# Refer to the other EPATCH_xxx variables for more customization of behavior.
161# 02_sparc_another-fix.patch.bz2
162#
163# This ensures that there are a set order, and you can have ARCH
164# specific patches.
165#
166# If you however give an argument to epatch(), it will treat it as a
167# single patch that need to be applied if its a file. If on the other
168# hand its a directory, it will set EPATCH_SOURCE to this.
169#
170# <azarah@gentoo.org> (10 Nov 2002)
171#
172epatch() { 209epatch() {
173 _epatch_draw_line() { 210 _epatch_draw_line() {
211 # create a line of same length as input string
174 [[ -z $1 ]] && set "$(printf "%65s" '')" 212 [[ -z $1 ]] && set "$(printf "%65s" '')"
175 echo "${1//?/=}" 213 echo "${1//?/=}"
176 } 214 }
177 _epatch_assert() { local _pipestatus=${PIPESTATUS[*]}; [[ ${_pipestatus// /} -eq 0 ]] ; }
178 local PIPE_CMD=""
179 local STDERR_TARGET="${T}/$$.out"
180 local PATCH_TARGET="${T}/$$.patch"
181 local PATCH_SUFFIX=""
182 local SINGLE_PATCH="no"
183 local x=""
184 215
185 unset P4CONFIG P4PORT P4USER # keep perforce at bay #56402 216 unset P4CONFIG P4PORT P4USER # keep perforce at bay #56402
186 217
187 if [ "$#" -gt 1 ] 218 # Let the rest of the code process one user arg at a time --
188 then 219 # each arg may expand into multiple patches, and each arg may
220 # need to start off with the default global EPATCH_xxx values
221 if [[ $# -gt 1 ]] ; then
189 local m="" 222 local m
190 for m in "$@" ; do 223 for m in "$@" ; do
191 epatch "${m}" 224 epatch "${m}"
192 done 225 done
193 return 0 226 return 0
194 fi 227 fi
195 228
196 if [ -n "$1" -a -f "$1" ] 229 local SINGLE_PATCH="no"
197 then 230 # no args means process ${EPATCH_SOURCE}
231 [[ $# -eq 0 ]] && set -- "${EPATCH_SOURCE}"
232
233 if [[ -f $1 ]] ; then
198 SINGLE_PATCH="yes" 234 SINGLE_PATCH="yes"
199 235 set -- "$1"
200 local EPATCH_SOURCE="$1" 236 # Use the suffix from the single patch (localize it); the code
237 # below will find the suffix for us
201 local EPATCH_SUFFIX="${1##*\.}" 238 local EPATCH_SUFFIX=$1
202 239
203 elif [ -n "$1" -a -d "$1" ] 240 elif [[ -d $1 ]] ; then
204 then 241 # Some people like to make dirs of patches w/out suffixes (vim)
205 # Allow no extension if EPATCH_FORCE=yes ... used by vim for example ... 242 set -- "$1"/*${EPATCH_SUFFIX:+."${EPATCH_SUFFIX}"}
206 if [ "${EPATCH_FORCE}" = "yes" ] && [ -z "${EPATCH_SUFFIX}" ] 243
244 else
245 # sanity check ... if it isn't a dir or file, wtf man ?
246 [[ $# -ne 0 ]] && EPATCH_SOURCE=$1
247 echo
248 eerror "Cannot find \$EPATCH_SOURCE! Value for \$EPATCH_SOURCE is:"
249 eerror
250 eerror " ${EPATCH_SOURCE}"
251 eerror " ( ${EPATCH_SOURCE##*/} )"
252 echo
253 die "Cannot find \$EPATCH_SOURCE!"
254 fi
255
256 local PIPE_CMD
257 case ${EPATCH_SUFFIX##*\.} in
258 xz) PIPE_CMD="xz -dc" ;;
259 lzma) PIPE_CMD="lzma -dc" ;;
260 bz2) PIPE_CMD="bzip2 -dc" ;;
261 gz|Z|z) PIPE_CMD="gzip -dc" ;;
262 ZIP|zip) PIPE_CMD="unzip -p" ;;
263 *) ;;
264 esac
265
266 [[ ${SINGLE_PATCH} == "no" ]] && einfo "${EPATCH_MULTI_MSG}"
267
268 local x
269 for x in "$@" ; do
270 # If the patch dir given contains subdirs, or our EPATCH_SUFFIX
271 # didn't match anything, ignore continue on
272 [[ ! -f ${x} ]] && continue
273
274 local patchname=${x##*/}
275
276 # Apply single patches, or forced sets of patches, or
277 # patches with ARCH dependant names.
278 # ???_arch_foo.patch
279 # Else, skip this input altogether
280 local a=${patchname#*_} # strip the ???_
281 a=${a%%_*} # strip the _foo.patch
282 if ! [[ ${SINGLE_PATCH} == "yes" || \
283 ${EPATCH_FORCE} == "yes" || \
284 ${a} == all || \
285 ${a} == ${ARCH} ]]
207 then 286 then
208 local EPATCH_SOURCE="$1/*" 287 continue
288 fi
289
290 # Let people filter things dynamically
291 if [[ -n ${EPATCH_EXCLUDE} ]] ; then
292 # let people use globs in the exclude
293 eshopts_push -o noglob
294
295 local ex
296 for ex in ${EPATCH_EXCLUDE} ; do
297 if [[ ${patchname} == ${ex} ]] ; then
298 eshopts_pop
299 continue 2
300 fi
301 done
302
303 eshopts_pop
304 fi
305
306 if [[ ${SINGLE_PATCH} == "yes" ]] ; then
307 if [[ -n ${EPATCH_SINGLE_MSG} ]] ; then
308 einfo "${EPATCH_SINGLE_MSG}"
309 else
310 einfo "Applying ${patchname} ..."
311 fi
209 else 312 else
210 local EPATCH_SOURCE="$1/*.${EPATCH_SUFFIX}" 313 einfo " ${patchname} ..."
211 fi 314 fi
212 else 315
213 if [[ ! -d ${EPATCH_SOURCE} ]] || [[ -n $1 ]] ; then 316 # most of the time, there will only be one run per unique name,
214 if [ -n "$1" -a "${EPATCH_SOURCE}" = "${WORKDIR}/patch" ] 317 # but if there are more, make sure we get unique log filenames
215 then 318 local STDERR_TARGET="${T}/${patchname}.out"
216 EPATCH_SOURCE="$1" 319 if [[ -e ${STDERR_TARGET} ]] ; then
320 STDERR_TARGET="${T}/${patchname}-$$.out"
321 fi
322
323 printf "***** %s *****\n\n" "${patchname}" > "${STDERR_TARGET}"
324
325 # Decompress the patch if need be
326 local count=0
327 local PATCH_TARGET
328 if [[ -n ${PIPE_CMD} ]] ; then
329 PATCH_TARGET="${T}/$$.patch"
330 echo "PIPE_COMMAND: ${PIPE_CMD} ${x} > ${PATCH_TARGET}" >> "${STDERR_TARGET}"
331
332 if ! (${PIPE_CMD} "${x}" > "${PATCH_TARGET}") >> "${STDERR_TARGET}" 2>&1 ; then
333 echo
334 eerror "Could not extract patch!"
335 #die "Could not extract patch!"
336 count=5
337 break
217 fi 338 fi
339 else
340 PATCH_TARGET=${x}
341 fi
218 342
343 # Check for absolute paths in patches. If sandbox is disabled,
344 # people could (accidently) patch files in the root filesystem.
345 # Or trigger other unpleasantries #237667. So disallow -p0 on
346 # such patches.
347 local abs_paths=$(egrep -n '^[-+]{3} /' "${PATCH_TARGET}" | awk '$2 != "/dev/null" { print }')
348 if [[ -n ${abs_paths} ]] ; then
349 count=1
350 printf "NOTE: skipping -p0 due to absolute paths in patch:\n%s\n" "${abs_paths}" >> "${STDERR_TARGET}"
351 fi
352
353 # Dynamically detect the correct -p# ... i'm lazy, so shoot me :/
354 while [[ ${count} -lt 5 ]] ; do
355 # Generate some useful debug info ...
356 (
357 _epatch_draw_line "***** ${patchname} *****"
219 echo 358 echo
220 eerror "Cannot find \$EPATCH_SOURCE! Value for \$EPATCH_SOURCE is:" 359 echo "PATCH COMMAND: patch -p${count} ${EPATCH_OPTS} < '${PATCH_TARGET}'"
360 echo
361 _epatch_draw_line "***** ${patchname} *****"
362 ) >> "${STDERR_TARGET}"
363
364 if (patch -p${count} ${EPATCH_OPTS} --dry-run -f < "${PATCH_TARGET}") >> "${STDERR_TARGET}" 2>&1 ; then
365 (
366 _epatch_draw_line "***** ${patchname} *****"
367 echo
368 echo "ACTUALLY APPLYING ${patchname} ..."
369 echo
370 _epatch_draw_line "***** ${patchname} *****"
371 patch -p${count} ${EPATCH_OPTS} < "${PATCH_TARGET}" 2>&1
372 ) >> "${STDERR_TARGET}"
373
374 if [ $? -ne 0 ] ; then
375 echo
376 eerror "A dry-run of patch command succeeded, but actually"
377 eerror "applying the patch failed!"
378 #die "Real world sux compared to the dreamworld!"
379 count=5
380 fi
381 break
382 fi
383
384 : $(( count++ ))
385 done
386
387 # if we had to decompress the patch, delete the temp one
388 if [[ -n ${PIPE_CMD} ]] ; then
389 rm -f "${PATCH_TARGET}"
390 fi
391
392 if [[ ${count} -ge 5 ]] ; then
393 echo
394 eerror "Failed Patch: ${patchname} !"
395 eerror " ( ${PATCH_TARGET} )"
221 eerror 396 eerror
222 eerror " ${EPATCH_SOURCE}" 397 eerror "Include in your bugreport the contents of:"
223 eerror " ( ${EPATCH_SOURCE##*/} )" 398 eerror
399 eerror " ${STDERR_TARGET}"
224 echo 400 echo
225 die "Cannot find \$EPATCH_SOURCE!"
226 fi
227
228 local EPATCH_SOURCE="${EPATCH_SOURCE}/*.${EPATCH_SUFFIX}"
229 fi
230
231 case ${EPATCH_SUFFIX##*\.} in
232 xz)
233 PIPE_CMD="xz -dc"
234 PATCH_SUFFIX="xz"
235 ;;
236 lzma)
237 PIPE_CMD="lzma -dc"
238 PATCH_SUFFIX="lzma"
239 ;;
240 bz2)
241 PIPE_CMD="bzip2 -dc"
242 PATCH_SUFFIX="bz2"
243 ;;
244 gz|Z|z)
245 PIPE_CMD="gzip -dc"
246 PATCH_SUFFIX="gz"
247 ;;
248 ZIP|zip)
249 PIPE_CMD="unzip -p"
250 PATCH_SUFFIX="zip"
251 ;;
252 *)
253 PIPE_CMD="cat"
254 PATCH_SUFFIX="patch"
255 ;;
256 esac
257
258 if [ "${SINGLE_PATCH}" = "no" ]
259 then
260 einfo "${EPATCH_MULTI_MSG}"
261 fi
262 for x in ${EPATCH_SOURCE}
263 do
264 # New ARCH dependant patch naming scheme ...
265 #
266 # ???_arch_foo.patch
267 #
268 if [ -f ${x} ] && \
269 ([ "${SINGLE_PATCH}" = "yes" -o "${x/_all_}" != "${x}" -o "${x/_${ARCH}_}" != "${x}" ] || \
270 [ "${EPATCH_FORCE}" = "yes" ])
271 then
272 local count=0
273 local popts="${EPATCH_OPTS}"
274 local patchname=${x##*/}
275
276 if [ -n "${EPATCH_EXCLUDE}" ]
277 then
278 if [ "${EPATCH_EXCLUDE/${patchname}}" != "${EPATCH_EXCLUDE}" ]
279 then
280 continue
281 fi
282 fi
283
284 if [ "${SINGLE_PATCH}" = "yes" ]
285 then
286 if [ -n "${EPATCH_SINGLE_MSG}" ]
287 then
288 einfo "${EPATCH_SINGLE_MSG}"
289 else
290 einfo "Applying ${patchname} ..."
291 fi
292 else
293 einfo " ${patchname} ..."
294 fi
295
296 echo "***** ${patchname} *****" > ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}
297 echo >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}
298
299 # Decompress the patch if need be
300 if [[ ${PATCH_SUFFIX} != "patch" ]] ; then
301 echo -n "PIPE_COMMAND: " >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}
302 echo "${PIPE_CMD} ${x} > ${PATCH_TARGET}" >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}
303
304 if ! (${PIPE_CMD} ${x} > ${PATCH_TARGET}) >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/} 2>&1 ; then
305 echo
306 eerror "Could not extract patch!"
307 #die "Could not extract patch!"
308 count=5
309 break
310 fi
311 else
312 PATCH_TARGET="${x}"
313 fi
314
315 # Check for absolute paths in patches. If sandbox is disabled,
316 # people could (accidently) patch files in the root filesystem.
317 # Or trigger other unpleasantries #237667. So disallow -p0 on
318 # such patches.
319 local abs_paths=$(egrep -n '^[-+]{3} /' "${PATCH_TARGET}" | awk '$2 != "/dev/null" { print }')
320 if [[ -n ${abs_paths} ]] ; then
321 count=1
322 echo "NOTE: skipping -p0 due to absolute paths in patch:" >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}
323 echo "${abs_paths}" >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}
324 fi
325
326 # Allow for prefix to differ ... im lazy, so shoot me :/
327 while [ "${count}" -lt 5 ]
328 do
329 # Generate some useful debug info ...
330 _epatch_draw_line "***** ${patchname} *****" >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}
331 echo >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}
332
333 echo -n "PATCH COMMAND: " >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}
334 echo "patch -p${count} ${popts} < ${PATCH_TARGET}" >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}
335
336 echo >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}
337 _epatch_draw_line "***** ${patchname} *****" >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}
338
339 if (cat ${PATCH_TARGET} | patch -p${count} ${popts} --dry-run -f ; _epatch_assert) >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/} 2>&1
340 then
341 _epatch_draw_line "***** ${patchname} *****" > ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}.real
342 echo >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}.real
343 echo "ACTUALLY APPLYING ${patchname} ..." >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}.real
344 echo >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}.real
345 _epatch_draw_line "***** ${patchname} *****" >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}.real
346
347 cat ${PATCH_TARGET} | patch -p${count} ${popts} >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}.real 2>&1
348 _epatch_assert
349
350 if [ "$?" -ne 0 ]
351 then
352 cat ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}.real >> ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}
353 echo
354 eerror "A dry-run of patch command succeeded, but actually"
355 eerror "applying the patch failed!"
356 #die "Real world sux compared to the dreamworld!"
357 count=5
358 fi
359
360 rm -f ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}.real
361
362 break
363 fi
364
365 count=$((count + 1))
366 done
367
368 if [ "${PATCH_SUFFIX}" != "patch" ]
369 then
370 rm -f ${PATCH_TARGET}
371 fi
372
373 if [ "${count}" -eq 5 ]
374 then
375 echo
376 eerror "Failed Patch: ${patchname} !"
377 eerror " ( ${PATCH_TARGET} )"
378 eerror
379 eerror "Include in your bugreport the contents of:"
380 eerror
381 eerror " ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/}"
382 echo
383 die "Failed Patch: ${patchname}!" 401 die "Failed Patch: ${patchname}!"
384 fi 402 fi
385 403
386 rm -f ${STDERR_TARGET%/*}/${patchname}-${STDERR_TARGET##*/} 404 # if everything worked, delete the patch log
387 405 rm -f "${STDERR_TARGET}"
388 eend 0 406 eend 0
389 fi
390 done 407 done
391 if [ "${SINGLE_PATCH}" = "no" ] 408
392 then 409 [[ ${SINGLE_PATCH} == "no" ]] && einfo "Done with patching"
393 einfo "Done with patching" 410 : # everything worked
394 fi
395} 411}
396epatch_user() { 412epatch_user() {
397 [[ $# -ne 0 ]] && die "epatch_user takes no options" 413 [[ $# -ne 0 ]] && die "epatch_user takes no options"
398 414
399 # don't clobber any EPATCH vars that the parent might want 415 # don't clobber any EPATCH vars that the parent might want
1380 lic="${PWD}/${lic}" 1396 lic="${PWD}/${lic}"
1381 elif [ -e "${lic}" ] ; then 1397 elif [ -e "${lic}" ] ; then
1382 lic="${lic}" 1398 lic="${lic}"
1383 fi 1399 fi
1384 fi 1400 fi
1385 [ ! -f "${lic}" ] && die "Could not find requested license ${lic}"
1386 local l="`basename ${lic}`" 1401 local l="`basename ${lic}`"
1387 1402
1388 # here is where we check for the licenses the user already 1403 # here is where we check for the licenses the user already
1389 # accepted ... if we don't find a match, we make the user accept 1404 # accepted ... if we don't find a match, we make the user accept
1390 local alic 1405 local alic
1394 eshopts_pop 1409 eshopts_pop
1395 return 0 1410 return 0
1396 fi 1411 fi
1397 done 1412 done
1398 eshopts_pop 1413 eshopts_pop
1414 [ ! -f "${lic}" ] && die "Could not find requested license ${lic}"
1399 1415
1400 local licmsg=$(emktemp) 1416 local licmsg=$(emktemp)
1401 cat <<-EOF > ${licmsg} 1417 cat <<-EOF > ${licmsg}
1402 ********************************************************** 1418 **********************************************************
1403 The following license outlines the terms of use of this 1419 The following license outlines the terms of use of this
1754} 1770}
1755 1771
1756# @FUNCTION: built_with_use 1772# @FUNCTION: built_with_use
1757# @USAGE: [--hidden] [--missing <action>] [-a|-o] <DEPEND ATOM> <List of USE flags> 1773# @USAGE: [--hidden] [--missing <action>] [-a|-o] <DEPEND ATOM> <List of USE flags>
1758# @DESCRIPTION: 1774# @DESCRIPTION:
1775#
1776# Deprecated: Use EAPI 2 use deps in DEPEND|RDEPEND and with has_version calls.
1777#
1759# A temporary hack until portage properly supports DEPENDing on USE 1778# A temporary hack until portage properly supports DEPENDing on USE
1760# flags being enabled in packages. This will check to see if the specified 1779# flags being enabled in packages. This will check to see if the specified
1761# DEPEND atom was built with the specified list of USE flags. The 1780# DEPEND atom was built with the specified list of USE flags. The
1762# --missing option controls the behavior if called on a package that does 1781# --missing option controls the behavior if called on a package that does
1763# not actually support the defined USE flags (aka listed in IUSE). 1782# not actually support the defined USE flags (aka listed in IUSE).

Legend:
Removed from v.1.323  
changed lines
  Added in v.1.332

  ViewVC Help
Powered by ViewVC 1.1.20