mage-next/src/smage2.in

#!/bin/bash
# $Id$

# compiles/installs .smage2 source install scripts
# needs pkgbuild_dir (mage)

# TODO: record dynlib, gz | xz database


# set default variables
: ${MAGERC="@@SYSCONFDIR@@/mage.rc"}
: ${MLIBDIR="@@MAGELIBDIR@@"}

# export default C locale
export LC_ALL=C

# first of all include common functions
source ${MLIBDIR}/common.functions.sh || exit 1
source @@SYSCONFDIR@@/mage.rc.global || die "@@SYSCONFDIR@@/mage.rc.global missing."
source ${MAGERC} || die "${MAGERC} missing."
source ${MLIBDIR}/mage4.functions.sh || die "${MLIBDIR}/mage4.functions.sh missing."
source ${MLIBDIR}/smage2.functions.sh || die "${MLIBDIR}/smage2.functions.sh missing."

# export default path
export PATH="${PATH}:${MLIBDIR}"

print_usage()
{
	echo "Usage: $(basename $0) [option] pkgname ..."
	echo "Options:"
	echo "--smage"
	echo "--src-tarball"
	echo "--calc"
	echo "--update"
	echo "--download"
	echo "--regen"
	echo "--create-src-tarball"
	echo "--resume"
	echo
	echo "Environment variables::"
	echo " NOCOLORS=true $(basename $0) [src]install PACKAGE"
	echo " Disables all colors in the messages."
	echo
}

# very basic getops
for i in $*
do
	case $1 in
		--smage|*.${SMAGESUFFIX}) shift; SMAGENAME="$1" ;;
		--src-tarball) shift; SRCPKGTARBALL="$1" ;;
		--calc) shift; SMAGENAME="$1" ;;
		--update) ;;
		--download) shift; SMAGENAME="$1" ;;
		--regen) shift; SMAGENAME="$1" ;;
		--create-src-tarball) shift; SMAGENAME="$1" ;;
		--resume) ;;
	esac
	shift
done

## setup ##
SMAGENAME="$1"

# expand PKGDIR, BUILDDIR and BINDIR with MROOT
if [[ -n ${MROOT} ]]
then
	export PKGDIR=${MROOT}/${PKGDIR}
	export BUILDDIR=${MROOT}/${BUILDDIR}
	export BINDIR=${MROOT}/${BINDIR}
fi

# print out our version
showversion
echo

if [[ -z ${SMAGENAME} ]]
then
	echo "No .smage2 file given. Exiting."
	echo
	exit 1
fi

# load supported mage features
load_mage_features

# updating smage2-scripts
if [[ $1 = update ]]
then
	if [ ! -d ${SOURCEDIR} ]
	then
		install -d ${SOURCEDIR}
	fi
	syncsmage2
	exit 0
fi

