#!/bin/bash

# Copyright 1999-2006 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

source "${PORTAGE_BIN_PATH:-/usr/lib/portage/bin}"/isolated-functions.sh

if [[ $# -lt 1 ]] ; then

	die "$0: at least one argument needed"

	exit 1

fi

if [[ ! -d ${D}${DESTTREE}/bin ]] ; then

	install -d "${D}${DESTTREE}/bin" || { die "$0 failed to install ${D}${DESTTREE}/bin"; exit 2; }

fi

ret=0

for x in "$@" ; do

	if [[ -e ${x} ]] ; then

		install -m0755 -o ${PORTAGE_INST_UID:-0} -g ${PORTAGE_INST_GID:-0} "${x}" "${D}${DESTTREE}/bin"

	else

		echo "!!! ${0##*/}: $x does not exist" 1>&2

		false

	fi

	((ret|=$?))

done

[[ $ret -ne 0 ]] && die "$0 failed"

exit ${ret}

#!/bin/bash

# Copyright 1999-2006 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

if [[ $# -lt 1 ]] ; then

	die "$0: at least one argument needed"

	exit 1

fi

exec \

env \

INSDESTTREE="/etc/conf.d/" \

doins "$@"

#!/bin/bash

# Copyright 1999-2006 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

install -d ${DIROPTIONS} "${@/#/${D}/}"

ret=$?

[[ $ret -ne 0 ]] && die "$0 failed"

exit $?

[[ $ret -ne 0 ]] && die "$0 failed"

#!/bin/bash

# Copyright 1999-2006 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

if [[ $# -lt 1 ]] ; then

	die "$0: at least one argument needed"

	exit 1

fi

exec \

env \

INSDESTTREE="/etc/env.d/" \

doins "$@"

#!/bin/bash

# Copyright 1999-2007 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

source "${PORTAGE_BIN_PATH:-/usr/lib/portage/bin}"/isolated-functions.sh

if [[ $# -lt 1 ]] ; then

	die "$0: at least one argument needed"

	exit 1

fi

if [[ ! -d ${D}${_E_EXEDESTTREE_} ]] ; then

	install -d "${D}${_E_EXEDESTTREE_}"

fi

TMP=$T/.doexe_tmp

mkdir "$TMP"

ret=0

for x in "$@" ; do

	if [ -L "${x}" ] ; then

		cp "$x" "$TMP"

		mysrc=$TMP/${x##*/}

	elif [ -d "${x}" ] ; then

		vecho "doexe: warning, skipping directory ${x}"

		continue

	else

		mysrc="${x}"

	fi

	if [ -e "$mysrc" ] ; then

		install $EXEOPTIONS "$mysrc" "$D$_E_EXEDESTTREE_"

	else

		echo "!!! ${0##*/}: $mysrc does not exist" 1>&2

		false

	fi

	((ret|=$?))

done

rm -rf "$TMP"

[[ $ret -ne 0 ]] && die "$0 failed"

exit $ret

#!/bin/bash

# Copyright 2009 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

PORTAGE_BIN_PATH=${PORTAGE_BIN_PATH:-/usr/lib/portage/bin}

PORTAGE_PYM_PATH=${PORTAGE_PYM_PATH:-/usr/lib/portage/pym}

# Set EPYTHON variable as empty so that dohtml doesn't try

# to use potentially unsupported version of Python.

EPYTHON= PYTHONPATH=$PORTAGE_PYM_PATH${PYTHONPATH:+:}$PYTHONPATH \

	"$PORTAGE_BIN_PATH/dohtml.py" "$@"

ret=$?

[[ $ret -ne 0 ]] && die "$0 failed"

exit $?

#!/bin/bash

# Copyright 1999-2010 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

source "${PORTAGE_BIN_PATH:-/usr/lib/portage/bin}"/isolated-functions.sh

if [[ -z $1 ]] ; then

	die "$0: at least one argument needed"

	exit 1

fi

if [[ ! -d ${D}usr/share/info ]] ; then

	install -d "${D}usr/share/info" || { die "$0: failed to install ${D}usr/share/info"; exit 1; }

fi

install -m0644 "$@" "${D}usr/share/info"

rval=$?

if [ $rval -ne 0 ] ; then

	for x in "$@" ; do

		[ -e "$x" ] || echo "!!! ${0##*/}: $x does not exist" 1>&2

	done

fi

[[ $rval -ne 0 ]] && die "$0 failed"

exit $rval

#!/bin/bash

# Copyright 1999-2007 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

if [[ $# -lt 1 ]] ; then

	die "$0: at least one argument needed"

	exit 1

fi

exec \

env \

_E_EXEDESTTREE_="/etc/init.d/" \

doexe "$@"

#!/bin/bash

# Copyright 1999-2009 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

source "${PORTAGE_BIN_PATH:-/usr/lib/portage/bin}"/isolated-functions.sh

if [ $# -lt 1 ] ; then

	die "${0##*/}: at least one argument needed"

	exit 1

fi

if [[ "$1" == "-r" ]] ; then

	DOINSRECUR=y

	shift

else

	DOINSRECUR=n

fi

if [[ ${INSDESTTREE#${D}} != "${INSDESTTREE}" ]]; then

	vecho "-------------------------------------------------------" 1>&2

	vecho "You should not use \${D} with helpers." 1>&2

	vecho "  --> ${INSDESTTREE}" 1>&2

	vecho "-------------------------------------------------------" 1>&2

	die "$0: \${D} used with helpers"

	exit 1

fi

case "$EAPI" in

	0|1|2|3|3_pre2)

		PRESERVE_SYMLINKS=n

		;;

	*)

		PRESERVE_SYMLINKS=y

		;;

esac

export TMP=$T/.doins_tmp

# Use separate directories to avoid potential name collisions.

mkdir -p "$TMP"/{1,2}

[[ ! -d ${D}${INSDESTTREE} ]] && dodir "${INSDESTTREE}"

_doins() {

	local mysrc="$1" mydir="$2" cleanup="" rval

	if [ -L "$mysrc" ] ; then

		if [ $PRESERVE_SYMLINKS = y ] ; then

			rm -rf "$D$INSDESTTREE/$mydir/${mysrc##*/}" || return $?

			cp -P "$mysrc" "$D$INSDESTTREE/$mydir/${mysrc##*/}"

			return $?

		else

			cp "$mysrc" "$TMP/2/${mysrc##*/}" || return $?

			mysrc="$TMP/2/${mysrc##*/}"

			cleanup=$mysrc

		fi

	fi

	install ${INSOPTIONS} "${mysrc}" "${D}${INSDESTTREE}/${mydir}"

	rval=$?

	[[ -n ${cleanup} ]] && rm -f "${cleanup}"

	[ $rval -ne 0 ] && echo "!!! ${0##*/}: $mysrc does not exist" 1>&2

	return $rval

}

_xdoins() {

	local -i failed=0

	while read -d $'\0' x ; do

		_doins "$x" "${x%/*}"

		((failed|=$?))

	done

	return $failed

}

success=0

failed=0

for x in "$@" ; do

	if [[ $PRESERVE_SYMLINKS = n && -d $x ]] || \

		[[ $PRESERVE_SYMLINKS = y && -d $x && ! -L $x ]] ; then

		if [ "${DOINSRECUR}" == "n" ] ; then

			continue

		fi

		while [ "$x" != "${x%/}" ] ; do

			x=${x%/}

		done

		if [ "$x" = "${x%/*}" ] ; then

			pushd "$PWD" >/dev/null

		else

			pushd "${x%/*}" >/dev/null

		fi

		x=${x##*/}

		x_orig=$x

		# Follow any symlinks recursively until we've got

		# a normal directory for 'find' to traverse.

		while [ -L "$x" ] ; do

			pushd "$(readlink "$x")" >/dev/null

			x=${PWD##*/}

			pushd "${PWD%/*}" >/dev/null

		done

		if [[ $x != $x_orig ]] ; then

			mv "$x" "$TMP/1/$x_orig"

			pushd "$TMP/1" >/dev/null

		fi

		find "$x_orig" -type d -exec dodir "${INSDESTTREE}/{}" \;

		find "$x_orig" \( -type f -or -type l \) -print0 | _xdoins

		if [[ ${PIPESTATUS[1]} -eq 0 ]] ; then

			# NOTE: Even if only an empty directory is installed here, it

			# still counts as success, since an empty directory given as

			# an argument to doins -r should not trigger failure.

			((success|=1))

		else

			((failed|=1))

		fi

		if [[ $x != $x_orig ]] ; then

			popd >/dev/null

			mv "$TMP/1/$x_orig" "$x"

		fi

		while popd >/dev/null 2>&1 ; do true ; done

	else

		_doins "${x}"

		if [[ $? -eq 0 ]] ; then

			((success|=1))

		else

			((failed|=1))

		fi

	fi

done

rm -rf "$TMP"

[[ $failed -ne 0 || $success -eq 0 ]] && { die "$0 failed"; exit 1; } || exit 0

#!/bin/bash

# Copyright 1999-2006 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

# Setup ABI cruft

LIBDIR_VAR="LIBDIR_${ABI}"

if [[ -n ${ABI} && -n ${!LIBDIR_VAR} ]] ; then

	CONF_LIBDIR=${!LIBDIR_VAR}

fi

unset LIBDIR_VAR

# we need this to default to lib so that things dont break

CONF_LIBDIR=${CONF_LIBDIR:-lib}

libdir="${D}${DESTTREE}/${CONF_LIBDIR}"

if [[ $# -lt 1 ]] ; then

	die "$0: at least one argument needed"

	exit 1

fi

if [[ ! -d ${libdir} ]] ; then

	install -d "${libdir}" || { die "$0 failed to install ${libdir}"; exit 1; }

fi

ret=0

for x in "$@" ; do

	if [[ -e ${x} ]] ; then

		if [[ ! -L ${x} ]] ; then

			install ${LIBOPTIONS} "${x}" "${libdir}"

		else

			ln -s "$(readlink "${x}")" "${libdir}/${x##*/}"

		fi

	else

		echo "!!! ${0##*/}: ${x} does not exist" 1>&2

		false

	fi

	((ret|=$?))

done

[[ $ret -ne 0 ]] && die "$0 failed"

exit ${ret}

#!/bin/bash

# Copyright 1999-2006 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

source "${PORTAGE_BIN_PATH:-/usr/lib/portage/bin}"/isolated-functions.sh

if [[ $# -lt 1 ]] ; then

	die "$0: at least one argument needed"

	exit 1

fi

i18n=""

ret=0

for x in "$@" ; do

	if [[ ${x:0:6} == "-i18n=" ]] ; then

		i18n=${x:6}/

		continue

	fi

	if [[ ${x:0:6} == ".keep_" ]] ; then

		continue

	fi

	suffix=${x##*.}

	# These will be automatically decompressed by ecompressdir.

	if hasq ${suffix} Z gz bz2 ; then

		realname=${x%.*}

		suffix=${realname##*.}

	fi

	if hasq "${EAPI:-0}" 2 3 || [[ -z ${i18n} ]] \

		&& ! hasq "${EAPI:-0}" 0 1 \

		&& [[ $x =~ (.*)\.([a-z][a-z](_[A-Z][A-Z])?)\.(.*) ]]

	then

		name=${BASH_REMATCH[1]##*/}.${BASH_REMATCH[4]}

		mandir=${BASH_REMATCH[2]}/man${suffix:0:1}

	else

		name=${x##*/}

		mandir=${i18n#/}man${suffix:0:1}

	fi

	if [[ ${mandir} =~ man[0-9n](f|p|pm)?$ ]] ; then

		if [[ -s ${x} ]] ; then

			if [[ ! -d ${D}/usr/share/man/${mandir} ]] ; then

				install -d "${D}/usr/share/man/${mandir}"

			fi

			install -m0644 "${x}" "${D}/usr/share/man/${mandir}/${name}"

			((ret|=$?))

		elif [[ ! -e ${x} ]] ; then

			echo "!!! ${0##*/}: $x does not exist" 1>&2

			((ret|=1))

		fi

	else

		vecho "doman: '${x}' is probably not a man page; skipping" 1>&2

		((ret|=1))

	fi

done

[[ $ret -ne 0 ]] && die "$0 failed"

exit ${ret}

#!/bin/bash

# Copyright 1999-2006 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

mynum=${#}

if [ ${mynum} -lt 1 ] ; then

	die "$0: at least one argument needed"

	exit 1

fi

if [ ! -d "${D}${DESTTREE}/share/locale" ] ; then

	install -d "${D}${DESTTREE}/share/locale/"

fi

ret=0

for x in "$@" ; do

	if [ -e "${x}" ] ; then

		mytiny="${x##*/}"

		mydir="${D}${DESTTREE}/share/locale/${mytiny%.*}/LC_MESSAGES"

		if [ ! -d "${mydir}" ] ; then

			install -d "${mydir}"

		fi

		install -m0644 "${x}" "${mydir}/${MOPREFIX}.mo"

	else

		echo "!!! ${0##*/}: $x does not exist" 1>&2

		false

	fi

	((ret|=$?))

done

[[ $ret -ne 0 ]] && die "$0 failed"

exit $ret

#!/bin/bash

# Copyright 1999-2006 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

if [[ $# -lt 1 ]] ; then

	die "$0: at least one argument needed"

	exit 1

fi

if [[ ! -d ${D}${DESTTREE}/sbin ]] ; then

	install -d "${D}${DESTTREE}/sbin" || { die "$0 failed to install ${D}${DESTTREE}/sbin"; exit 2; }

fi

ret=0

for x in "$@" ; do

	if [[ -e ${x} ]] ; then

		install -m0755 -o ${PORTAGE_INST_UID:-0} -g ${PORTAGE_INST_GID:-0} "${x}" "${D}${DESTTREE}/sbin"

	else

		echo "!!! ${0##*/}: ${x} does not exist" 1>&2

		false

	fi

	((ret|=$?))

done

[[ $ret -ne 0 ]] && die "$0 failed"

exit ${ret}

#!/bin/bash

# Copyright 1999-2006 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

if [[ $# -ne 2 ]] ; then

	die "$0: two arguments needed"

	exit 1

fi

destdir=${2%/*}

[[ ! -d ${D}${destdir} ]] && dodir "${destdir}"

exec ln -snf "$1" "${D}$2"

#!/bin/bash

# Copyright 1999-2007 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

source "${PORTAGE_BIN_PATH:-/usr/lib/portage/bin}"/isolated-functions.sh

if [[ -z $1 ]] ; then

	die "${0##*/}: at least one argument needed"

	exit 1

fi

# setup compression stuff

PORTAGE_COMPRESS=${PORTAGE_COMPRESS-bzip2}

[[ -z ${PORTAGE_COMPRESS} ]] && exit 0

if [[ ${PORTAGE_COMPRESS_FLAGS+set} != "set" ]] ; then

	case ${PORTAGE_COMPRESS} in

		bzip2|gzip)  PORTAGE_COMPRESS_FLAGS="-9";;

	esac

fi

# decompress_args(suffix, binary)

#	- suffix: the compression suffix to work with

#	- binary: the program to execute that'll compress/decompress

# new_args: global array used to return revised arguments

decompress_args() {

	local suffix=$1 binary=$2

	shift 2

	# Initialize the global new_args array.

	new_args=()

	declare -a decompress_args=()

	local x i=0 decompress_count=0

	for x in "$@" ; do

		if [[ ${x%$suffix} = $x ]] ; then

			new_args[$i]=$x

		else

			new_args[$i]=${x%$suffix}

			decompress_args[$decompress_count]=$x

			((decompress_count++))

		fi

		((i++))

	done

	if [ $decompress_count -gt 0 ] ; then

		${binary} "${decompress_args[@]}"

		if [ $? -ne 0 ] ; then

			# Apparently decompression failed for one or more files, so

			# drop those since we don't want to compress them twice.

			new_args=()

			local x i=0

			for x in "$@" ; do

				if [[ ${x%$suffix} = $x ]] ; then

					new_args[$i]=$x

					((i++))

				elif [[ -f ${x%$suffix} ]] ; then

					new_args[$i]=${x%$suffix}

					((i++))

				else

					# Apparently decompression failed for this one, so drop

					# it since we don't want to compress it twice.

					true

				fi

			done

		fi

	fi

}

case $1 in

	--suffix)

		[[ -n $2 ]] && vecho "${0##*/}: --suffix takes no additional arguments" 1>&2

		if [[ ! -e ${T}/.ecompress.suffix ]] ; then

			set -e

			tmpdir="${T}"/.ecompress$$.${RANDOM}

			mkdir "${tmpdir}"

			cd "${tmpdir}"

			# we have to fill the file enough so that there is something

			# to compress as some programs will refuse to do compression

			# if it cannot actually compress the file

			echo {0..1000} > compressme

			${PORTAGE_COMPRESS} ${PORTAGE_COMPRESS_FLAGS} compressme > /dev/null

			suffix=$(ls compressme*)

			suffix=${suffix#compressme}

			cd /

			rm -rf "${tmpdir}"

			echo "${suffix}" > "${T}/.ecompress.suffix"

		fi

		cat "${T}/.ecompress.suffix"

		;;

	--bin)

		[[ -n $2 ]] && vecho "${0##*/}: --bin takes no additional arguments" 1>&2

		echo "${PORTAGE_COMPRESS} ${PORTAGE_COMPRESS_FLAGS}"

		;;

	--queue)

		shift

		touch "${@/%/.ecompress.file}"

		ret=$?

		[[ $ret -ne 0 ]] && die "$0 failed"

		exit $ret

		;;

	--dequeue)

		[[ -n $2 ]] && vecho "${0##*/}: --dequeue takes no additional arguments" 1>&2

		find "${D}" -name '*.ecompress.file' -print0 \

			| sed -e 's:\.ecompress\.file::g' \

			| ${XARGS} -0 ecompress

		find "${D}" -name '*.ecompress.file' -print0 | ${XARGS} -0 rm -f

		;;

	--*)

		die "${0##*/}: unknown arguments '$*'"

		exit 1

		;;

	*)

		# Since dodoc calls ecompress on files that are already compressed,

		# perform decompression here (similar to ecompressdir behavior).

		decompress_args ".Z" "gunzip -f" "$@"

		set -- "${new_args[@]}"

		decompress_args ".gz" "gunzip -f" "$@"

		set -- "${new_args[@]}"

		decompress_args ".bz2" "bunzip2 -f" "$@"

		set -- "${new_args[@]}"

		mask_ext_re=""

		set -f

		for x in $PORTAGE_COMPRESS_EXCLUDE_SUFFIXES ; do

			mask_ext_re+="|$x"

		done

		set +f

		mask_ext_re="^(${mask_ext_re:1})\$"

		declare -a filtered_args=()

		i=0

		for x in "$@" ; do

			[[ ${x##*.} =~ $mask_ext_re ]] && continue

			filtered_args[$i]=$x

			((i++))

		done

		[ $i -eq 0 ] && exit 0

		set -- "${filtered_args[@]}"

		# If a compressed version of the file already exists, simply

		# delete it so that the compressor doesn't whine (bzip2 will

		# complain and skip, gzip will prompt for input)

		suffix=$(ecompress --suffix)

		[[ -n ${suffix} ]] && echo -n "${@/%/${suffix}$'\001'}" | \

			tr '\001' '\000' | ${XARGS} -0 rm -f

		# Finally, let's actually do some real work

		"${PORTAGE_COMPRESS}" ${PORTAGE_COMPRESS_FLAGS} "$@"

		ret=$?

		[[ $ret -ne 0 ]] && die "$0 failed"

		exit $ret

		;;

esac

#!/bin/bash

# Copyright 1999-2007 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

source "${PORTAGE_BIN_PATH:-/usr/lib/portage/bin}"/isolated-functions.sh

if [[ -z $1 ]] ; then

	die "${0##*/}: at least one argument needed"

	exit 1

fi

case $1 in

	--ignore)

		shift

		for skip in "$@" ; do

			[[ -d ${D}${skip} ]] && touch "${D}${skip}.ecompress.skip"

		done

		exit 0

		;;

	--queue)

		shift

		set -- "${@/%/.ecompress.dir}"

		set -- "${@/#/${D}}"

		touch "$@"

		ret=$?

		[[ $ret -ne 0 ]] && die "$0 failed"

		exit $ret

		;;

	--dequeue)

		[[ -n $2 ]] && vecho "${0##*/}: --dequeue takes no additional arguments" 1>&2

		find "${D}" -name '*.ecompress.dir' -print0 \

			| sed -e 's:\.ecompress\.dir::g' -e "s:${D}:/:g" \

			| ${XARGS} -0 ecompressdir

		find "${D}" -name '*.ecompress.skip' -print0 | ${XARGS} -0 rm -f

		exit 0

		;;

	--*)

		die "${0##*/}: unknown arguments '$*'"

		exit 1

		;;

esac

# figure out the new suffix

suffix=$(ecompress --suffix)

# funk_up_dir(action, suffix, binary)

#	- action: compress or decompress

#	- suffix: the compression suffix to work with

#	- binary: the program to execute that'll compress/decompress

# The directory we act on is implied in the ${dir} variable

funk_up_dir() {

	local act=$1 suffix=$2 binary=$3

	local negate=""

	[[ ${act} == "compress" ]] && negate="!"

	# first we act on all the files

	find "${dir}" -type f ${negate} -iname '*'${suffix} -print0 | ${XARGS} -0 ${binary}

	((ret|=$?))

	find "${dir}" -type l -print0 | \

	while read -d $'\0' brokenlink ; do

		[[ -e ${brokenlink} ]] && continue

		olddest=$(readlink "${brokenlink}")

		[[ ${act} == "compress" ]] \

			&& newdest="${olddest}${suffix}" \

			|| newdest="${olddest%${suffix}}"

		rm -f "${brokenlink}"

		[[ ${act} == "compress" ]] \

			&& ln -snf "${newdest}" "${brokenlink}${suffix}" \

			|| ln -snf "${newdest}" "${brokenlink%${suffix}}"

		((ret|=$?))

	done

}

# _relocate_skip_dirs(srctree, dsttree)

# Move all the directories we want to skip running compression

# on from srctree to dsttree.

_relocate_skip_dirs() {

	local srctree="$1" dsttree="$2"

	[[ -d ${srctree} ]] || return 0

	find "${srctree}" -name '*.ecompress.skip' -print0 | \

	while read -d $'\0' src ; do

		src=${src%.ecompress.skip}

		dst="${dsttree}${src#${srctree}}"

		parent=${dst%/*}

		mkdir -p "${parent}"

		mv "${src}" "${dst}"

		mv "${src}.ecompress.skip" "${dst}.ecompress.skip"

	done

}

hide_skip_dirs()    { _relocate_skip_dirs "${D}" "${T}"/ecompress-skip/ ; }

restore_skip_dirs() { _relocate_skip_dirs "${T}"/ecompress-skip/ "${D}" ; }

ret=0

rm -rf "${T}"/ecompress-skip

for dir in "$@" ; do

	dir=${dir#/}

	dir="${D}${dir}"

	if [[ ! -d ${dir} ]] ; then

		vecho "${0##*/}: /${dir#${D}} does not exist!"

		continue

	fi

	cd "${dir}"

	actual_dir=${dir}

	dir=. # use relative path to avoid 'Argument list too long' errors

	# hide all the stuff we want to skip

	hide_skip_dirs "${dir}"

	# since we've been requested to compress the whole dir,

	# delete any individual queued requests

	rm -f "${actual_dir}.ecompress.dir"

	find "${dir}" -type f -name '*.ecompress.file' -print0 | ${XARGS} -0 rm -f

	# not uncommon for packages to compress doc files themselves

	funk_up_dir "decompress" ".Z" "gunzip -f"

	funk_up_dir "decompress" ".gz" "gunzip -f"

	funk_up_dir "decompress" ".bz2" "bunzip2 -f"

	# forcibly break all hard links as some compressors whine about it

	find "${dir}" -type f -links +1 -exec env file="{}" sh -c \

		'cp -p "${file}" "${file}.ecompress.break" ; mv -f "${file}.ecompress.break" "${file}"' \;

	# now lets do our work

	[[ -z ${suffix} ]] && continue

	vecho "${0##*/}: $(ecompress --bin) /${actual_dir#${D}}"

	funk_up_dir "compress" "${suffix}" "ecompress"

	# finally, restore the skipped stuff

	restore_skip_dirs

done

[[ $ret -ne 0 ]] && die "$0 failed"

exit ${ret}

#!/bin/bash

# Copyright 1999-2007 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

# we can't prefix all arguments because

# chown takes random options

slash="/"

chown "${@/#${slash}/${D}${slash}}"

ret=$?

[[ $ret -ne 0 ]] && die "$0 failed"

exit $ret

#!/bin/bash

# Copyright 1999-2007 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

# we can't prefix all arguments because

# chmod takes random options

slash="/"

chmod "${@/#${slash}/${D}${slash}}"

ret=$?

[[ $ret -ne 0 ]] && die "$0 failed"

exit $ret

#!/bin/bash

# Copyright 1999-2006 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

if [[ -z ${T} ]] || [[ -z ${2} ]] ; then

	die "$0: Need two arguments, old file and new file"

	exit 1

fi

if [ ! -e "$1" ] ; then

	die "!!! ${0##*/}: $1 does not exist"

	exit 1

fi

rm -rf "${T}/${2}" && \

cp -f "${1}" "${T}/${2}" && \

exec dobin "${T}/${2}"

#!/bin/bash

# Copyright 1999-2006 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

if [[ -z ${T} ]] || [[ -z ${2} ]] ; then

	die "$0: Need two arguments, old file and new file"

	exit 1

fi

if [ ! -e "$1" ] ; then

	die "!!! ${0##*/}: $1 does not exist"

	exit 1

fi

rm -rf "${T}/${2}" && \

cp -f "${1}" "${T}/${2}" && \

exec doconfd "${T}/${2}"

#!/bin/bash

# Copyright 1999-2006 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

if [[ -z ${T} ]] || [[ -z ${2} ]] ; then

	die "$0: Need two arguments, old file and new file"

	exit 1

fi

if [ ! -e "$1" ] ; then

	die "!!! ${0##*/}: $1 does not exist"

	exit 1

fi

rm -rf "${T}/${2}" && \

cp -f "${1}" "${T}/${2}" && \

exec dodoc "${T}/${2}"

#!/bin/bash

# Copyright 1999-2006 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

if [[ -z ${T} ]] || [[ -z ${2} ]] ; then

	die "$0: Need two arguments, old file and new file"

	exit 1

fi

if [ ! -e "$1" ] ; then

	die "!!! ${0##*/}: $1 does not exist"

	exit 1

fi

rm -rf "${T}/${2}" && \

cp -f "${1}" "${T}/${2}" && \

exec doenvd "${T}/${2}"

#!/bin/bash

# Copyright 1999-2006 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

if [[ -z ${T} ]] || [[ -z ${2} ]] ; then

	die "$0: Need two arguments, old file and new file"

	exit 1

fi

if [ ! -e "$1" ] ; then

	die "!!! ${0##*/}: $1 does not exist"

	exit 1

fi

rm -rf "${T}/${2}" && \

cp -f "${1}" "${T}/${2}" && \

exec doexe "${T}/${2}"

#!/bin/bash

# Copyright 1999-2006 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

if [[ -z ${T} ]] || [[ -z ${2} ]] ; then

	die "$0: Need two arguments, old file and new file"

	exit 1

fi

if [ ! -e "$1" ] ; then

	die "!!! ${0##*/}: $1 does not exist"

	exit 1

fi

rm -rf "${T}/${2}" && \

cp -f "${1}" "${T}/${2}" && \

exec doinitd "${T}/${2}"

#!/bin/bash

# Copyright 1999-2009 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

if [[ -z ${T} ]] || [[ -z ${2} ]] ; then

	die "$0: Need two arguments, old file and new file"

	exit 1

fi

if [ ! -e "$1" ] ; then

	die "!!! ${0##*/}: $1 does not exist"

	exit 1

fi

rm -rf "${T}/${2}" || { ret=$?; die "$0 failed"; exit $ret; }

cp -P "$1" "$T/$2" || { ret=$?; die "$0 failed"; exit $ret; }

doins "${T}/${2}"

ret=$?

rm -rf "${T}/${2}"

[[ $ret -ne 0 ]] && die "$0 failed"

exit $ret

#!/bin/bash

# Copyright 1999-2006 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

if [[ -z ${T} ]] || [[ -z ${2} ]] ; then

	die "$0: Need two arguments, old file and new file"

	exit 1

fi

if [ ! -e "$1" ] ; then

	die "!!! ${0##*/}: $1 does not exist"

	exit 1

fi

rm -rf "${T}/${2}" && \

cp -f "${1}" "${T}/${2}" && \

exec dolib.a "${T}/${2}"

#!/bin/bash

# Copyright 1999-2006 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

if [[ -z ${T} ]] || [[ -z ${2} ]] ; then

	die "$0: Need two arguments, old file and new file"

	exit 1

fi

if [ ! -e "$1" ] ; then

	die "!!! ${0##*/}: $1 does not exist"

	exit 1

fi

rm -rf "${T}/${2}" && \

cp -f "${1}" "${T}/${2}" && \

exec dolib.so "${T}/${2}"

#!/bin/bash

# Copyright 1999-2006 Gentoo Foundation

# Distributed under the terms of the GNU General Public License v2

if [[ -z ${T} ]] || [[ -z ${2} ]] ; then

	die "$0: Need two arguments, old file and new file"

	exit 1

fi

if [ ! -e "$1" ] ; then

	die "!!! ${0##*/}: $1 does not exist"

	exit 1

fi

rm -rf "${T}/${2}" && \

cp -f "${1}" "${T}/${2}" && \

exec doman "${T}/${2}"