1500 lines
31 KiB
Bash
Executable File
1500 lines
31 KiB
Bash
Executable File
#!/bin/sh
|
|
#
|
|
# xbps - A simple, minimal, fast and uncomplete build package system.
|
|
#-
|
|
# Copyright (c) 2008 Juan Romero Pardines.
|
|
# All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions
|
|
# are met:
|
|
# 1. Redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer.
|
|
# 2. Redistributions in binary form must reproduce the above copyright
|
|
# notice, this list of conditions and the following disclaimer in the
|
|
# documentation and/or other materials provided with the distribution.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
#-
|
|
trap "echo && exit 1" INT QUIT
|
|
|
|
: ${XBPS_CONFIG_FILE:=/etc/xbps.conf}
|
|
|
|
: ${progname:=$(basename $0)}
|
|
: ${fetch_cmd:=wget}
|
|
: ${xbps_machine:=$(uname -m)}
|
|
: ${XBPS_CROSS_HOST:=$xbps_machine-pc-linux-gnu}
|
|
|
|
usage()
|
|
{
|
|
cat << _EOF
|
|
$progname: [-C] [-c <config_file>] <target> [package_name]
|
|
|
|
Targets:
|
|
build Builds a package, only build phase is done.
|
|
chroot Enters to the chroot in masterdir.
|
|
configure Configure a package, only configure phase is done.
|
|
extract Extract distribution file(s) into build directory.
|
|
fetch Download distribution file(s).
|
|
info Show information about <package_name>.
|
|
install-destdir build + configure + install into destdir.
|
|
install install-destdir + stow.
|
|
list Lists all currently installed packages.
|
|
listfiles Lists files installed from <package_name>.
|
|
remove Remove package completely (destdir + masterdir).
|
|
stow Copy files from destdir/<pkgname> into masterdir.
|
|
unstow Remove <pkgname> files from masterdir.
|
|
|
|
Options:
|
|
-C Do not remove build directory after successful installation.
|
|
-c Path to global configuration file:
|
|
if not specified /etc/xbps.conf is used.
|
|
_EOF
|
|
exit 1
|
|
}
|
|
|
|
set_defvars()
|
|
{
|
|
local i=
|
|
|
|
# Directories
|
|
: ${XBPS_TEMPLATESDIR:=$XBPS_DISTRIBUTIONDIR/templates}
|
|
: ${XBPS_HELPERSDIR:=$XBPS_DISTRIBUTIONDIR/helpers}
|
|
: ${XBPS_PKGDB_FPATH:=$XBPS_DESTDIR/.xbps-pkgdb.plist}
|
|
: ${XBPS_UTILSDIR:=$XBPS_DISTRIBUTIONDIR/utils}
|
|
: ${XBPS_DIGEST_CMD:=$XBPS_UTILSDIR/xbps-digest}
|
|
: ${XBPS_PKGDB_CMD:=$XBPS_UTILSDIR/xbps-pkgdb}
|
|
: ${XBPS_CMPVER_CMD:=$XBPS_UTILSDIR/xbps-cmpver}
|
|
|
|
local DDIRS="XBPS_TEMPLATESDIR XBPS_HELPERSDIR XBPS_UTILSDIR"
|
|
for i in ${DDIRS}; do
|
|
eval val="\$$i"
|
|
[ ! -d "$val" ] && msg_error "cannot find $i, aborting."
|
|
done
|
|
|
|
XBPS_PKGDB_CMD="env XBPS_PKGDB_FPATH=$XBPS_PKGDB_FPATH $XBPS_PKGDB_CMD"
|
|
}
|
|
|
|
check_path()
|
|
{
|
|
eval local orig="$1"
|
|
|
|
case "$orig" in
|
|
/) ;;
|
|
/*) orig="${orig%/}" ;;
|
|
*) orig="$(pwd)/${orig%/}" ;;
|
|
esac
|
|
|
|
path_fixed="$orig"
|
|
}
|
|
|
|
run_file()
|
|
{
|
|
local file="$1"
|
|
|
|
check_path "$file"
|
|
. $path_fixed
|
|
}
|
|
|
|
run_func()
|
|
{
|
|
func="$1"
|
|
|
|
[ -z "$func" ] && return 1
|
|
|
|
type -t $func | grep -q 'function'
|
|
[ $? -eq 0 ] && $func
|
|
}
|
|
|
|
msg_error()
|
|
{
|
|
[ -z "$1" ] && return 1
|
|
|
|
if [ -n "$in_chroot" ]; then
|
|
echo "[chroot] => ERROR: $1"
|
|
else
|
|
echo "=> ERROR: $1"
|
|
fi
|
|
|
|
exit 1
|
|
}
|
|
|
|
msg_warn()
|
|
{
|
|
[ -z "$1" ] && return 1
|
|
|
|
if [ -n "$in_chroot" ]; then
|
|
echo "[chroot] => WARNING: $1"
|
|
else
|
|
echo "=> WARNING: $1"
|
|
fi
|
|
}
|
|
|
|
msg_normal()
|
|
{
|
|
[ -z "$1" ] && return 1
|
|
|
|
if [ -n "$in_chroot" ]; then
|
|
echo "[chroot] => $1"
|
|
else
|
|
echo "=> $1"
|
|
fi
|
|
}
|
|
|
|
#
|
|
# Shows info about a template.
|
|
#
|
|
info_tmpl()
|
|
{
|
|
local i=
|
|
|
|
echo "pkgname: $pkgname"
|
|
echo "version: $version"
|
|
for i in "${distfiles}"; do
|
|
[ -n "$i" ] && echo "distfile: $i"
|
|
done
|
|
[ -n "$checksum" ] && echo "checksum: $checksum"
|
|
echo "maintainer: $maintainer"
|
|
echo "build_style: $build_style"
|
|
echo "short_desc: $short_desc"
|
|
echo "$long_desc"
|
|
echo
|
|
check_build_depends_pkg $pkgname-$version
|
|
if [ $? -eq 0 ]; then
|
|
echo "This package requires the following dependencies to be built:"
|
|
for i in ${build_depends}; do
|
|
echo " $i"
|
|
done
|
|
fi
|
|
}
|
|
|
|
#
|
|
# Checks that all required variables specified in the configuration
|
|
# file are properly working.
|
|
#
|
|
check_config_vars()
|
|
{
|
|
local cffound=
|
|
local f=
|
|
|
|
if [ -z "$config_file_specified" ]; then
|
|
config_file_paths="$XBPS_CONFIG_FILE ./xbps.conf"
|
|
for f in $config_file_paths; do
|
|
[ -f $f ] && XBPS_CONFIG_FILE=$f && \
|
|
cffound=yes && break
|
|
done
|
|
[ -z "$cffound" ] && msg_error "cannot find a config file"
|
|
fi
|
|
|
|
run_file ${XBPS_CONFIG_FILE}
|
|
XBPS_CONFIG_FILE=$path_fixed
|
|
|
|
if [ ! -f "$XBPS_CONFIG_FILE" ]; then
|
|
msg_error "cannot find configuration file: $XBPS_CONFIG_FILE"
|
|
fi
|
|
|
|
local XBPS_VARS="XBPS_MASTERDIR XBPS_DESTDIR XBPS_BUILDDIR \
|
|
XBPS_SRCDISTDIR"
|
|
|
|
for f in ${XBPS_VARS}; do
|
|
eval val="\$$f"
|
|
[ -z "$val" ] && msg_error "'$f' not set in configuration file"
|
|
|
|
if [ ! -d "$val" ]; then
|
|
mkdir "$val"
|
|
[ $? -ne 0 ] && msg_error "couldn't create '$f' directory"
|
|
fi
|
|
done
|
|
}
|
|
|
|
#
|
|
# Resets all vars used by a template.
|
|
#
|
|
reset_tmpl_vars()
|
|
{
|
|
local v=
|
|
local TMPL_VARS="pkgname distfiles configure_args configure_env \
|
|
make_build_args make_install_args build_style \
|
|
short_desc maintainer long_desc checksum wrksrc \
|
|
patch_files make_cmd base_package base_chroot \
|
|
make_env make_build_target configure_script \
|
|
pre_configure pre_build pre_install post_install \
|
|
postinstall_helpers make_install_target version \
|
|
tar_override_cmd xml_entries sgml_entries \
|
|
build_depends libtool_fixup_la_stage no_fixup_libtool \
|
|
disable_parallel_build run_depends cross_compiler \
|
|
only_for_archs \
|
|
XBPS_EXTRACT_DONE XBPS_CONFIGURE_DONE \
|
|
XBPS_BUILD_DONE XBPS_INSTALL_DONE"
|
|
|
|
for v in ${TMPL_VARS}; do
|
|
eval unset "$v"
|
|
done
|
|
|
|
unset_build_vars
|
|
}
|
|
|
|
#
|
|
# Reads a template file and setups required variables for operations.
|
|
#
|
|
setup_tmpl()
|
|
{
|
|
local pkg="$1"
|
|
|
|
[ -z "$pkg" ] && msg_error "missing package name after target." && usage
|
|
|
|
if [ -f "$XBPS_TEMPLATESDIR/$pkg.tmpl" ]; then
|
|
if [ "$pkgname" != "$pkg" ]; then
|
|
run_file $XBPS_TEMPLATESDIR/$pkg.tmpl
|
|
fi
|
|
prepare_tmpl
|
|
else
|
|
msg_error "cannot find '$pkg' template build file."
|
|
fi
|
|
}
|
|
|
|
#
|
|
# Checks some vars used in templates and sets some of them required.
|
|
#
|
|
prepare_tmpl()
|
|
{
|
|
local i=
|
|
local found=
|
|
|
|
#
|
|
# There's nothing of interest if we are a meta template.
|
|
#
|
|
[ "$build_style" = "meta-template" ] && return 0
|
|
|
|
REQ_VARS="pkgname distfiles version build_style"
|
|
|
|
# Check if required vars weren't set.
|
|
for i in ${REQ_VARS}; do
|
|
eval val="\$$i"
|
|
if [ -z "$val" -o -z "$i" ]; then
|
|
msg_error "\"$i\" not set on $pkgname template."
|
|
fi
|
|
done
|
|
|
|
for i in ${only_for_archs}; do
|
|
[ "$i" = "$xbps_machine" ] && found=si && break
|
|
done
|
|
if [ -n "${only_for_archs}" -a -z "$found" ]; then
|
|
msg_error "this package is only for: ${only_for_archs}."
|
|
fi
|
|
|
|
unset XBPS_EXTRACT_DONE XBPS_APPLYPATCHES_DONE
|
|
unset XBPS_CONFIGURE_DONE XBPS_BUILD_DONE XBPS_INSTALL_DONE
|
|
|
|
[ -z "$wrksrc" ] && wrksrc="$pkgname-$version"
|
|
wrksrc="$XBPS_BUILDDIR/$wrksrc"
|
|
|
|
XBPS_EXTRACT_DONE="$wrksrc/.xbps_extract_done"
|
|
XBPS_APPLYPATCHES_DONE="$wrksrc/.xbps_applypatches_done"
|
|
XBPS_CONFIGURE_DONE="$wrksrc/.xbps_configure_done"
|
|
XBPS_BUILD_DONE="$wrksrc/.xbps_build_done"
|
|
XBPS_INSTALL_DONE="$wrksrc/.xbps_install_done"
|
|
|
|
if [ -z "$in_chroot" ]; then
|
|
export PATH="$XBPS_MASTERDIR/bin:$XBPS_MASTERDIR/sbin"
|
|
export PATH="$PATH:$XBPS_MASTERDIR/usr/bin:$XBPS_MASTERDIR/usr/sbin"
|
|
fi
|
|
export PATH="$PATH:/bin:/sbin:/usr/bin:/usr/sbin"
|
|
}
|
|
|
|
#
|
|
# Extracts contents of distfiles specified in a template into
|
|
# the $wrksrc directory.
|
|
#
|
|
extract_distfiles()
|
|
{
|
|
local pkg="$1"
|
|
local count=
|
|
local curfile=
|
|
local cursufx=
|
|
local lwrksrc=
|
|
local ltar_cmd=
|
|
local f=
|
|
|
|
[ -f $XBPS_EXTRACT_DONE ] && return 0
|
|
|
|
#
|
|
# If we are being called via the target, just extract and return.
|
|
#
|
|
[ -n "$pkg" -a -z "$pkgname" ] && return 1
|
|
|
|
#
|
|
# There's nothing of interest if we are a meta template.
|
|
#
|
|
[ "$build_style" = "meta-template" ] && return 0
|
|
|
|
for f in ${distfiles}; do
|
|
count=$(($count + 1))
|
|
done
|
|
|
|
if [ $count -gt 1 ]; then
|
|
if [ -z "$wrksrc" ]; then
|
|
msg_error "\$wrksrc must be defined with multiple distfiles."
|
|
exit 1
|
|
fi
|
|
mkdir $wrksrc
|
|
fi
|
|
|
|
msg_normal "Extracting $pkgname-$version distfile(s)."
|
|
|
|
if [ -n "$tar_override_cmd" ]; then
|
|
ltar_cmd="$tar_override_cmd"
|
|
else
|
|
ltar_cmd="tar"
|
|
fi
|
|
|
|
for f in ${distfiles}; do
|
|
if $(echo $f|grep -q '.tar.bz2'); then
|
|
cursufx=".tar.bz2"
|
|
elif $(echo $f|grep -q '.tbz'); then
|
|
cursufx=".tbz"
|
|
elif $(echo $f|grep -q '.tar.gz'); then
|
|
cursufx=".tar.gz"
|
|
elif $(echo $f|grep -q '.tgz'); then
|
|
cursufx=".tgz"
|
|
elif $(echo $f|grep -q '.tar'); then
|
|
cursufx=".tar"
|
|
elif $(echo $f|grep -q '.zip'); then
|
|
cursufx=".zip"
|
|
else
|
|
msg_error "unknown distfile suffix for $f."
|
|
fi
|
|
|
|
curfile=$(basename $f)
|
|
|
|
if [ $count -gt 1 ]; then
|
|
lwrksrc="$wrksrc/${curfile%$cursufx}"
|
|
else
|
|
lwrksrc="$XBPS_BUILDDIR"
|
|
fi
|
|
|
|
case ${cursufx} in
|
|
.tar.bz2|.tbz)
|
|
$ltar_cmd xfj $XBPS_SRCDISTDIR/$curfile -C $lwrksrc
|
|
if [ $? -ne 0 ]; then
|
|
msg_error "extracting $curfile into $lwrksrc."
|
|
fi
|
|
;;
|
|
.tar.gz|.tgz)
|
|
$ltar_cmd xfz $XBPS_SRCDISTDIR/$curfile -C $lwrksrc
|
|
if [ $? -ne 0 ]; then
|
|
msg_error "extracting $curfile into $lwrksrc."
|
|
fi
|
|
;;
|
|
.tar)
|
|
$ltar_cmd xf $XBPS_SRCDISTDIR/$curfile -C $lwrksrc
|
|
if [ $? -ne 0 ]; then
|
|
msg_error "extracting $curfile into $lwrksrc."
|
|
fi
|
|
;;
|
|
.zip)
|
|
if [ -x $XBPS_MASTERDIR/usr/bin/unzip ]; then
|
|
$XBPS_MASTERDIR/usr/bin/unzip \
|
|
-q -x $XBPS_SRCDISTDIR/$curfile -d $lwrksrc
|
|
if [ $? -ne 0 ]; then
|
|
msg_error "extracting $curfile into $lwrksrc."
|
|
fi
|
|
else
|
|
msg_error "cannot find unzip bin for extraction"
|
|
fi
|
|
;;
|
|
*)
|
|
msg_error "cannot guess $curfile extract suffix. ($cursufx)"
|
|
;;
|
|
esac
|
|
done
|
|
|
|
touch -f $XBPS_EXTRACT_DONE
|
|
}
|
|
|
|
#
|
|
# Verifies that file's checksum downloaded matches what it's specified
|
|
# in template file.
|
|
#
|
|
verify_sha256_cksum()
|
|
{
|
|
local file="$1"
|
|
local origsum="$2"
|
|
|
|
[ -z "$file" -o -z "$cksum" ] && return 1
|
|
|
|
filesum=$($XBPS_DIGEST_CMD $XBPS_SRCDISTDIR/$file)
|
|
if [ "$origsum" != "$filesum" ]; then
|
|
msg_error "SHA256 checksum doesn't match for $file."
|
|
fi
|
|
|
|
msg_normal "SHA256 checksum OK for $file."
|
|
}
|
|
|
|
#
|
|
# Downloads the distfiles and verifies checksum for all them.
|
|
#
|
|
fetch_distfiles()
|
|
{
|
|
local pkg="$1"
|
|
local dfiles=
|
|
local localurl=
|
|
local dfcount=0
|
|
local ckcount=0
|
|
local f=
|
|
|
|
[ -z $pkgname ] && exit 1
|
|
|
|
#
|
|
# There's nothing of interest if we are a meta template.
|
|
#
|
|
[ "$build_style" = "meta-template" ] && return 0
|
|
|
|
for f in ${distfiles}; do
|
|
curfile=$(basename $f)
|
|
if [ -f "$XBPS_SRCDISTDIR/$curfile" ]; then
|
|
for i in ${checksum}; do
|
|
if [ $dfcount -eq $ckcount -a -n $i ]; then
|
|
cksum=$i
|
|
found=yes
|
|
break
|
|
fi
|
|
|
|
ckcount=$(($ckcount + 1))
|
|
done
|
|
|
|
if [ -z $found ]; then
|
|
msg_error "cannot find checksum for $curfile."
|
|
fi
|
|
|
|
verify_sha256_cksum $curfile $cksum
|
|
if [ $? -eq 0 ]; then
|
|
unset cksum found
|
|
ckcount=0
|
|
dfcount=$(($dfcount + 1))
|
|
continue
|
|
fi
|
|
fi
|
|
|
|
msg_normal "Fetching distfile: $curfile."
|
|
|
|
if [ -n "$distfiles" ]; then
|
|
localurl="$f"
|
|
else
|
|
localurl="$url/$curfile"
|
|
fi
|
|
|
|
|
|
cd $XBPS_SRCDISTDIR && $fetch_cmd $localurl
|
|
if [ $? -ne 0 ]; then
|
|
unset localurl
|
|
if [ ! -f $XBPS_SRCDISTDIR/$curfile ]; then
|
|
msg_error "couldn't fetch $curfile."
|
|
else
|
|
msg_error "there was an error fetching $curfile."
|
|
fi
|
|
else
|
|
unset localurl
|
|
#
|
|
# XXX duplicate code.
|
|
#
|
|
for i in ${checksum}; do
|
|
if [ $dfcount -eq $ckcount -a -n $i ]; then
|
|
cksum=$i
|
|
found=yes
|
|
break
|
|
fi
|
|
|
|
ckcount=$(($ckcount + 1))
|
|
done
|
|
|
|
if [ -z $found ]; then
|
|
msg_error "cannot find checksum for $curfile."
|
|
fi
|
|
|
|
verify_sha256_cksum $curfile $cksum
|
|
if [ $? -eq 0 ]; then
|
|
unset cksum found
|
|
ckcount=0
|
|
fi
|
|
fi
|
|
|
|
dfcount=$(($dfcount + 1))
|
|
done
|
|
|
|
unset cksum found
|
|
}
|
|
|
|
libtool_fixup_file()
|
|
{
|
|
local hldirf="hardcode_libdir_flag_spec"
|
|
|
|
[ "$pkgname" = "libtool" -o ! -f $wrksrc/libtool ] && return 0
|
|
[ -n "$no_libtool_fixup" ] && return 0
|
|
|
|
# If we are being invoked by a chroot, don't transform stuff.
|
|
[ -n "$in_chroot" ] && return 0
|
|
|
|
sed -i -e "s|^$hldirf=.*|$hldirf=\"-Wl,-rpath /usr/lib\"|g" \
|
|
$wrksrc/libtool
|
|
}
|
|
|
|
libtool_fixup_la_files()
|
|
{
|
|
local f=
|
|
local postinstall="$1"
|
|
local where=
|
|
|
|
# Ignore libtool itself
|
|
[ "$pkgname" = "libtool" ] && return 0
|
|
|
|
# If we are being invoked by a chroot, don't transform stuff.
|
|
[ -n "$in_chroot" ] && return 0
|
|
|
|
[ ! -f "$wrksrc/libtool" -o ! -f "$wrksrc/ltmain.sh" ] && return 0
|
|
|
|
#
|
|
# Replace hardcoded or incorrect paths with correct ones.
|
|
#
|
|
if [ -z "$postinstall" ]; then
|
|
where="$wrksrc"
|
|
else
|
|
where="$XBPS_DESTDIR/$pkgname-$version"
|
|
fi
|
|
|
|
for f in $(find $where -type f -name \*.la*); do
|
|
if [ -f $f ]; then
|
|
msg_normal "Fixing up libtool archive: ${f##$where/}."
|
|
sed -i -e "s|\/..\/lib||g;s|\/\/lib|/usr/lib|g" \
|
|
-e "s|$XBPS_MASTERDIR||g;s|$wrksrc||g" \
|
|
-e "s|$where||g" $f
|
|
awk '{ if (/^ dependency_libs/) {gsub("/usr[^]*lib","lib");}print}' \
|
|
$f > $f.in && mv $f.in $f
|
|
fi
|
|
done
|
|
}
|
|
|
|
set_build_vars()
|
|
{
|
|
[ -n "$in_chroot" ] && return 0
|
|
|
|
LDFLAGS="-L$XBPS_MASTERDIR/usr/lib"
|
|
SAVE_LDLIBPATH=$LD_LIBRARY_PATH
|
|
LD_LIBRARY_PATH="$XBPS_MASTERDIR/usr/lib"
|
|
CFLAGS="$CFLAGS $XBPS_CFLAGS"
|
|
CXXFLAGS="$CXXFLAGS $XBPS_CXXFLAGS"
|
|
CPPFLAGS="-I$XBPS_MASTERDIR/usr/include $CPPFLAGS"
|
|
PKG_CONFIG="$XBPS_MASTERDIR/usr/bin/pkg-config"
|
|
PKG_CONFIG_LIBDIR="$XBPS_MASTERDIR/usr/lib/pkgconfig"
|
|
|
|
export LD_LIBRARY_PATH="$LD_LIBRARY_PATH"
|
|
export CFLAGS="$CFLAGS" CXXFLAGS="$CXXFLAGS"
|
|
export CPPFLAGS="$CPPFLAGS" PKG_CONFIG="$PKG_CONFIG"
|
|
export PKG_CONFIG_LIBDIR="$PKG_CONFIG_LIBDIR"
|
|
export LDFLAGS="$LDFLAGS"
|
|
}
|
|
|
|
unset_build_vars()
|
|
{
|
|
[ -n "$in_chroot" ] && return 0
|
|
|
|
unset LDFLAGS CFLAGS CXXFLAGS CPPFLAGS PKG_CONFIG LD_LIBRARY_PATH
|
|
export LD_LIBRARY_PATH=$SAVE_LDLIBPATH
|
|
}
|
|
|
|
#
|
|
# Applies to the build directory the patches specified by a template.
|
|
#
|
|
apply_tmpl_patches()
|
|
{
|
|
local patch=
|
|
local i=
|
|
|
|
# Apply some build/install patches automatically.
|
|
if [ -f $XBPS_TEMPLATESDIR/$pkgname-fix-build.diff ]; then
|
|
patch_files="$pkgname-fix-build.diff $patch_files"
|
|
fi
|
|
if [ -f $XBPS_TEMPLATESDIR/$pkgname-fix-install.diff ]; then
|
|
patch_files="$pkgname-fix-install.diff $patch_files"
|
|
fi
|
|
|
|
#
|
|
# If package needs some patches applied before building,
|
|
# apply them now.
|
|
#
|
|
for i in ${patch_files}; do
|
|
patch="$XBPS_TEMPLATESDIR/$i"
|
|
if [ ! -f "$patch" ]; then
|
|
msg_warn "unexistent patch: $i."
|
|
continue
|
|
fi
|
|
|
|
cp -f $patch $wrksrc
|
|
|
|
# Try to guess if its a compressed patch.
|
|
if $(echo $patch|grep -q '.diff.gz'); then
|
|
gunzip $wrksrc/$i
|
|
patch=${i%%.gz}
|
|
elif $(echo $patch|grep -q '.diff.bz2'); then
|
|
bunzip2 $wrksrc/$i
|
|
patch=${i%%.bz2}
|
|
elif $(echo $patch|grep -q '.diff'); then
|
|
patch=$i
|
|
else
|
|
msg_warn "unknown patch type: $i."
|
|
continue
|
|
fi
|
|
|
|
cd $wrksrc && patch -s -p0 < $patch 2>/dev/null
|
|
if [ "$?" -eq 0 ]; then
|
|
msg_normal "Patch applied: $i."
|
|
else
|
|
msg_error "couldn't apply patch: $i."
|
|
fi
|
|
done
|
|
|
|
touch -f $XBPS_APPLYPATCHES_DONE
|
|
}
|
|
|
|
#
|
|
# Runs the "configure" phase for a pkg. This setups the Makefiles or any
|
|
# other stuff required to be able to build binaries or such.
|
|
#
|
|
configure_src_phase()
|
|
{
|
|
local pkg="$1"
|
|
local f=
|
|
local destdir=$XBPS_DESTDIR/$pkgname-$version
|
|
|
|
[ -z $pkg ] && [ -z $pkgname ] && return 1
|
|
|
|
#
|
|
# There's nothing we can do if we are a meta template or an
|
|
# {custom,only}_install template.
|
|
#
|
|
[ "$build_style" = "meta-template" -o \
|
|
"$build_style" = "only-install" -o \
|
|
"$build_style" = "custom-install" ] && return 0
|
|
|
|
[ ! -d $wrksrc ] && msg_error "unexistent build directory [$wrksrc]."
|
|
|
|
# Apply patches if requested by template file
|
|
[ ! -f $XBPS_APPLYPATCHES_DONE ] && apply_tmpl_patches
|
|
|
|
# cross compilation vars.
|
|
if [ -n "$cross_compiler" ]; then
|
|
. $XBPS_HELPERSDIR/cross-compilation.sh
|
|
cross_compile_setvars
|
|
else
|
|
if [ "$build_style" = "gnu_configure" ]; then
|
|
configure_args="$configure_args --host=$XBPS_CROSS_HOST"
|
|
configure_args="$configure_args --build=$XBPS_CROSS_HOST"
|
|
fi
|
|
fi
|
|
|
|
# Run pre_configure helpers.
|
|
run_func pre_configure
|
|
|
|
# Export configure_env vars.
|
|
for f in ${configure_env}; do
|
|
export "$f"
|
|
done
|
|
|
|
msg_normal "Running configure phase for $pkgname-$version."
|
|
|
|
[ -z "$configure_script" ] && configure_script="./configure"
|
|
|
|
local _prefix=
|
|
if [ -z "$base_package" ]; then
|
|
_prefix=/usr
|
|
else
|
|
_prefix=
|
|
fi
|
|
|
|
cd $wrksrc || exit 1
|
|
set_build_vars
|
|
|
|
#
|
|
# Packages using GNU autoconf
|
|
#
|
|
if [ "$build_style" = "gnu_configure" ]; then
|
|
${configure_script} \
|
|
--prefix=${_prefix} --sysconfdir=/etc \
|
|
--infodir=$destdir/usr/share/info \
|
|
--mandir=$destdir/usr/share/man \
|
|
${configure_args}
|
|
#
|
|
# Packages using propietary configure scripts.
|
|
#
|
|
elif [ "$build_style" = "configure" ]; then
|
|
${configure_script} ${configure_args}
|
|
#
|
|
# Packages that are perl modules and use Makefile.PL files.
|
|
# They are all handled by the helper perl-module.sh.
|
|
#
|
|
elif [ "$build_style" = "perl_module" ]; then
|
|
. $XBPS_HELPERSDIR/perl-module.sh
|
|
perl_module_build $pkgname
|
|
|
|
#
|
|
# Packages with BSD or GNU Makefiles are easy, just skip
|
|
# the configure stage and proceed.
|
|
#
|
|
elif [ "$build_style" = "bsd_makefile" -o \
|
|
"$build_style" = "gnu_makefile" ]; then
|
|
:
|
|
#
|
|
# Unknown build_style type won't work :-)
|
|
#
|
|
else
|
|
msg_error "unknown build_style [$build_style]"
|
|
exit 1
|
|
fi
|
|
|
|
if [ "$build_style" != "perl_module" -a "$?" -ne 0 ]; then
|
|
msg_error "building $pkg (configure phase)."
|
|
fi
|
|
|
|
# unset configure_env vars.
|
|
for f in ${configure_env}; do
|
|
unset eval ${f%=*}
|
|
done
|
|
|
|
# unset cross compiler vars.
|
|
[ -n "$cross_compiler" ] && cross_compile_unsetvars
|
|
|
|
unset_build_vars
|
|
|
|
touch -f $XBPS_CONFIGURE_DONE
|
|
}
|
|
|
|
#
|
|
# Runs the "build" phase for a pkg. This builds the binaries and other
|
|
# related stuff.
|
|
#
|
|
build_src_phase()
|
|
{
|
|
local pkgparam="$1"
|
|
local pkg="$pkgname-$version"
|
|
local f=
|
|
|
|
[ -z $pkgparam ] && [ -z $pkgname -o -z $version ] && return 1
|
|
|
|
#
|
|
# There's nothing of interest if we are a meta template or an
|
|
# {custom,only}-install template.
|
|
#
|
|
[ "$build_style" = "meta-template" -o \
|
|
"$build_style" = "only-install" -o \
|
|
"$build_style" = "custom-install" ] && return 0
|
|
|
|
[ ! -d $wrksrc ] && msg_error "unexistent build directory [$wrksrc]"
|
|
|
|
cd $wrksrc || exit 1
|
|
|
|
# cross compilation vars.
|
|
if [ -n "$cross_compiler" ]; then
|
|
. $XBPS_HELPERSDIR/cross-compilation.sh
|
|
cross_compile_setvars
|
|
fi
|
|
|
|
[ -z "$make_cmd" ] && make_cmd=/usr/bin/make
|
|
|
|
#
|
|
# Run pre_build helpers.
|
|
#
|
|
run_func pre_build
|
|
|
|
[ -z "$make_build_target" ] && make_build_target=
|
|
[ -n "$XBPS_MAKEJOBS" -a -z "$disable_parallel_build" ] && \
|
|
makejobs="-j$XBPS_MAKEJOBS"
|
|
|
|
# Export make_env vars.
|
|
for f in ${make_env}; do
|
|
export "$f"
|
|
done
|
|
|
|
libtool_fixup_file
|
|
set_build_vars
|
|
msg_normal "Running build phase for $pkg."
|
|
|
|
#
|
|
# Build package via make.
|
|
#
|
|
${make_cmd} ${makejobs} ${make_build_args} ${make_build_target}
|
|
[ $? -ne 0 ] && msg_error "building $pkg (build phase)."
|
|
|
|
unset makejobs
|
|
|
|
#
|
|
# Run pre_install helpers.
|
|
#
|
|
run_func pre_install
|
|
|
|
if [ -z "$libtool_fixup_la_stage" \
|
|
-o "$libtool_fixup_la_stage" = "postbuild" ]; then
|
|
libtool_fixup_la_files
|
|
fi
|
|
|
|
# unset cross compiler vars.
|
|
[ -n "$cross_compiler" ] && cross_compile_unsetvars
|
|
|
|
unset_build_vars
|
|
|
|
touch -f $XBPS_BUILD_DONE
|
|
}
|
|
|
|
#
|
|
# Runs the "install" phase for a pkg. This consists in installing package
|
|
# into the destination directory.
|
|
#
|
|
install_src_phase()
|
|
{
|
|
local pkg="$1"
|
|
local f=
|
|
local i=
|
|
|
|
[ -z $pkg ] && [ -z $pkgname ] && return 1
|
|
#
|
|
# There's nothing we can do if we are a meta template.
|
|
#
|
|
[ "$build_style" = "meta-template" ] && return 0
|
|
|
|
[ ! -d $wrksrc ] && msg_error "unexistent build directory [$wrksrc]"
|
|
|
|
cd $wrksrc || exit 1
|
|
|
|
msg_normal "Running install phase for: $pkgname-$version."
|
|
|
|
# cross compilation vars.
|
|
if [ -n "$cross_compiler" ]; then
|
|
. $XBPS_HELPERSDIR/cross-compilation.sh
|
|
cross_compile_setvars
|
|
fi
|
|
|
|
if [ "$build_style" = "custom-install" ]; then
|
|
run_func do_install
|
|
else
|
|
make_install
|
|
fi
|
|
|
|
#
|
|
# Run post_install helpers.
|
|
#
|
|
run_func post_install
|
|
|
|
# unset cross compiler vars.
|
|
[ -n "$cross_compiler" ] && cross_compile_unsetvars
|
|
|
|
msg_normal "Installed $pkgname-$version into $XBPS_DESTDIR."
|
|
|
|
touch -f $XBPS_INSTALL_DONE
|
|
|
|
#
|
|
# Remove $wrksrc if -C not specified.
|
|
#
|
|
if [ -d "$wrksrc" -a -z "$dontrm_builddir" ]; then
|
|
rm -rf $wrksrc
|
|
[ $? -eq 0 ] && \
|
|
msg_normal "Removed $pkgname-$version build directory."
|
|
fi
|
|
}
|
|
|
|
#
|
|
# Installs a package via 'make install ...'.
|
|
#
|
|
make_install()
|
|
{
|
|
local destdir=$XBPS_DESTDIR/$pkgname-$version
|
|
|
|
if [ -z "$make_install_target" ]; then
|
|
make_install_target="install prefix=$destdir/usr"
|
|
make_install_target="$make_install_target sysconfdir=$destdir/etc"
|
|
fi
|
|
|
|
[ -z "$make_cmd" ] && make_cmd=/usr/bin/make
|
|
|
|
set_build_vars
|
|
#
|
|
# Install package via make.
|
|
#
|
|
${make_cmd} ${make_install_target} ${make_install_args}
|
|
if [ "$?" -ne 0 ]; then
|
|
msg_error "installing $pkgname-$version."
|
|
exit 1
|
|
fi
|
|
|
|
# Replace libtool archives if requested.
|
|
[ "$libtool_fixup_la_stage" = "postinstall" ] && \
|
|
libtool_fixup_la_files "postinstall"
|
|
|
|
# Unset make_env vars.
|
|
for f in ${make_env}; do
|
|
unset eval ${f%=*}
|
|
done
|
|
|
|
# Unset build vars.
|
|
unset_build_vars
|
|
}
|
|
|
|
#
|
|
# Recursive function that founds dependencies in all required
|
|
# packages.
|
|
#
|
|
add_dependency_tolist()
|
|
{
|
|
local curpkg="$1"
|
|
local j=
|
|
|
|
[ -z "$curpkg" ] && return 1
|
|
[ -n "$prev_pkg" ] && curpkg=$prev_pkg
|
|
|
|
if [ "$pkgname" != "${curpkg%-[0-9]*.*}" ]; then
|
|
reset_tmpl_vars
|
|
run_file $XBPS_TEMPLATESDIR/${curpkg%-[0-9]*.*}.tmpl
|
|
fi
|
|
|
|
for j in ${build_depends}; do
|
|
#
|
|
# Check if dep already installed.
|
|
#
|
|
check_installed_pkg $j ${j##[aA-zZ]*-}
|
|
#
|
|
# If dep is already installed, check one more time
|
|
# if all its deps are there and continue.
|
|
#
|
|
if [ $? -eq 0 ]; then
|
|
install_builddeps_required_pkg $j
|
|
installed_deps_list="$j $installed_deps_list"
|
|
continue
|
|
fi
|
|
|
|
deps_list="$j $deps_list"
|
|
[ -n "$prev_pkg" ] && unset prev_pkg
|
|
#
|
|
# Check if dependency needs more deps.
|
|
#
|
|
check_build_depends_pkg ${j%-[0-9]*.*}
|
|
if [ $? -eq 0 ]; then
|
|
add_dependency_tolist $j
|
|
prev_pkg="$j"
|
|
fi
|
|
done
|
|
}
|
|
|
|
#
|
|
# Removes duplicate deps in the installed or not installed list.
|
|
#
|
|
find_dupdeps_inlist()
|
|
{
|
|
local action="$1"
|
|
local tmp_list=
|
|
local dup=
|
|
local f=
|
|
|
|
[ -z "$action" ] && return 1
|
|
|
|
case "$action" in
|
|
installed)
|
|
list=$installed_deps_list
|
|
;;
|
|
notinstalled)
|
|
list=$deps_list
|
|
;;
|
|
*)
|
|
return 1
|
|
;;
|
|
esac
|
|
|
|
for f in $list; do
|
|
if [ -z "$tmp_list" ]; then
|
|
tmp_list="$f"
|
|
else
|
|
for i in $tmp_list; do
|
|
[ "$f" = "$i" ] && dup=yes
|
|
done
|
|
|
|
[ -z "$dup" ] && tmp_list="$tmp_list $f"
|
|
unset dup
|
|
fi
|
|
done
|
|
|
|
case "$action" in
|
|
installed)
|
|
installed_deps_list="$tmp_list"
|
|
;;
|
|
notinstalled)
|
|
deps_list="$tmp_list"
|
|
;;
|
|
*)
|
|
return 1
|
|
;;
|
|
esac
|
|
}
|
|
|
|
#
|
|
# Installs all dependencies required by a package.
|
|
#
|
|
install_dependencies_pkg()
|
|
{
|
|
local pkg="$1"
|
|
local i=
|
|
deps_list=
|
|
installed_deps_list=
|
|
|
|
[ -z "$pkg" ] && return 1
|
|
|
|
doing_deps=true
|
|
|
|
echo -n "=> Calculating dependency list for $pkgname-$version... "
|
|
add_dependency_tolist $pkg
|
|
find_dupdeps_inlist installed
|
|
find_dupdeps_inlist notinstalled
|
|
echo "done."
|
|
|
|
[ -z "$deps_list" -a -z "$installed_deps_list" ] && return 0
|
|
|
|
msg_normal "Required dependencies for $(basename $pkg):"
|
|
for i in ${installed_deps_list}; do
|
|
fpkg="$($XBPS_PKGDB_CMD list|awk '{print $1}'|grep -w ${i%-[0-9]*.*})"
|
|
echo " $i: found $fpkg."
|
|
done
|
|
|
|
for i in ${deps_list}; do
|
|
echo " $i: not found."
|
|
done
|
|
|
|
for i in ${deps_list}; do
|
|
# skip dup deps
|
|
check_installed_pkg $i ${i##[aA-zZ]*-}
|
|
[ $? -eq 0 ] && continue
|
|
# continue installing deps
|
|
msg_normal "Installing $pkg dependency: $i."
|
|
install_pkg ${i%-[0-9]*.*}
|
|
done
|
|
|
|
unset installed_deps_list
|
|
unset deps_list
|
|
}
|
|
|
|
install_builddeps_required_pkg()
|
|
{
|
|
local pkg="$1"
|
|
local dep=
|
|
|
|
[ -z "$pkg" ] && return 1
|
|
|
|
if [ "$pkgname" != "${pkg%-[0-9]*.*}" ]; then
|
|
run_file $XBPS_TEMPLATESDIR/${pkg%-[0-9]*.*}.tmpl
|
|
fi
|
|
|
|
for dep in ${build_depends}; do
|
|
check_installed_pkg $dep ${dep##[aA-zZ]*-}
|
|
if [ $? -ne 0 ]; then
|
|
msg_normal "Installing $pkg dependency: $dep."
|
|
install_pkg ${dep%-[0-9]*.*}
|
|
fi
|
|
done
|
|
}
|
|
|
|
#
|
|
# Checks the registered pkgs db file and returns 0 if a pkg that satisfies
|
|
# the minimal required version is there, or 1 otherwise.
|
|
#
|
|
check_installed_pkg()
|
|
{
|
|
local pkg="$1"
|
|
local reqver="$2"
|
|
local iver=
|
|
|
|
[ -z "$pkg" -o -z "$reqver" -o ! -r $XBPS_PKGDB_FPATH ] && return 1
|
|
|
|
if [ "$pkgname" != "${pkg%-[0-9]*.*}" ]; then
|
|
reset_tmpl_vars
|
|
run_file $XBPS_TEMPLATESDIR/${pkg%-[0-9]*.*}.tmpl
|
|
fi
|
|
|
|
iver="$($XBPS_PKGDB_CMD version $pkgname)"
|
|
if [ -n "$iver" ]; then
|
|
$XBPS_CMPVER_CMD $pkgname-$iver $pkgname-$reqver
|
|
[ $? -eq 0 ] && return 0
|
|
fi
|
|
|
|
return 1
|
|
}
|
|
|
|
#
|
|
# Checks the build depends db file and returns 0 if pkg has dependencies,
|
|
# otherwise returns 1.
|
|
#
|
|
check_build_depends_pkg()
|
|
{
|
|
local pkg="$1"
|
|
|
|
[ -z $pkg ] && return 1
|
|
|
|
if [ "$pkgname" != "${pkg%-[0-9]*.*}" ]; then
|
|
reset_tmpl_vars
|
|
run_file $XBPS_TEMPLATESDIR/${pkg%-[0-9]*.*}.tmpl
|
|
fi
|
|
|
|
if [ -n "$build_depends" ]; then
|
|
return 0
|
|
fi
|
|
|
|
return 1
|
|
}
|
|
|
|
#
|
|
# Installs a pkg by reading its build template file.
|
|
#
|
|
install_pkg()
|
|
{
|
|
local pkg=
|
|
local curpkgn="$1"
|
|
|
|
local cur_tmpl="$XBPS_TEMPLATESDIR/$curpkgn.tmpl"
|
|
if [ -z $cur_tmpl -o ! -f $cur_tmpl ]; then
|
|
msg_error "cannot find $cur_tmpl template build file."
|
|
fi
|
|
|
|
#
|
|
# If we are being invoked through the chroot, re-read config file
|
|
# to get correct stuff.
|
|
#
|
|
if [ -n "$in_chroot" ]; then
|
|
check_config_vars
|
|
set_defvars
|
|
fi
|
|
|
|
reset_tmpl_vars
|
|
run_file $cur_tmpl
|
|
pkg="$curpkgn-$version"
|
|
|
|
#
|
|
# If we are the originator package save the path this template in
|
|
# other var for future use.
|
|
#
|
|
[ -z "$origin_tmpl" ] && origin_tmpl=$pkgname
|
|
|
|
if [ -z "$base_chroot" -a -z "$in_chroot" ]; then
|
|
run_file $XBPS_HELPERSDIR/chroot.sh
|
|
chroot_pkg_handler install $curpkgn
|
|
return $?
|
|
fi
|
|
|
|
#
|
|
# We are going to install a new package.
|
|
#
|
|
prepare_tmpl
|
|
|
|
#
|
|
# Install dependencies required by this package.
|
|
#
|
|
if [ -z "$doing_deps" ]; then
|
|
install_dependencies_pkg $pkg
|
|
#
|
|
# At this point all required deps are installed, and
|
|
# only remaining is the origin template; install it.
|
|
#
|
|
unset doing_deps
|
|
reset_tmpl_vars
|
|
setup_tmpl $curpkgn
|
|
fi
|
|
|
|
#
|
|
# Fetch, extract, build and install into the destination directory.
|
|
#
|
|
fetch_distfiles
|
|
|
|
if [ ! -f "$XBPS_EXTRACT_DONE" ]; then
|
|
extract_distfiles
|
|
fi
|
|
|
|
if [ ! -f "$XBPS_CONFIGURE_DONE" ]; then
|
|
configure_src_phase
|
|
fi
|
|
|
|
if [ ! -f "$XBPS_BUILD_DONE" ]; then
|
|
build_src_phase
|
|
fi
|
|
|
|
install_src_phase
|
|
|
|
#
|
|
# Just register meta-template and exit.
|
|
#
|
|
if [ "$build_style" = "meta-template" ]; then
|
|
$XBPS_PKGDB_CMD register $pkgname $version "$short_desc"
|
|
[ $? -eq 0 ] && \
|
|
msg_normal "Installed meta-template: $pkg." && \
|
|
return 0
|
|
return 1
|
|
fi
|
|
|
|
#
|
|
# Do not stow package if it wasn't requested.
|
|
#
|
|
[ -z "$install_destdir_target" ] && stow_pkg $pkg
|
|
}
|
|
|
|
#
|
|
# Lists files installed by a package.
|
|
#
|
|
list_pkg_files()
|
|
{
|
|
local pkg="$1"
|
|
local f="$XBPS_DESTDIR/$pkg/.xbps-filelist"
|
|
|
|
[ -z $pkg ] && msg_error "unexistent package, aborting."
|
|
|
|
if [ ! -d "$XBPS_DESTDIR/$pkg" ]; then
|
|
msg_error "cannot find $pkg in $XBPS_DESTDIR."
|
|
fi
|
|
|
|
cat $f|sort -u
|
|
}
|
|
|
|
#
|
|
# Removes a currently installed package (unstow + removed from destdir).
|
|
#
|
|
remove_pkg()
|
|
{
|
|
local pkg="$1"
|
|
|
|
[ -z $pkg ] && msg_error "unexistent package, aborting."
|
|
|
|
if [ ! -f "$XBPS_TEMPLATESDIR/$pkg.tmpl" ]; then
|
|
msg_error "cannot find template build file."
|
|
fi
|
|
|
|
run_file $XBPS_TEMPLATESDIR/$pkg.tmpl
|
|
|
|
#
|
|
# If it's a meta-template, just unregister it from the db.
|
|
#
|
|
if [ "$build_style" = "meta-template" ]; then
|
|
$XBPS_PKGDB_CMD unregister $pkgname $version
|
|
[ $? -eq 0 ] && \
|
|
echo "=> Removed meta-template: $pkg."
|
|
return $?
|
|
fi
|
|
|
|
if [ ! -d "$XBPS_DESTDIR/$pkg-$version" ]; then
|
|
msg_error "cannot find package on $XBPS_DESTDIR."
|
|
fi
|
|
|
|
unstow_pkg $pkg
|
|
rm -rf $XBPS_DESTDIR/$pkg-$version
|
|
return $?
|
|
}
|
|
|
|
#
|
|
# Stows a package, i.e copy files from destdir into masterdir.
|
|
#
|
|
stow_pkg()
|
|
{
|
|
local pkg="$1"
|
|
local i=
|
|
local flist="$XBPS_BUILDDIR/.xbps-filelist-$pkgname-$version"
|
|
|
|
[ -z "$pkg" ] && return 2
|
|
|
|
if [ -n "$stow_flag" ]; then
|
|
pkg=$XBPS_TEMPLATESDIR/$pkg.tmpl
|
|
if [ "$pkgname" != "$pkg" ]; then
|
|
run_file $pkg
|
|
fi
|
|
pkg=$pkgname-$version
|
|
#
|
|
# You cannot stow a meta-template.
|
|
#
|
|
[ "$build_style" = "meta-template" ] && return 0
|
|
fi
|
|
|
|
cd $XBPS_DESTDIR/$pkgname-$version || exit 1
|
|
find . > $flist
|
|
sed -i -e "s|^.$||g;s|^./||g;s|.xbps-filelist||g;/^$/d" $flist
|
|
cp -ar . $XBPS_MASTERDIR
|
|
mv -f $flist $XBPS_DESTDIR/$pkgname-$version/.xbps-filelist
|
|
|
|
$XBPS_PKGDB_CMD register $pkgname $version "$short_desc"
|
|
[ $? -ne 0 ] && exit 1
|
|
|
|
#
|
|
# Run template postinstall helpers if requested.
|
|
#
|
|
if [ "$pkgname" != "${pkg%%-$version}" ]; then
|
|
run_file $XBPS_TEMPLATESDIR/${pkg%%-$version}.tmpl
|
|
fi
|
|
|
|
for i in ${postinstall_helpers}; do
|
|
local pihf="$XBPS_HELPERSDIR/$i"
|
|
[ -f "$pihf" ] && . $pihf
|
|
done
|
|
}
|
|
|
|
#
|
|
# Unstow a package, i.e removes its files from masterdir.
|
|
#
|
|
unstow_pkg()
|
|
{
|
|
local pkg="$1"
|
|
local f=
|
|
|
|
[ -z $pkg ] && msg_error "template wasn't specified?"
|
|
|
|
if [ "$pkgname" != "$pkg" ]; then
|
|
run_file $XBPS_TEMPLATESDIR/$pkg.tmpl
|
|
fi
|
|
|
|
#
|
|
# You cannot unstow a meta-template.
|
|
#
|
|
[ "$build_style" = "meta-template" ] && return 0
|
|
|
|
cd $XBPS_DESTDIR/$pkgname-$version || exit 1
|
|
[ ! -f .xbps-filelist ] && exit 1
|
|
|
|
for f in $(cat .xbps-filelist|sort -ur); do
|
|
if [ -f $XBPS_MASTERDIR/$f -o -h $XBPS_MASTERDIR/$f ]; then
|
|
rm $XBPS_MASTERDIR/$f >/dev/null 2>&1
|
|
if [ $? -eq 0 ]; then
|
|
echo "Removing file: $f"
|
|
fi
|
|
fi
|
|
done
|
|
|
|
for f in $(cat .xbps-filelist|sort -ur); do
|
|
if [ -d $XBPS_MASTERDIR/$f ]; then
|
|
rmdir $XBPS_MASTERDIR/$f >/dev/null 2>&1
|
|
if [ $? -eq 0 ]; then
|
|
echo "Removing directory: $f"
|
|
fi
|
|
fi
|
|
done
|
|
|
|
$XBPS_PKGDB_CMD unregister $pkgname $version
|
|
return $?
|
|
}
|
|
|
|
#
|
|
# main()
|
|
#
|
|
while getopts "Cc:" opt; do
|
|
case $opt in
|
|
C) dontrm_builddir=yes;;
|
|
c) config_file_specified=yes; XBPS_CONFIG_FILE="$OPTARG";;
|
|
--) shift; break;;
|
|
esac
|
|
done
|
|
shift $(($OPTIND - 1))
|
|
|
|
[ $# -eq 0 -o $# -gt 2 ] && usage
|
|
|
|
target="$1"
|
|
if [ -z "$target" ]; then
|
|
echo "=> ERROR: missing target."
|
|
usage
|
|
fi
|
|
|
|
#
|
|
# Check configuration vars before anyting else, and set defaults vars.
|
|
#
|
|
check_config_vars
|
|
set_defvars
|
|
|
|
# Main switch
|
|
case "$target" in
|
|
build)
|
|
setup_tmpl $2
|
|
if [ -z "$base_chroot" -a -z "$in_chroot" ]; then
|
|
run_file $XBPS_HELPERSDIR/chroot.sh
|
|
chroot_pkg_handler build $2
|
|
else
|
|
fetch_distfiles $2
|
|
if [ ! -f "$XBPS_EXTRACT_DONE" ]; then
|
|
extract_distfiles $2
|
|
fi
|
|
if [ ! -f "$XBPS_CONFIGURE_DONE" ]; then
|
|
configure_src_phase $2
|
|
fi
|
|
build_src_phase $2
|
|
fi
|
|
;;
|
|
chroot)
|
|
run_file $XBPS_HELPERSDIR/chroot.sh
|
|
chroot_pkg_handler chroot dummy
|
|
;;
|
|
configure)
|
|
setup_tmpl $2
|
|
if [ -z "$base_chroot" -a -z "$in_chroot" ]; then
|
|
run_file $XBPS_HELPERSDIR/chroot.sh
|
|
chroot_pkg_handler configure $2
|
|
else
|
|
fetch_distfiles $2
|
|
if [ ! -f "$XBPS_EXTRACT_DONE" ]; then
|
|
extract_distfiles $2
|
|
fi
|
|
configure_src_phase $2
|
|
fi
|
|
;;
|
|
extract)
|
|
setup_tmpl $2
|
|
fetch_distfiles $2
|
|
extract_distfiles $2
|
|
;;
|
|
fetch)
|
|
setup_tmpl $2
|
|
fetch_distfiles $2
|
|
;;
|
|
info)
|
|
setup_tmpl $2
|
|
info_tmpl $2
|
|
;;
|
|
install-destdir)
|
|
[ -z "$2" ] && msg_error "missing package name after target."
|
|
install_destdir_target=yes
|
|
install_pkg $2
|
|
;;
|
|
install)
|
|
[ -z "$2" ] && msg_error "missing package name after target."
|
|
install_pkg $2
|
|
;;
|
|
list)
|
|
$XBPS_PKGDB_CMD list
|
|
;;
|
|
listfiles)
|
|
[ -z "$2" ] && msg_error "missing package after target."
|
|
list_pkg_files $2
|
|
;;
|
|
remove)
|
|
[ -z "$2" ] && msg_error "missing package name after target."
|
|
remove_pkg $2
|
|
;;
|
|
stow)
|
|
stow_flag=yes
|
|
setup_tmpl $2
|
|
stow_pkg $2
|
|
;;
|
|
unstow)
|
|
setup_tmpl $2
|
|
unstow_pkg $2
|
|
;;
|
|
*)
|
|
echo "=> ERROR: invalid target: $target."
|
|
usage
|
|
esac
|
|
|
|
# Agur
|
|
exit 0
|