#!/bin/bash -e

#

# makepkg - make packages compatible for use with pacman

# Generated from makepkg.in; do not edit by hand.

#

# Copyright (c) 2006-2009 Pacman Development Team <pacman-dev@archlinux.org>

# Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>

# Copyright (c) 2005 by Aurelien Foret <orelien@chez.com>

# Copyright (c) 2006 by Miklos Vajna <vmiklos@frugalware.org>

# Copyright (c) 2005 by Christian Hamar <krics@linuxforum.hu>

# Copyright (c) 2006 by Alex Smith <alex@alex-smith.me.uk>

# Copyright (c) 2006 by Andras Voroskoi <voroskoi@frugalware.org>

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program. If not, see <http://www.gnu.org/licenses/>.

#

# makepkg uses quite a few external programs during its execution. You

# need to have at least the following installed for makepkg to function:

# bsdtar (libarchive), bzip2, coreutils, fakeroot, find (findutils),

# getopt (util-linux), gettext, grep, gzip, openssl, sed, tput (ncurses)

# gettext initialization

export TEXTDOMAIN='pacman'

export TEXTDOMAINDIR='/usr/share/locale'

# file -i does not work on Mac OSX unless legacy mode is set

export COMMAND_MODE='legacy'

myver='3.3.3'

confdir='/etc'

BUILDSCRIPT='PKGBUILD'

startdir="$PWD"

srcdir="$startdir/src"

pkgdir="$startdir/pkg"

packaging_options=('strip' 'docs' 'libtool' 'emptydirs' 'zipman' 'purge')

other_options=('ccache' 'distcc' 'makeflags' 'force')

splitpkg_overrides=('pkgver' 'pkgrel' 'pkgdesc' 'arch' 'license' 'groups' \

'depends' 'optdepends' 'provides' 'conflicts' 'replaces' \

'backup' 'options' 'install' 'changelog')

readonly -a packaging_options other_options splitpkg_overrides

# Options

ASROOT=0

CLEANUP=0

CLEANCACHE=0

DEP_BIN=0

FORCE=0

INFAKEROOT=0

GENINTEG=0

SKIPINTEG=0

INSTALL=0

NOBUILD=0

NODEPS=0

NOEXTRACT=0

RMDEPS=0

REPKG=0

LOGGING=0

SOURCEONLY=0

IGNOREARCH=0

HOLDVER=0

BUILDFUNC=0

PKGFUNC=0

SPLITPKG=0

PKGLIST=""

# Forces the pkgver of the current PKGBUILD. Used by the fakeroot call

# when dealing with svn/cvs/etc PKGBUILDs.

FORCE_VER=""

PACMAN_OPTS=

### SUBROUTINES ###

plain() {

local mesg=$1; shift

printf "${BOLD} ${mesg}${ALL_OFF}\n" "$@" >&2

}

msg() {

local mesg=$1; shift

printf "${GREEN}==>${ALL_OFF}${BOLD} ${mesg}${ALL_OFF}\n" "$@" >&2

}

msg2() {

local mesg=$1; shift

printf "${BLUE} ->${ALL_OFF}${BOLD} ${mesg}${ALL_OFF}\n" "$@" >&2

}

warning() {

local mesg=$1; shift

printf "${YELLOW}==> $(gettext "WARNING:")${ALL_OFF}${BOLD} ${mesg}${ALL_OFF}\n" "$@" >&2

}

error() {

local mesg=$1; shift

printf "${RED}==> $(gettext "ERROR:")${ALL_OFF}${BOLD} ${mesg}${ALL_OFF}\n" "$@" >&2

}

##

# Special exit call for traps, Don't print any error messages when inside,

# the fakeroot call, the error message will be printed by the main call.

##

trap_exit() {

if (( ! INFAKEROOT )); then

echo

error "$@"

fi

[[ -n $srclinks ]] && rm -rf "$srclinks"

exit 1

}

##

# Clean up function. Called automatically when the script exits.

##