# creates md5sums for smages to given dir
if [[ $1 = calcmd5 ]]
then
	if [ $# -ge 2 ]
	then
		SMAGENAME="$2"
		MD5DIR="$3"
		[[ -z ${MD5DIR} ]] && MD5DIR="$(dirname ${SMAGENAME})/md5"

		smagesource ${SMAGENAME} || die "download source failed"

		# overridable sourcedir; must be declared after source of the smage2
		CALC_SOURCEDIR="${CALC_SOURCEDIR:="${SOURCEDIR}/${PNAME}"}"

		[ -z "${SRC_URI}" ] && die "Nothing declared to calculate."

		# end of array
		EOA=${#SRC_URI[*]}

		[ ! -d ${MD5DIR} ] && install -d ${MD5DIR}

		# clear md5sum file
		MY_MD5_FILE="${MD5DIR}/$(basename ${SMAGENAME} .${SMAGESUFFIX}).md5"
		echo -n > ${MY_MD5_FILE}

		for ((i=0; i < EOA; i++))
		do
			# url to file
			my_SRC_URI="$(echo ${SRC_URI[${i}]} | cut -d' ' -f1)"

			# subdir in sources dir; the my_SRCI_URI file goes to there
			my_SRC_URI_DEST="$(echo ${SRC_URI[${i}]} | cut -d' ' -f2)"

			# if my_src_uri_dest is not equal my_src_uri; than an other dir is used
			if [[ ${my_SRC_URI_DEST} != ${my_SRC_URI} ]]
			then
				MY_SRC_FILE="${my_SRC_URI_DEST}/$(basename ${SRC_URI[${i}]})"
			else
				MY_SRC_FILE="$(basename ${SRC_URI[${i}]})"
			fi

			if [ -e "${CALC_SOURCEDIR}/${MY_SRC_FILE}" ]
			then
				echo "calculating $(basename ${MY_SRC_FILE}) ..."
				( cd ${CALC_SOURCEDIR}; md5sum "${MY_SRC_FILE}" ) >> ${MY_MD5_FILE}
			else
				echo "WARNING: File '$(basename ${MY_SRC_FILE}) not found in ${CALC_SOURCEDIR}."
			fi
			
			# unset them to be shure
			unset my_SRC_URI
			unset my_SRC_URI_DEST
			unset my_SRC_URI_MIRROR
			unset my_SOURCEDIR
		done

		echo
		echo "Calculating of md5 sums for '$(basename ${SMAGENAME} .${SMAGESUFFIX})' done."
		echo
	else
		echo "Usage: Calculating MD5 Sums:"
		echo "    $(basename $0) calcmd5 /path/to/SMAGENAME [/path/to/MD5DIR]"
		echo
		echo
		echo "Export the CALC_SOURCEDIR variable to override current SOURCEDIRs."
		echo
		exit 1
	fi

	exit 0
fi

# download sources
if [ "$1" == "download" -a -n "$2" ]
then
	if [ ! -d ${SMAGESCRIPTSDIR} ]
	then
		install -d ${SMAGESCRIPTSDIR}
	fi

	# get smage
	SMAGENAME="$2"
	MD5DIR="$(dirname ${SMAGENAME})/md5"
	smagesource ${SMAGENAME} || die "download source failed"

	download_sources
	exit 0
fi

# regen-mage-tree
if [ "$1" == "only-regen-tree" -a -n "$2" ]
then
	# set correct SMAGENAME
	SMAGENAME="$2"
	MD5DIR="$(dirname ${SMAGENAME})/md5"
	smagesource ${SMAGENAME} || die "regen: smage2 not found"

	regen_mage_tree

	# build several subpackages
	if [[ -n ${SPLIT_PACKAGES} ]]
	then
		split_save_variables
		for subpackage in ${SPLIT_PACKAGES}
		do
			# get the right variables for the split
			export PNAME="${subpackage}"
			split_info_${subpackage}
			# fix PCATEGORIE -> PCAT
			if [[ ! -z ${PCATEGORIE} ]]
			then
				PCAT="${PCATEGORIE}"
				unset PCATEGORIE
			fi
			# build md5sum for existing packages
			generate_package_md5sum \
				--pcat "${PCAT}" \
				--pname "${PNAME}" \
				--pver "${PVER}" \
				--pbuild "${PBUILD}" \
				--parch "${ARCH}"
			# restore smage environment
			split_restore_variables
		done
		# unset all saved smage variables
		split_unset_variables

	else
		# build md5sum for existing packages
		generate_package_md5sum \
			--pcat "${PCAT}" \
			--pname "${PNAME}" \
			--pver "${PVER}" \
			--pbuild "${PBUILD}" \
			--parch "${ARCH}"
	fi

	exit 0
fi

if [ "$1" == "--create-src-tarball" -a -n "$2" ]
then
	# set correct SMAGENAME
	SMAGENAME="$2"
	MD5DIR="$(dirname ${SMAGENAME})/md5"

	echo -e "${COLGREEN}create-src-tarball called for ${COLBLUE}${SMAGENAME}${COLGREEN} ...${COLDEFAULT}"

	smagesource ${SMAGENAME} || die "regen: smage2 not found"

	if [[ -d ${SOURCEDIR}/${PNAME} ]]
	then
		echo -e "${COLGREEN}Deleting old sourcefiles ${COLBLUE}${SOURCEDIR}/${PNAME}${COLGREEN} ...${COLDEFAULT}"
		rm -rf ${SOURCEDIR}/${PKGNAME}
	fi

	download_sources
	source_pkg_build ${SMAGENAME}
	exit 0
fi

if [ "$1" == "--src-tarball" -a -n "$2" ] || [ "$1" == "-st" -a -n "$2" ]
then
	SRCPKGTARBALL="${2}"
	msetfeature "srcpkgtarball"

	# abort if given file is not a source pkg
	[[ ${SRCPKGTARBALL##*.} != ${SRCPKGSUFFIX} ]] && die "${SRCPKGTARBALL} is not a valid src-pkg file."

	# set correct SMAGENAME; use the one that the src_pkg provide
	# /path/to/SOURCEDIR/PNAME/SMAGENAME
	SMAGENAME="${SOURCEDIR}/$(basename ${SRCPKGTARBALL%-*-*})/$(basename ${SRCPKGTARBALL} .${SRCPKGSUFFIX}).${SMAGESUFFIX}"

	echo -e "${COLGREEN}Using src-tarball ${COLBLUE}${SRCPKGTARBALL}${COLGREEN} ...${COLDEFAULT}"

	[[ ! -d ${SOURCEDIR} ]] && install -d ${SOURCEDIR}

	# unpack srctarball
	[[ ! -f ${SRCPKGTARBALL} ]] && die "Error: ${SRCPKGTARBALL} does not exist. Aborting."	

	tar xvjf ${SRCPKGTARBALL} -C ${SOURCEDIR} || die  "Error unpackung src-tarball ${SRCPKGTARBALL}"

	[[ ! -f ${SMAGENAME} ]] && die "Included smage2 file in src-tarball not found: ${SMAGENAME}"
fi

if [ "$1" == "--resume" -a -n "$2" ]
then
	msetfeature "resume"
	SMAGENAME="$2"
fi

[ ! -e ${MLIBDIR}/pkgbuild_dir ] && die "Error: ${MLIBDIR}/pkgbuild_dir not found. Aborting."
[ -z "$(basename ${SMAGENAME} | grep .${SMAGESUFFIX})" ] &&
	die "File '$(basename ${SMAGENAME})' is not a sMage v${SMAGEVERSION} file. Aborting."
[ -z "${SOURCEDIR}" ] && die "\$SOURCEDIR not found. Please setup your ${MAGERC} correctly."
[ -z "${SMAGESCRIPTSDIR}" ] && die "\$SMAGESCRIPTSDIR not found. Please setup your ${MAGERC} correctly."
[ -z "${SMAGE2RSYNC}" ] && die "\$SMAGE2RSYNC not found. Please setup your ${MAGERC} correctly."
[ -z "${BINDIR}" ] && die "no BINDIR variable found in ${MAGERC}"
[ -z "${CHOST}" ] && die "no CHOST variable found in ${MAGERC}"
[ -z "${CFLAGS}" ] && die "no CFLAGS variable found in ${MAGERC}"
[ -z "${CXXFLAGS}" ] && die "no CXXFLAGS variable found in ${MAGERC}"

smagesource ${SMAGENAME} || die "source failed"
PKGNAME="${PNAME}-${PVER}-${ARCH}$(print_distrotag)-${PBUILD}"
MD5DIR="$(dirname ${SMAGENAME})/md5"
SMAGE_LOG_CMD="tee -a ${SMAGELOGDIR}/${PKGNAME}.log"

xtitle "Compiling ${PKGNAME}"
echo -e "${COLGREEN}Compiling ${PKGNAME}${COLDEFAULT}"

if mqueryfeature "srcpkgbuild"
then
	if [[ -d ${SOURCEDIR}/${PNAME} ]]
	then
		echo -e "${COLBLUE}===${COLGREEN} deleting old sourcefiles ${COLBLUE}${SOURCEDIR}/${PNAME}${COLGREEN} ...${COLDEFAULT}"
		rm -rf ${SOURCEDIR}/${PNAME}
	fi
fi

# download sources
mqueryfeature "srcpkgtarball" || download_sources

# fixes some issues with these functions
export -f pkg_setup || die "pkg_setup export failed"
export -f src_prepare || die "src_prepare export failed"
export -f src_compile || die "src_compile export failed"
export -f src_check || die "src_check export failed"
export -f src_install || die "src_install export failed"

# fixes some compile issues
export CHOST="${CHOST}" || die "CHOST export failed"
export CPPFLAGS="${CPPFLAGS}" || die "CPPFLAGS export failed"
export CFLAGS="${CFLAGS}" || die "CFLAGS export failed"
if [[ -z ${CXXFLAGS} ]]
then
	export CXXFLAGS="${CFLAGS}" || die "CXXFLAGS export failed"
else
	export CXXFLAGS="${CXXFLAGS}" || die "CXXFLAGS export failed"
fi
export LDFLAGS="${LDFLAGS}" || die "LDFLAGS export failed"
export BINDIR="${BINDIR}" || die "BINDIR export failed"
export MAKEOPTS="${MAKEOPTS}" || die "MAKEOPTS export failed"

# setup distcc
# setup for distcc goes *before* ccache, so ccache comes before distcc in path
mqueryfeature "distcc" && setup_distcc_environment

# setup icecc
# setup for icecc goes *before* ccache, so ccache comes before icecc in path
mqueryfeature "icecc" && setup_icecc_environment

# setup ccache
mqueryfeature "ccache" && setup_ccache_environment

if mqueryfeature "resume"
then
	echo -e "${COLMAGENTA}Resume requested; continuing previous build${COLDEFAULT}"

	# setup build logging
	[[ ! -d ${SMAGELOGDIR} ]] && install -d ${SMAGELOGDIR}
	if [[ -f ${SMAGELOGDIR}/${PKGNAME}.log.bz2 ]]
	then
		bunzip2 -f ${SMAGELOGDIR}/${PKGNAME}.log.bz2
	fi
	echo -e "### Resume started on $(date) ###\n" >> ${SMAGELOGDIR}/${PKGNAME}.log

else
	# clean up builddir if a previously one exist
	if [ -d ${BUILDDIR} ]
	then
		rm -rf ${BUILDDIR}/* || die "couldn't cleanup \$BUILDDIR."
	fi
	install -d ${BUILDDIR} || die "couldn't create \$BUILDDIR."

	# clean up srcdir if a previously unpacked one exist
	if [ -d ${SRCDIR} ]
	then
		rm -rf ${SRCDIR}
	fi

	# clean up bindir if a previous build exist or create a new one
	if [ -d ${BINDIR} ]
	then
		rm -rf ${BINDIR}
	fi
	install -d ${BINDIR} || die "couldn't create \$BINDIR."

	# clean up package temp dir if a previous build exist
	if [ -d ${BUILDDIR}/${PKGNAME} ]
	then
		rm -rf ${BUILDDIR}/${PKGNAME}
	fi

	# clean up stamps dir
	if [ -d ${BUILDDIR}/.stamps ]
	then
		rm -rf ${BUILDDIR}/.stamps
	fi

	# setup build logging
	[[ ! -d ${SMAGELOGDIR} ]] && install -d ${SMAGELOGDIR}
	echo -e "### Build started on $(date) ###\n" > ${SMAGELOGDIR}/${PKGNAME}.log
fi

if [[ ${PKGTYPE} = virtual ]]
then
	echo "virtual package detected; nothing will be build ..."
	# automatically set !pkgbuild here too
	msetfeature "!pkgbuild"
else
	( run_resume pkg_setup || pkg_setup ) |& ${SMAGE_LOG_CMD}
	die_pipestatus 0 "pkg_setup failed"
	resume_stamp pkg_setup
	step_by_step pkg_setup

	( run_resume src_prepare || src_prepare ) |& ${SMAGE_LOG_CMD}
	die_pipestatus 0 "src_prepare failed"
	resume_stamp src_prepare
	step_by_step src_prepare

	( run_resume src_compile || src_compile ) |& ${SMAGE_LOG_CMD}
	die_pipestatus 0 "src_compile failed"
	resume_stamp src_compile
	step_by_step src_compile

	# only run checks if requested
	if mqueryfeature "!check"
	then
		echo "!check detected; src_check() will not be run!" |& ${SMAGE_LOG_CMD}
	else
		( run_resume src_check || src_check ) |& ${SMAGE_LOG_CMD}
		die_pipestatus 0 "src_check failed"
		resume_stamp src_check
	fi
	step_by_step src_check

	# build several subpackages
	if [[ -n ${SPLIT_PACKAGES} ]]
	then
		# save bindir & pname
		split_save_variables
		export SAVED_BINDIR="${BINDIR}"
		for subpackage in ${SPLIT_PACKAGES}
		do
			split_info_${subpackage}
			if [[ ${PKGTYPE} = virtual ]]
			then
				echo
				echo -en "${COLBLUE}*** ${COLDEFAULT}"
				echo -en "Virtual package detected"
				echo -en " for subpkg: ${COLBLUE}${PNAME}${COLDEFAULT}"
				echo -e " - basepkg: ${COLBLUE}${SPLIT_PACKAGE_BASE}${COLDEFAULT} ..."

				echo "virtual package detected; nothing will be build ..."
				# automatically set !pkgbuild here too
				msetfeature "!pkgbuild"
			else
				if typeset -f src_install_${subpackage} > /dev/null
				then
					# export subpackage bindir
					export BINDIR="${SAVED_BINDIR}_${subpackage}"
					# export PNAME, several internal function and include
					# rely on this variable
					export PNAME="${subpackage}"

					echo
					echo -en "${COLBLUE}*** ${COLDEFAULT}"
					echo -en "Running ${COLGREEN}split src_install()${COLDEFAULT}"
					echo -en " for subpkg: ${COLBLUE}${PNAME}${COLDEFAULT}"
					echo -e " - basepkg: ${COLBLUE}${SPLIT_PACKAGE_BASE}${COLDEFAULT} ..."

					( run_resume src_install_${subpackage} || src_install_${subpackage} ) |& ${SMAGE_LOG_CMD}
					die_pipestatus 0 "src_install_${subpackage} failed"
					resume_stamp src_install_${subpackage}
					step_by_step src_install_${subpackage}
				fi
			fi
			# restore smage environment
			split_restore_variables
		done
		# unset all saved smage variables
		split_unset_variables
	else
		( run_resume src_install || src_install ) |& ${SMAGE_LOG_CMD}
		die_pipestatus 0 "src_install failed"
		resume_stamp src_install
		step_by_step src_install
	fi
fi

# echo for sake of good-looking
echo

if mqueryfeature "!compressdoc"
then
	echo -e "!compressdoc detected; documentation will not be compressed ..."
elif mqueryfeature "!pkgbuild"
then
		echo "!pkgbuild detected; skipping documentation compression..."
else
	# compressing doc, info & man files
	if [[ -n ${SPLIT_PACKAGES} ]]
	then
		# save smage environment
		split_save_variables
		for subpackage in ${SPLIT_PACKAGES}
		do
			# honor split_info
			split_info_${subpackage}
			if [[ ${PKGTYPE} = virtual ]]
			then
				# automatically set !pkgbuild here too
				msetfeature "!pkgbuild"
			fi

			if mqueryfeature "!compressdoc"
			then
				echo -e "!compressdoc detected; documentation of '${subpackage}' will not be compressed ..."
			elif mqueryfeature "!pkgbuild"
			then
				echo "!pkgbuild detected; skipping documentation compression for '${subpackage}' ..."
			else
				run_resume post-mcompressdoc_${subpackage} || mcompressdocs ${BINDIR}_${subpackage}
				resume_stamp post-mcompressdoc_${subpackage}
			fi
			# restore smage environment
			split_restore_variables
		done
		# unset saved variables
		split_unset_variables
	else
		run_resume post-mcompressdoc || mcompressdocs ${BINDIR}
		resume_stamp post-mcompressdoc
	fi
fi

if mqueryfeature "!libtool"
then
	if mqueryfeature "!pkgbuild"
	then
		echo "!pkgbuild detected; skipping libtool archive stripping ..."
	else
		if [[ -n ${SPLIT_PACKAGES} ]]
		then
			# save smage environment
			split_save_variables
			for subpackage in ${SPLIT_PACKAGES}
			do
				# honor split_info
				split_info_${subpackage}
				if [[ ${PKGTYPE} = virtual ]]
				then
					# automatically set !pkgbuild here too
					msetfeature "!pkgbuild"
				fi

				if mqueryfeature "!libtool"
				then
					if mqueryfeature "!pkgbuild"
					then
						echo "!pkgbuild detected; skipping libtool archive stripping for '${subpackage}'..."
					else
						echo -e "${COLBLUE}===${COLGREEN} stripping libtool archives for '${subpackage}' ...${COLDEFAULT}"
						run_resume post-mstriplibtoolarchive_${subpackage} || mstriplibtoolarchive ${BINDIR}_${subpackage}
						resume_stamp post-mstriplibtoolarchive_${subpackage}
					fi
				fi

				# restore smage environment
				split_restore_variables
			done
			# unset saved variables
			split_unset_variables
		else
			echo -e "${COLBLUE}===${COLGREEN} stripping libtool archives ...${COLDEFAULT}"
			run_resume post-mstriplibtoolarchive || mstriplibtoolarchive ${BINDIR}
			resume_stamp post-mstriplibtoolarchive
		fi
	fi
fi

if mqueryfeature "purge"
then
	if mqueryfeature "!pkgbuild"
	then
		echo "!pkgbuild detected; skipping file purgation ..."
	else
		if [[ -n ${SPLIT_PACKAGES} ]]
		then
			# save smage environment
			split_save_variables
			for subpackage in ${SPLIT_PACKAGES}
			do
				# honor split_info
				split_info_${subpackage}
				if [[ ${PKGTYPE} = virtual ]]
				then
					# automatically set !pkgbuild here too
					msetfeature "!pkgbuild"
				fi

				if mqueryfeature "purge"
				then
					if mqueryfeature "!pkgbuild"
					then
						echo "!pkgbuild detected; skipping file purgation for '${subpackage}' ..."
					else
						echo -e "${COLBLUE}===${COLGREEN} purging all purge targets in '${subpackage}' ...${COLDEFAULT}"
						run_resume post-mpurgetargets_${subpackage} || mpurgetargets ${BINDIR}_${subpackage}
						resume_stamp post-mpurgetargets_${subpackage}
					fi
				fi

				# restore smage environment
				split_restore_variables
			done
			# unset saved variables
			split_unset_variables
		else
			echo -e "${COLBLUE}===${COLGREEN} purging all purge targets ...${COLDEFAULT}"
			run_resume post-mpurgetargets || mpurgetargets ${BINDIR}
			resume_stamp post-mpurgetargets
		fi
	fi
fi

# stripping all bins and libs
if mqueryfeature "!strip"
then
	echo -e "!strip detected; package will not be stripped ..."
elif mqueryfeature "!pkgbuild"
then
	echo "!pkgbuild detected; skipping stripping of the package ..."
else
	if [[ -n ${SPLIT_PACKAGES} ]]
	then
		# save smage environment
		split_save_variables
		for subpackage in ${SPLIT_PACKAGES}
		do
			# honor split_info
			split_info_${subpackage}
			if [[ ${PKGTYPE} = virtual ]]
			then
				# automatically set !pkgbuild here too
				msetfeature "!pkgbuild"
			fi

			if mqueryfeature "!strip"
			then
				echo -e "!strip detected; package '${subpackage}' will not be stripped ..."
			elif mqueryfeature "!pkgbuild"
			then
				echo "!pkgbuild detected; skipping stripping of the package '${subpackage}' ..."
			else
				echo -e "${COLBLUE}===${COLGREEN} stripping binaries for '${subpackage}' ...${COLDEFAULT}"
				run_resume post-mstripbins_${subpackage} || mstripbins ${BINDIR}_${subpackage}
				resume_stamp post-mstripbins_${subpackage}
				echo -e "${COLBLUE}===${COLGREEN} stripping dynamic libraries for '${subpackage}' ...${COLDEFAULT}"
				run_resume post-mstriplibs_${subpackage} || mstriplibs ${BINDIR}_${subpackage}
				resume_stamp post-mstriplibs_${subpackage}
				echo -e "${COLBLUE}===${COLGREEN} stripping static libraries for '${subpackage}' ...${COLDEFAULT}"
				run_resume post-mstripstatic_${subpackage} || mstripstatic ${BINDIR}_${subpackage}
				resume_stamp post-mstripstatic_${subpackage}
			fi

			# restore smage environment
			split_restore_variables
		done
		# unset saved variables
		split_unset_variables
	else
			echo -e "${COLBLUE}===${COLGREEN} stripping binaries ...${COLDEFAULT}"
			run_resume post-mstripbins || mstripbins ${BINDIR}
			resume_stamp post-mstripbins
			echo -e "${COLBLUE}===${COLGREEN} stripping dynamic libraries ...${COLDEFAULT}"
			run_resume post-mstriplibs || mstriplibs ${BINDIR}
			resume_stamp post-mstriplibs
			echo -e "${COLBLUE}===${COLGREEN} stripping static libraries ...${COLDEFAULT}"
			run_resume post-mstripstatic || mstripstatic ${BINDIR}
			resume_stamp post-mstripstatic
	fi
fi

if mqueryfeature "qalint"
then
	if mqueryfeature "!pkgbuild"
	then
		echo "!pkgbuild detected; skipping QA lint checks ..."
	else
		if [[ -n ${SPLIT_PACKAGES} ]]
		then
			# save smage environment
			split_save_variables
			for subpackage in ${SPLIT_PACKAGES}
			do
				# honor split_info
				split_info_${subpackage}
				if [[ ${PKGTYPE} = virtual ]]
				then
					# automatically set !pkgbuild here too
					msetfeature "!pkgbuild"
				fi

				if mqueryfeature "qalint"
				then
					if mqueryfeature "!pkgbuild"
					then
						echo "!pkgbuild detected; skipping QA lint checks for '${subpackage}' ..."
					else
						echo -e "${COLBLUE}===${COLGREEN} running QA lint checks for '${subpackage}' ...${COLDEFAULT}"
						mqalint ${BINDIR}_${subpackage}
					fi
				fi

				# restore smage environment
				split_restore_variables
			done
			# unset saved variables
			split_unset_variables
		else
			echo -e "${COLBLUE}===${COLGREEN} running QA lint checks ...${COLDEFAULT}"
			mqalint ${BINDIR}
		fi
	fi
fi

if mqueryfeature "!pkgbuild"
then
		echo -e "!pkgbuild detected; Package will not be build ..."
else
		# build several subpackages
		if [[ -n ${SPLIT_PACKAGES} ]]
		then
			split_save_variables
			for subpackage in ${SPLIT_PACKAGES}
			do
				# get the right variables for the split
				export PNAME="${subpackage}"
				split_info_${PNAME}
				# fix PCATEGORIE -> PCAT
				if [[ ! -z ${PCATEGORIE} ]]
				then
					PCAT="${PCATEGORIE}"
					unset PCATEGORIE
				fi
				if [[ ${PKGTYPE} = virtual ]]
				then
					# automatically set !pkgbuild here too
					msetfeature "!pkgbuild"
				fi

				# jump to next one if !pkgbuild is set in split_info
				if mqueryfeature "!pkgbuild"
				then
					# restore smage environment
					split_restore_variables
					continue
				fi

				# check if an special subpackage_pkgbuild exists
				if typeset -f ${PNAME}_pkgbuild > /dev/null
				then
					# run it
					run_resume post-${PNAME}_pkgbuild || ${PNAME}_pkgbuild
					resume_stamp post-${PNAME}_pkgbuild
				fi
				# now create the target package
				run_resume post-pkg_builddir_${PNAME} || ${MLIBDIR}/pkgbuild_dir \
					"${PNAME}-${PVER}-${ARCH}$(print_distrotag)-${PBUILD}" \
					"${BINDIR}_${PNAME}" || die "split_package: ${PNAME} package-build failed"
				resume_stamp post-pkg_builddir_${PNAME}

				# build pkg-md5-sum if requested
				run_resume post-md5sum_${PNAME} || generate_package_md5sum \
					--pcat "${PCAT}" \
					--pname "${PNAME}" \
					--pver "${PVER}" \
					--pbuild "${PBUILD}" \
					--parch "${ARCH}"
				resume_stamp post-md5sum_${PNAME}

				echo -e "${COLGREEN}\nPackage ${PNAME}-${PVER}-${ARCH}$(print_distrotag)-${PBUILD} successfully builded.\n${COLDEFAULT}"

				# restore smage environment
				split_restore_variables
			done
			# unset all saved smage variables
			split_unset_variables

		else
			run_resume post-pkg_builddir || ${MLIBDIR}/pkgbuild_dir ${PKGNAME} ${BINDIR} || die "package-build failed"
			resume_stamp post-pkg_builddir

			# build pkg-md5-sum if requested
			run_resume post-md5sum || generate_package_md5sum \
				--pcat "${PCAT}" \
				--pname "${PNAME}" \
				--pver "${PVER}" \
				--pbuild "${PBUILD}" \
				--parch "${ARCH}"
			resume_stamp post-md5sum

			echo -e "${COLGREEN}\nPackage ${PKGNAME} successfully builded.\n${COLDEFAULT}"
		fi

		# build src-pkg-tarball if requested
		if mqueryfeature "srcpkgbuild"
		then
			run_resume post-srcpkgbuild || source_pkg_build ${SMAGENAME}
			resume_stamp post-srcpkgbuild
		fi
fi

# auto regen mage tree if requested
regen_mage_tree

if mqueryfeature "buildlog"
then
	bzip2 -9f ${SMAGELOGDIR}/${PKGNAME}.log
else
	[[ -f ${SMAGELOGDIR}/${PKGNAME}.log ]] && rm ${SMAGELOGDIR}/${PKGNAME}.log
fi

xtitleclean