clean_up() {

local EXIT_CODE=$?

if (( INFAKEROOT )); then

# Don't clean up when leaving fakeroot, we're not done yet.

return

fi

if (( ! EXIT_CODE && CLEANUP )); then

# If it's a clean exit and -c/--clean has been passed...

msg "$(gettext "Cleaning up...")"

rm -rf "$pkgdir" "$srcdir"

if [[ -n $pkgbase ]]; then

# Can't do this unless the BUILDSCRIPT has been sourced.

if (( BUILDFUNC )); then

rm -f "${pkgbase}-${pkgver}-${pkgrel}-${CARCH}-build.log"*

fi

if (( PKGFUNC )); then

rm -f "${pkgbase}-${pkgver}-${pkgrel}-${CARCH}-package.log"*

elif (( SPLITPKG )); then

for pkg in ${pkgname[@]}; do

rm -f "${pkgbase}-${pkgver}-${pkgrel}-${CARCH}-package_${pkg}.log"*

done

fi

# clean up dangling symlinks to packages

for pkg in ${pkgname[@]}; do

for file in ${pkg}-*-*-${CARCH}${PKGEXT}; do

if [[ -h $file && ! -e $file ]]; then

rm -f $file

fi

done

done

fi

fi

remove_deps

}

##

# Signal Traps

##

set -E

trap 'clean_up' 0

trap 'trap_exit "$(gettext "TERM signal caught. Exiting...")"' TERM HUP QUIT

trap 'trap_exit "$(gettext "Aborted by user! Exiting...")"' INT

trap 'trap_exit "$(gettext "An unknown error has occurred. Exiting...")"' ERR

# a source entry can have two forms :

# 1) "filename::http://path/to/file"

# 2) "http://path/to/file"

# extract the filename from a source entry

get_filename() {

# if a filename is specified, use it

local filename="${1%%::*}"

# if it is just an URL, we only keep the last component

echo "${filename##*/}"

}

# extract the URL from a source entry

get_url() {

# strip an eventual filename

echo "${1#*::}"

}

##

# Checks to see if options are present in makepkg.conf or PKGBUILD;

# PKGBUILD options always take precedence.

#

# usage : check_option( $option )

# return : y - enabled

# n - disabled

# ? - not found

##

check_option() {

local ret=$(in_opt_array "$1" ${options[@]})

if [[ $ret != '?' ]]; then

echo $ret

return

fi

# fall back to makepkg.conf options

ret=$(in_opt_array "$1" ${OPTIONS[@]})

if [[ $ret != '?' ]]; then

echo $ret

return

fi

echo '?' # Not Found

}

##

# Check if option is present in BUILDENV

#

# usage : check_buildenv( $option )

# return : y - enabled

# n - disabled

# ? - not found

##

check_buildenv() {

echo $(in_opt_array "$1" ${BUILDENV[@]})

}

##

# usage : in_opt_array( $needle, $haystack )

# return : y - enabled

# n - disabled

# ? - not found

##

in_opt_array() {

local needle="${1,,}"; shift

local opt

for opt in "$@"; do

opt="${opt,,}"

if [[ $opt = $needle ]]; then

echo 'y' # Enabled

return

elif [[ $opt = "!$needle" ]]; then

echo 'n' # Disabled

return

fi

done

echo '?' # Not Found

}

##

# usage : in_array( $needle, $haystack )

# return : 0 - found

# 1 - not found

##

in_array() {

local needle=$1; shift

[[ -z $1 ]] && return 1 # Not Found

local item

for item in "$@"; do

[[ $item = $needle ]] && return 0 # Found

done

return 1 # Not Found

}

get_downloadclient() {

# $1 = URL with valid protocol prefix

local url=$1

local proto="${url%%://*}"

# loop through DOWNLOAD_AGENTS variable looking for protocol

local i

for i in "${DLAGENTS[@]}"; do

local handler="${i%%::*}"

if [[ $proto = $handler ]]; then

agent="${i##*::}"

break

fi

done

# if we didn't find an agent, return an error

if [[ -z $agent ]]; then

error "$(gettext "There is no agent set up to handle %s URLs. Check %s.")" "$proto" "$MAKEPKG_CONF"

plain "$(gettext "Aborting...")"

exit 1 # $E_CONFIG_ERROR

fi

# ensure specified program is installed

local program="${agent%% *}"

if [[ ! -x $program ]]; then

local baseprog=$(basename $program)

error "$(gettext "The download program %s is not installed.")" "$baseprog"

plain "$(gettext "Aborting...")"

exit 1 # $E_MISSING_PROGRAM

fi

echo "$agent"

}

download_file() {

# download command

local dlcmd=$1

# URL of the file

local url=$2

# destination file

local file=$3

# temporary download file, default to last component of the URL

local dlfile="${url##*/}"

# replace %o by the temporary dlfile if it exists

if echo "$dlcmd" | grep -q "%o" ; then

dlcmd=${dlcmd//\%o/\"$file.part\"}

dlfile="$file.part"

fi

# add the URL, either in place of %u or at the end

if echo "$dlcmd" | grep -q "%u" ; then

dlcmd=${dlcmd//\%u/\"$url\"}

else

dlcmd="$dlcmd \"$url\""

fi

local ret=0

eval "$dlcmd || ret=\$?"

if (( ret )); then

[[ ! -s $dlfile ]] && rm -f -- "$dlfile"

return $ret

fi

# rename the temporary download file to the final destination

if [[ $dlfile != $file ]]; then

mv -f "$SRCDEST/$dlfile" "$SRCDEST/$file"

fi

}

run_pacman() {

local ret=0

if (( ! ASROOT )) && [[ $1 != "-T" ]] && sudo -l $PACMAN &>/dev/null; then

sudo $PACMAN $PACMAN_OPTS "$@" || ret=$?

else

$PACMAN $PACMAN_OPTS "$@" || ret=$?

fi

return $ret

}

check_deps() {

(( $# > 0 )) || return

local ret=0

pmout=$(run_pacman -T "$@")

ret=$?

if (( ret == 127 )); then #unresolved deps

echo "$pmout"

elif (( ret )); then

error "$(gettext "'%s' returned a fatal error (%i): %s")" "$PACMAN" "$ret" "$pmout"

exit 1

fi

}

handle_deps() {

local R_DEPS_SATISFIED=0

local R_DEPS_MISSING=1

(( $# == 0 )) && return $R_DEPS_SATISFIED

local deplist="$*"

if (( ! DEP_BIN )); then

return $R_DEPS_MISSING

fi

if (( DEP_BIN )); then

# install missing deps from binary packages (using pacman -S)

msg "$(gettext "Installing missing dependencies...")"

if ! run_pacman -S --asdeps $deplist; then

error "$(gettext "'%s' failed to install missing dependencies.")" "$PACMAN"

exit 1 # TODO: error code

fi

fi

# we might need the new system environment

# avoid triggering the ERR trap

local restoretrap=$(trap -p ERR)

trap - ERR

source /etc/profile &>/dev/null

eval $restoretrap

return $R_DEPS_SATISFIED

}

resolve_deps() {

# $pkgdeps is a GLOBAL variable, used by remove_deps()

local R_DEPS_SATISFIED=0

local R_DEPS_MISSING=1

local deplist="$(check_deps $*)"

if [[ -z $deplist ]]; then

return $R_DEPS_SATISFIED

fi

if handle_deps $deplist; then

pkgdeps="$pkgdeps $deplist"

# check deps again to make sure they were resolved

deplist="$(check_deps $*)"

[[ -z $deplist ]] && return $R_DEPS_SATISFIED

elif (( DEP_BIN )); then

error "$(gettext "Failed to install all missing dependencies.")"

fi

msg "$(gettext "Missing Dependencies:")"

local dep

for dep in $deplist; do

msg2 "$dep"

done

return $R_DEPS_MISSING

}

# fix flyspray bug #5923

remove_deps() {

# $pkgdeps is a GLOBAL variable, set by resolve_deps()

(( ! RMDEPS )) && return

[[ -z $pkgdeps ]] && return

local dep depstrip deplist

deplist=""

for dep in $pkgdeps; do

depstrip="${dep%%[<=>]*}"

deplist="$deplist $depstrip"

done

msg "Removing installed dependencies..."

# exit cleanly on failure to remove deps as package has been built successfully

if ! run_pacman -Rns $deplist; then

warning "$(gettext "Failed to remove installed dependencies.")"

return 0

fi

}

download_sources() {

msg "$(gettext "Retrieving Sources...")"

if [[ ! -w $SRCDEST ]] ; then

error "$(gettext "You do not have write permission to store downloads in %s.")" "$SRCDEST"

plain "$(gettext "Aborting...")"

exit 1

fi

pushd "$SRCDEST" &>/dev/null

local netfile

for netfile in "${source[@]}"; do

local file=$(get_filename "$netfile")

local url=$(get_url "$netfile")

if [[ -f $startdir/$file ]]; then

msg2 "$(gettext "Found %s in build dir")" "$file"

rm -f "$srcdir/$file"

ln -s "$startdir/$file" "$srcdir/"

continue

elif [[ -f $SRCDEST/$file ]]; then

msg2 "$(gettext "Using cached copy of %s")" "$file"

rm -f "$srcdir/$file"

ln -s "$SRCDEST/$file" "$srcdir/"

continue

fi

# if we get here, check to make sure it was a URL, else fail

if [[ $file = $url ]]; then

error "$(gettext "%s was not found in the build directory and is not a URL.")" "$file"

exit 1 # $E_MISSING_FILE

fi

# find the client we should use for this URL

local dlclient=$(get_downloadclient "$url") || exit $?

msg2 "$(gettext "Downloading %s...")" "$file"

# fix flyspray bug #3289

local ret=0

download_file "$dlclient" "$url" "$file" || ret=$?

if (( ret )); then

error "$(gettext "Failure while downloading %s")" "$file"

plain "$(gettext "Aborting...")"

exit 1

fi

rm -f "$srcdir/$file"

ln -s "$SRCDEST/$file" "$srcdir/"

done

popd &>/dev/null

}

generate_checksums() {

msg "$(gettext "Generating checksums for source files...")"

plain ""

if [ ! $(type -p openssl) ]; then

error "$(gettext "Cannot find openssl.")"

exit 1 # $E_MISSING_PROGRAM

fi

local integ

for integ in ${INTEGRITY_CHECK[@]}; do

integ="${integ,,}"

case "$integ" in

md5|sha1|sha256|sha384|sha512) : ;;

*)

error "$(gettext "Invalid integrity algorithm '%s' specified.")" "$integ"

exit 1;; # $E_CONFIG_ERROR

esac

local ct=0

local numsrc=${#source[@]}

echo -n "${integ}sums=("

local i

local indent=''

for (( i = 0; i < ${#integ} + 6; i++ )); do

indent="$indent "

done

local netfile

for netfile in "${source[@]}"; do

local file="$(get_filename "$netfile")"

if [[ ! -f $file ]] ; then

if [[ ! -f $SRCDEST/$file ]] ; then

error "$(gettext "Unable to find source file %s to generate checksum.")" "$file"

plain "$(gettext "Aborting...")"

exit 1

else

file="$SRCDEST/$file"

fi

fi

local sum="$(openssl dgst -${integ} "$file")"

sum=${sum##* }

(( ct )) && echo -n "$indent"

echo -n "'$sum'"

ct=$(($ct+1))

(( $ct < $numsrc )) && echo

done

echo ")"

done

}

check_checksums() {

(( ! ${#source[@]} )) && return 0

if [ ! $(type -p openssl) ]; then

error "$(gettext "Cannot find openssl.")"

exit 1 # $E_MISSING_PROGRAM

fi

local correlation=0

local integ required

for integ in md5 sha1 sha256 sha384 sha512; do

local integrity_sums=($(eval echo "\${${integ}sums[@]}"))

if (( ${#integrity_sums[@]} == ${#source[@]} )); then

msg "$(gettext "Validating source files with %s...")" "${integ}sums"

correlation=1

local errors=0

local idx=0

local file

for file in "${source[@]}"; do

local found=1

file="$(get_filename "$file")"

echo -n " $file ... " >&2

if [[ ! -f $file ]] ; then

if [[ ! -f $SRCDEST/$file ]] ; then

echo "$(gettext "NOT FOUND")" >&2

errors=1

found=0

else

file="$SRCDEST/$file"

fi

fi

if (( $found )) ; then

local expectedsum="${integrity_sums[$idx],,}"

local realsum="$(openssl dgst -${integ} "$file")"

realsum="${realsum##* }"

if [[ $expectedsum = $realsum ]]; then

echo "$(gettext "Passed")" >&2

else

echo "$(gettext "FAILED")" >&2

errors=1

fi

fi

idx=$((idx + 1))

done

if (( errors )); then

error "$(gettext "One or more files did not pass the validity check!")"

exit 1 # TODO: error code

fi

elif (( ${#integrity_sums[@]} )); then

error "$(gettext "Integrity checks (%s) differ in size from the source array.")" "$integ"

exit 1 # TODO: error code

fi

done

if (( ! correlation )); then

if (( SKIPINTEG )); then

warning "$(gettext "Integrity checks are missing.")"

else

error "$(gettext "Integrity checks are missing.")"

exit 1 # TODO: error code

fi

fi

}

extract_sources() {

msg "$(gettext "Extracting Sources...")"

local netfile

for netfile in "${source[@]}"; do

file=$(get_filename "$netfile")

if in_array "$file" ${noextract[@]}; then

#skip source files in the noextract=() array

# these are marked explicitly to NOT be extracted

continue

fi

if [[ ! -f $file ]] ; then

if [[ ! -f $SRCDEST/$file ]] ; then

error "$(gettext "Unable to find source file %s for extraction.")" "$file"

plain "$(gettext "Aborting...")"

exit 1

else

file="$SRCDEST/$file"

fi

fi

# fix flyspray #6246

local file_type=$(file -bizL "$file")

local ext=${file##*.}

local cmd=''

case "$file_type" in

*application/x-tar*|*application/zip*|*application/x-zip*|*application/x-cpio*)

cmd="bsdtar" ;;

*application/x-gzip*)

case "$ext" in

gz|z|Z) cmd="gzip" ;;

*) continue;;

esac ;;

*application/x-bzip*)

case "$ext" in

bz2|bz) cmd="bzip2" ;;

*) continue;;

esac ;;

*application/x-xz*)

case "$ext" in

xz) cmd="xz" ;;

*) continue;;

esac ;;

*)

# Don't know what to use to extract this file,

# skip to the next file

continue;;

esac

local ret=0

msg2 "$(gettext "Extracting %s with %s")" "$file" "$cmd"

if [[ $cmd = bsdtar ]]; then

$cmd -xf "$file" || ret=?

else

rm -f "${file%.*}"

$cmd -dcf "$file" > "${file%.*}" || ret=?

fi

if (( ret )); then

error "$(gettext "Failed to extract %s")" "$file"

plain "$(gettext "Aborting...")"

exit 1

fi

done

if (( EUID == 0 )); then

# change perms of all source files to root user & root group

chown -R 0:0 "$srcdir"

fi

}

error_function() {

if [[ -p $logpipe ]]; then

rm "$logpipe"

fi

# first exit all subshells, then print the error

if (( ! BASH_SUBSHELL )); then

plain "$(gettext "Aborting...")"

remove_deps

fi

exit 2 # $E_BUILD_FAILED

}

run_function() {

if [[ -z $1 ]]; then

return 1

fi

pkgfunc="$1"

# clear user-specified makeflags if requested

if [[ $(check_option makeflags) = "n" ]]; then

MAKEFLAGS=""

fi

msg "$(gettext "Starting %s()...")" "$pkgfunc"

cd "$srcdir"

# ensure all necessary build variables are exported

export CFLAGS CXXFLAGS LDFLAGS MAKEFLAGS CHOST

# save our shell options so pkgfunc() can't override what we need

local shellopts=$(shopt -p)

local ret=0

if (( LOGGING )); then

BUILDLOG="${startdir}/${pkgbase}-${pkgver}-${pkgrel}-${CARCH}-$pkgfunc.log"

if [[ -f $BUILDLOG ]]; then

local i=1

while true; do

if [[ -f $BUILDLOG.$i ]]; then

i=$(($i +1))

else

break

fi

done

mv "$BUILDLOG" "$BUILDLOG.$i"

fi

# ensure overridden package variables survive tee with split packages

logpipe=$(mktemp -u "$startdir/logpipe.XXXXXXXX")

mknod "$logpipe" p

exec 3>&1

tee "$BUILDLOG" < "$logpipe" &

exec 1>"$logpipe" 2>"$logpipe"

restoretrap=$(trap -p ERR)

trap 'error_function' ERR

$pkgfunc 2>&1

eval $restoretrap

sync

exec 1>&3 2>&3 3>&-

rm "$logpipe"

else

restoretrap=$(trap -p ERR)

trap 'error_function' ERR

$pkgfunc 2>&1

eval $restoretrap

fi

# reset our shell options

eval "$shellopts"

}

run_build() {

# use distcc if it is requested (check buildenv and PKGBUILD opts)

if [[ $(check_buildenv distcc) = "y" && $(check_option distcc) != "n" ]]; then

[[ -d /usr/lib/distcc/bin ]] && export PATH="/usr/lib/distcc/bin:$PATH"

export DISTCC_HOSTS

elif [[ $(check_option distcc) = "n" ]]; then

# if it is not wanted, clear the makeflags too

MAKEFLAGS=""

fi

# use ccache if it is requested (check buildenv and PKGBUILD opts)

if [[ $(check_buildenv ccache) = "y" && $(check_option ccache) != "n" ]]; then

[[ -d /usr/lib/ccache/bin ]] && export PATH="/usr/lib/ccache/bin:$PATH"

fi

run_function "build"

}

run_package() {

if [[ -z $1 ]]; then

pkgfunc="package"

else

pkgfunc="package_$1"

fi

run_function "$pkgfunc"

}

tidy_install() {

cd "$pkgdir"

msg "$(gettext "Tidying install...")"

if [[ $(check_option docs) = "n" && -n ${DOC_DIRS[*]} ]]; then

msg2 "$(gettext "Removing doc files...")"

rm -rf ${DOC_DIRS[@]}

fi

if [[ $(check_option purge) = "y" && -n ${PURGE_TARGETS[*]} ]]; then

msg2 "$(gettext "Purging other files...")"

local pt

for pt in "${PURGE_TARGETS[@]}"; do

if [[ ${pt} = ${pt//\/} ]]; then

find . -type f -name "${pt}" -exec rm -f -- '{}' \;

else

rm -f ${pt}

fi

done

fi

if [[ $(check_option zipman) = "y" && -n ${MAN_DIRS[*]} ]]; then

msg2 "$(gettext "Compressing man and info pages...")"

local manpage ext file link hardlinks hl

find ${MAN_DIRS[@]} -type f 2>/dev/null |

while read manpage ; do

# check file still exists (potentially compressed with hard link)

if [[ -f ${manpage} ]]; then

ext="${manpage##*.}"

file="${manpage##*/}"

if [[ $ext != gz && $ext != bz2 ]]; then

# update symlinks to this manpage

find ${MAN_DIRS[@]} -lname "$file" 2>/dev/null |

while read link ; do

rm -f "$link"

ln -sf "${file}.gz" "${link}.gz"

done

# find hard links and remove them

# the '|| true' part keeps the script from bailing if find returned an

# error, such as when one of the man directories doesn't exist

hardlinks="$(find ${MAN_DIRS[@]} \! -name "$file" -samefile "$manpage" 2>/dev/null)" || true

for hl in ${hardlinks}; do

rm -f "${hl}";

done

# compress the original

gzip -9 "$manpage"

# recreate hard links removed earlier

for hl in ${hardlinks}; do

ln "${manpage}.gz" "${hl}.gz"

chmod 644 ${hl}.gz

done

fi

fi

done

fi

if [[ $(check_option strip) = y && -n ${STRIP_DIRS[*]} ]]; then

msg2 "$(gettext "Stripping debugging symbols from binaries and libraries...")"

local binary

find ${STRIP_DIRS[@]} -type f 2>/dev/null | while read binary ; do

case "$(file -biz "$binary")" in

*compressed-encoding*) # Skip compressed binaries

;;

*application/x-sharedlib*) # Libraries (.so)

/usr/bin/strip -S "$binary";;

*application/x-archive*) # Libraries (.a)

/usr/bin/strip -S "$binary";;

*application/x-executable*) # Binaries

/usr/bin/strip "$binary";;

esac

done

fi

if [[ $(check_option libtool) = "n" ]]; then

msg2 "$(gettext "Removing libtool .la files...")"

find . ! -type d -name "*.la" -exec rm -f -- '{}' \;

fi

if [[ $(check_option emptydirs) = "n" ]]; then

msg2 "$(gettext "Removing empty directories...")"

find . -depth -type d -empty -delete

fi

}

write_pkginfo() {

local builddate=$(date -u "+%s")

if [[ -n $PACKAGER ]]; then

local packager="$PACKAGER"

else

local packager="Unknown Packager"

fi

local size="$(du -sk)"

size="$(( ${size%%[^0-9]*} * 1024 ))"

msg2 "$(gettext "Generating .PKGINFO file...")"

echo "# Generated by makepkg $myver" >.PKGINFO

if (( INFAKEROOT )); then

echo "# using $(fakeroot -v)" >>.PKGINFO

fi

echo "# $(LC_ALL=C date -u)" >>.PKGINFO

echo "pkgname = $1" >>.PKGINFO

(( SPLITPKG )) && echo pkgbase = $pkgbase >>.PKGINFO

echo "pkgver = $pkgver-$pkgrel" >>.PKGINFO

echo "pkgdesc = $pkgdesc" >>.PKGINFO

echo "url = $url" >>.PKGINFO

echo "builddate = $builddate" >>.PKGINFO

echo "packager = $packager" >>.PKGINFO

echo "size = $size" >>.PKGINFO

echo "arch = $PKGARCH" >>.PKGINFO

if [[ $(check_option force) = "y" ]]; then

echo "force = true" >> .PKGINFO

fi

local it

for it in "${license[@]}"; do

echo "license = $it" >>.PKGINFO

done

for it in "${replaces[@]}"; do

echo "replaces = $it" >>.PKGINFO

done

for it in "${groups[@]}"; do

echo "group = $it" >>.PKGINFO

done

for it in "${depends[@]}"; do

echo "depend = $it" >>.PKGINFO

done

for it in "${optdepends[@]}"; do

echo "optdepend = $it" >>.PKGINFO

done

for it in "${conflicts[@]}"; do

echo "conflict = $it" >>.PKGINFO

done

for it in "${provides[@]}"; do

echo "provides = $it" >>.PKGINFO

done

for it in "${backup[@]}"; do

echo "backup = $it" >>.PKGINFO

done

for it in "${packaging_options[@]}"; do

local ret="$(check_option $it)"

if [[ $ret != "?" ]]; then

if [[ $ret = y ]]; then

echo "makepkgopt = $it" >>.PKGINFO

else

echo "makepkgopt = !$it" >>.PKGINFO

fi

fi

done

# TODO maybe remove this at some point

# warn if license array is not present or empty

if [[ -z $license ]]; then

warning "$(gettext "Please add a license line to your %s!")" "$BUILDSCRIPT"

plain "$(gettext "Example for GPL\'ed software: license=('GPL').")"

fi

}

check_package() {

cd "$pkgdir"

# check existence of backup files

local file

for file in "${backup[@]}"; do

if [[ ! -f $file ]]; then

warning "$(gettext "Invalid backup entry : %s")" "$file"

fi

done

# check for references to the build directory

if grep -R "${srcdir}" "${pkgdir}" &>/dev/null; then

warning "$(gettext "Package contains reference to %s")" "\$srcdir"

fi

}

create_package_pacman() {

if [[ -z $1 ]]; then

nameofpkg="$pkgname"

else

nameofpkg="$1"

fi

if [[ $arch = "any" ]]; then

PKGARCH="any"

else

PKGARCH=$CARCH

fi

write_pkginfo $nameofpkg

local comp_files=".PKGINFO"

# check for an install script

if [[ -n $install ]]; then

msg2 "$(gettext "Adding install script...")"

cp "$startdir/$install" .INSTALL

comp_files="$comp_files .INSTALL"

fi

# do we have a changelog?

if [[ -n $changelog ]]; then

msg2 "$(gettext "Adding package changelog...")"

cp "$startdir/$changelog" .CHANGELOG

comp_files="$comp_files .CHANGELOG"

fi

# tar it up

msg2 "$(gettext "Compressing package...")"