Diff of /branches/mage-next/src/smage2.in

Parent Directory | Revision Log | Patch

	revision 169 by niro, Sun Jul 31 11:57:05 2005 UTC	revision 1580 by niro, Wed Dec 28 11:58:28 2011 UTC
#	Line 1	Line 1
1	#!/bin/bash	#!/bin/bash
2		# $Id$
3
4	# compiles/installs .smage2 source install scripts	# compiles/installs .smage2 source install scripts
5	# needs pkgbuild_dir (mage)	# needs pkgbuild_dir (mage)
6
7	# SMAGE2	# TODO: record dynlib, gz | xz database
	# $Header: /home/cvsd/magellan-cvs/magellan-src/mage/usr/lib/mage/smage2.sh,v 1.16 2005-07-31 11:57:05 niro Exp $
8
9	#01.10.2004
10	# added ccache support	# set default user mage.rc
11	# added distcc support	: ${MAGERC="/etc/mage.rc"}
12
13	## setup ##	## setup ##
	SMAGEVERSION=0.3.6-r19
	PKGSUFFIX="mpk"
14	SMAGENAME="$1"	SMAGENAME="$1"
15	SMAGESUFFIX="smage2"	SMAGEVERSION="$( < ${MLIBDIR}/version)"
	#SOURCEDIR="/bootstrap/sources"
	#SMAGESCRIPTSDIR="/bootstrap/smage2-install-scripts"
	#SMAGE2RSYNC="rsync://192.168.0.2/smage2-scripts"
	MLIBDIR=/usr/lib/mage
16
17	# export default C locale	# export default C locale
18	export LC_ALL=C	export LC_ALL=C
19
20	source /etc/mage.rc	source /etc/mage.rc.global
21		source ${MAGERC}
22		source ${MLIBDIR}/mage4.functions.sh
23
24		# set PKGDIR and BUILDDIR and BINDIR to MROOT
25		if [[ -n ${MROOT} ]]
26		then
27		export PKGDIR=${MROOT}/${PKGDIR}
28		export BUILDDIR=${MROOT}/${BUILDDIR}
29		export BINDIR=${MROOT}/${BINDIR}
30		fi
31
32		# sources the smage file and uses state from distribution file if exist
33		# may helpful for repository support later on
34		smagesource()
35		{
36		local file="$1"
37		local mystate
38		local mycodename
39
40		source ${file}
41
42		[[ -n ${STATE} ]] && mystate="${STATE}"
43
44		# do not overide if local state was broken or disabled!
45		case ${STATE} in
46		broken) return ;;
47		disabled) return ;;
48		esac
49
50		if [ -f ${SMAGESCRIPTSDIR}/distribution ]
51		then
52		source ${SMAGESCRIPTSDIR}/distribution
53		[[ -n ${STATE} ]] && mystate="${STATE}"
54		fi
55		# now switch state and export it
56		STATE="${mystate}"
57		}
58
59	showversion() {	showversion()
60		{
61	echo -en "Magellan Source Install v${SMAGEVERSION} "	echo -en "Magellan Source Install v${SMAGEVERSION} "
62	echo -e  "-- Niels Rogalla (niro@magellan-linux.de)"	echo -e  "-- Niels Rogalla (niro@magellan-linux.de)"
63	}	}
64
65	die() {	die()
66		{
67	xtitleclean	xtitleclean
68		echo -e ${COLRED}"Exited ${BASH_SOURCE} at line no ${BASH_LINENO}."${COLDEFAULT}
69	echo "SMAGE failed: $@"	echo "SMAGE failed: $@"
70	exit 1	exit 1
71	}	}
72
73	xtitle() {	die_pipestatus()
74	if [ ${TERM} == "xterm" ]	{
75		# the status change if we do any parameter declarations!!
76		# dont do this anymore, keep this in mind!
77		#
78		# local pos="$1"
79		# local comment="$2"
80		#
81		# [ ${PIPESTATUS[${pos}]} -ne 0 ] && die "${comment}"
82		#
83		[ ${PIPESTATUS[$1]} -ne 0 ] && die "$2"
84		}
85
86		xtitle()
87		{
88		if [[ ${TERM} = xterm ]]
89	then	then
90	echo -ne "\033]0;[sMage: $@]\007"	echo -ne "\033]0;[sMage: $@]\007"
91	fi	fi
92	return 0	return 0
93	}	}
94
95	xtitleclean() {	xtitleclean()
96	if [ ${TERM} == "xterm" ]	{
97		if [[ ${TERM} = xterm ]]
98	then	then
99	echo -ne "\033]0;\007"	echo -ne "\033]0;\007"
100	fi	fi
101	return 0	return 0
102	}	}
103
104	syncsmage2() {	syncsmage2()
105		{
106	xtitle "Updating smage2-script tree ..."	xtitle "Updating smage2-script tree ..."
107	local i	local i
108	for i in ${SMAGE2RSYNC}	for i in ${SMAGE2RSYNC}
109	do	do
110	rsync \	rsync ${RSYNC_FETCH_OPTIONS} ${i} ${SMAGESCRIPTSDIR}
111	--recursive \	if [[ $? = 0 ]]
	--links \
	--perms \
	--times \
	--devices \
	--timeout=600 \
	--verbose \
	--compress \
	--progress \
	--stats \
	--delete \
	--delete-after \
	${i} ${SMAGESCRIPTSDIR}
	if [ "$?" == "0" ]
112	then	then
113	break	break
114	else	else
115	continue	continue
116	fi	fi
117	done	done
118
119	#clean up backup files (foo~)	# clean up backup files (foo~)
120	find ${SMAGESCRIPTSDIR} -name *~ -exec rm '{}' ';'	find ${SMAGESCRIPTSDIR} -name *~ -exec rm '{}' ';'
121
122	xtitleclean	xtitleclean
123	}	}
124
125	# $1 filename	# $1 filename
126	get_db_md5_sum() {	get_db_md5_sum()
127		{
128	local DB_FILE	local DB_FILE
129	local MD5_FILE	local MD5_FILE
130	local i	local i
#	Line 101  get_db_md5_sum() {	Line 137  get_db_md5_sum() {
137	echo "${i}"	echo "${i}"
138	}	}
139
140	download_sources() {	download_sources()
141		{
142	[ -z "${SRC_URI}" ] && echo -e "\nNothing declared to download.\n" && return 0	[ -z "${SRC_URI}" ] && echo -e "\nNothing declared to download.\n" && return 0
143
144	local EOA=${#SRC_URI[*]}	local count=${#SRC_URI[*]}
145	local my_SRC_URI	local uri
146	local my_SRC_URI_DEST	local subdir
147	local my_SRC_URI_MIRROR	local outputdir
148	local my_SOURCEDIR	local db_md5_file="${MD5DIR}/$(basename ${SMAGENAME} .${SMAGESUFFIX}).md5"
149	local DB_MD5_SUM_FILE="${MD5DIR}/$(basename ${SMAGENAME} .${SMAGESUFFIX}).md5"	local fetching
150	local FETCHING	local i
	local i mirror
	#install SRCDIR/PNAME if not exist
	[ ! -d ${SOURCEDIR}/${PNAME} ] && install -d ${SOURCEDIR}/${PNAME}
151
152	# check if FETCHING is needed	# check if FETCHING is needed
153	( cd ${SOURCEDIR}/${PNAME}; md5sum --check ${DB_MD5_SUM_FILE} &> /dev/null )	if mchecksum --rundir "${SOURCEDIR}/${PNAME}" --file "${db_md5_file}" --method md5
	if [[ $? == 0 ]]
154	then	then
155	# md5's ok, not fetching needed	# md5's ok, no fetching needed
156	FETCHING=false	fetching=false
157	else	else
158	FETCHING=true	fetching=true
159	fi	fi
	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)"
160
161	# if my_src_uri_dest is not equal my_src_uri; than an other dir is used	if [[ ${fetching} = true ]]
162	if [[ ${my_SRC_URI_DEST} != ${my_SRC_URI} ]]	then
163	then	for ((i=0; i < count; i++))
164	my_SOURCEDIR="${SOURCEDIR}/${PNAME}/${my_SRC_URI_DEST}"	do
165	else	# url to file
166	my_SOURCEDIR="${SOURCEDIR}/${PNAME}"	uri="${SRC_URI[${i}]%%' '*}"
	fi
167
168	# if an mirrored file than replace first the mirror uri	# subdir in sources dir; the my_SRCI_URI file goes to there
169	if [ -n "$(echo ${my_SRC_URI} | grep 'mirror://')" ]	subdir="${SRC_URI[${i}]##*' '}"
	then
	for mirror in ${MIRRORS}
	do
	my_SRC_URI_MIRROR="$(echo ${my_SRC_URI} | sed "s|mirror:/|${mirror}/sources|g")"
170
171	#echo "DEBUG: ${MY_SRC_URI}"	# if $subdir is not equal with $uri then an other dir is used
172	if [[ ${FETCHING} == true ]]	if [[ ${uri} != ${subdir} ]]
	then
	echo "==> fetching ${my_SRC_URI_MIRROR}"
	wget \
	--passive-ftp \
	--tries 3 \
	--continue \
	--progress bar \
	--directory-prefix="${my_SOURCEDIR}" \
	"${my_SRC_URI_MIRROR}"
	if [ "$?" == "0" ]
	then
	break
	else
	continue
	fi
	fi
	done
	else
	#echo "DEBUG: ${SRC_URI[${i}]}"
	if [[ ${FETCHING} == true ]]
173	then	then
174	echo "==> fetching ${my_SRC_URI}"	outputdir="${SOURCEDIR}/${PNAME}/${subdir}"
175	wget \	else
176	--passive-ftp \	outputdir="${SOURCEDIR}/${PNAME}"
	--tries 3 \
	--continue \
	--progress bar \
	--directory-prefix="${my_SOURCEDIR}" \
	"${my_SRC_URI}"
	# only needed to run through a list of mirrors
	# if [ "$?" == "0" ]
	# then
	# break
	# else
	# continue
	# fi
177	fi	fi
	fi
	# unset them to be shure
	unset my_SRC_URI
	unset my_SRC_URI_DEST
	unset my_SRC_URI_MIRROR
	unset my_SOURCEDIR
	done
178
179	# recheck md5 sums	echo -e "${COLBLUE}==>${COLGREEN} fetching ${uri}${COLDEFAULT}"
180	echo	mdownload --uri "${uri}" --dir "${outputdir}" || die "Could not download '${uri}'"
181	echo ">== Checking MD5 sums:"
182	( cd ${SOURCEDIR}/${PNAME}; md5sum --check ${DB_MD5_SUM_FILE} ) || die "md5 failed"	# unset them to be sure
183	echo	unset uri
184		unset subdir
185		unset outputdir
186		done
187
188		# recheck md5 sums after download
189		echo
190		echo -e "${COLBLUE}===${COLGREEN} Checking MD5 sums:${COLDEFAULT}"
191		mchecksum --rundir "${SOURCEDIR}/${PNAME}" --file "${db_md5_file}" --method md5 || die "md5 failed"
192		echo
193		else
194		echo -e "${COLBLUE}===${COLGREEN} All sources already fetched, nothing to do${COLDEFAULT}"
195		fi
196
197	# not needed anymore	# not needed anymore
198	unset SRC_URI	unset SRC_URI
199	}	}
200
201	# dummy function, used if that not exist in smage file	# dummy function, used if that does not exist in smage file
202	src_prepare() {	src_prepare()
203		{
204	echo "no src_prepare defined"	echo "no src_prepare defined"
	sleep 2
205	return 0	return 0
206	}	}
207
208	# dummy function, used if that not exist in smage file	# dummy function, used if that does not exist in smage file
209	src_compile() {	src_compile()
210		{
211	echo "no src_compile defined"	echo "no src_compile defined"
	sleep 2
212	return 0	return 0
213	}	}
214
215	# dummy function, used if that not exist in smage file	# dummy function, used if that does not exist in smage file
216	src_install() {	src_check()
217		{
218		echo "no src_check defined"
219		return 0
220		}
221
222		# dummy function, used if that does not exist in smage file
223		src_install()
224		{
225	echo "no src_install defined"	echo "no src_install defined"
	sleep 2
226	return 0	return 0
227	}	}
228
229		mlibdir()
230		{
231		local libdir=lib
232		[[ ${ARCH} = x86_64 ]] && libdir=lib64
233
234	build_mage_script() {	echo "${libdir}"
	return 0
235	}	}
236
237	mconfigure() {	mconfigure()
238		{
239	if [ -x ./configure ]	if [ -x ./configure ]
240	then	then
241	./configure \	./configure \
242	--prefix=/usr \	--prefix=/usr \
243	--host=${CHOST} \	--host=${CHOST} \
244	--mandir=/usr/share/man \	--build=${CHOST} \
245	--infodir=/usr/share/info \	--mandir=/usr/share/man \
246	--datadir=/usr/share \	--infodir=/usr/share/info \
247	--sysconfdir=/etc \	--datadir=/usr/share \
248	--localstatedir=/var/lib \	--sysconfdir=/etc \
249	"$@" || die "mconfigure failed"	--localstatedir=/var/lib \
250		--libdir=/usr/$(mlibdir) \
251		"$@" || die "mconfigure failed"
252	else	else
253	echo "configure is not an executable ..."	echo "configure is not an executable ..."
254	exit 1	exit 1
255	fi	fi
256	}	}
257
258	minstall() {	minstall()
259	if [ -f ./[mM]akefile -o -f ./GNUmakefile ] ; then	{
260		if [ -f ./[mM]akefile -o -f ./GNUmakefile ]
261		then
262	make prefix=${BINDIR}/usr \	make prefix=${BINDIR}/usr \
263	datadir=${BINDIR}/usr/share \	datadir=${BINDIR}/usr/share \
264	infodir=${BINDIR}/usr/share/info \	infodir=${BINDIR}/usr/share/info \
265	localstatedir=${BINDIR}/var/lib \	localstatedir=${BINDIR}/var/lib \
266	mandir=${BINDIR}/usr/share/man \	mandir=${BINDIR}/usr/share/man \
267	sysconfdir=${BINDIR}/etc \	sysconfdir=${BINDIR}/etc \
268		libdir=${BINDIR}/usr/$(mlibdir) \
269	"$@" install || die "minstall failed"	"$@" install || die "minstall failed"
270	else	else
271	die "no Makefile found"	die "no Makefile found"
272	fi	fi
273	}	}
274
275	mmake() {	mmake()
276		{
277	make ${MAKEOPTS} ${EXTRA_EMAKE} "$@"	make ${MAKEOPTS} ${EXTRA_EMAKE} "$@"
278	}	}
279
280	munpack() {	munpack()
281		{
282	local SRCFILE	local SRCFILE
283	local IFTAR	local IFTAR
284	local DEST	local DEST
285
286	SRCFILE=$1	SRCFILE=$1
287
288	if [ -z "$2" ]	if [[ -z $2 ]]
289	then	then
290	DEST=${BUILDDIR}	DEST=${BUILDDIR}
291	else	else
292	DEST=$2	DEST=$2
293	fi	fi
294
295		[[ ! -d ${DEST} ]] && install -d ${DEST}
296
297	case "${SRCFILE##*.}" in	case "${SRCFILE##*.}" in
298	bz2)	bz2)
299	IFTAR="$(basename $SRCFILE .bz2)"	IFTAR="$(basename $SRCFILE .bz2)"
300	IFTAR="${IFTAR##*.}"	IFTAR="${IFTAR##*.}"
301	if [ "${IFTAR}" == "tar" ]	if [[ ${IFTAR} = tar ]]
302	then	then
303	tar --no-same-owner -xvjf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST}	tar --no-same-owner -xvjf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tar.bz2 unpack failed."
304		else
305		pushd ${DEST} > /dev/null
306		bzcat ${SOURCEDIR}/${PNAME}/${SRCFILE} > ${DEST}/$(basename ${SRCFILE} .bz2) || die ".bz2 unpack failed."
307		popd > /dev/null
308	fi	fi
309	;;	;;
310	gz)	gz)
311	IFTAR="$(basename $SRCFILE .gz)"	IFTAR="$(basename $SRCFILE .gz)"
312	IFTAR="${IFTAR##*.}"	IFTAR="${IFTAR##*.}"
313	if [ "${IFTAR}" == "tar" ]	if [[ ${IFTAR} = tar ]]
314		then
315		tar --no-same-owner -xvzf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tar.gz unpack failed."
316		else
317		pushd ${DEST} > /dev/null
318		zcat ${SOURCEDIR}/${PNAME}/${SRCFILE} > ${DEST}/$(basename ${SRCFILE} .gz) || die ".gz unpack failed."
319		popd > /dev/null
320		fi
321		;;
322		xz)
323		IFTAR="$(basename $SRCFILE .xz)"
324		IFTAR="${IFTAR##*.}"
325		if [[ ${IFTAR} = tar ]]
326	then	then
327	tar --no-same-owner -xvzf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST}	tar --no-same-owner -xvJf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tar.xz unpack failed."
328		else
329		pushd ${DEST} > /dev/null
330		xzcat ${SOURCEDIR}/${PNAME}/${SRCFILE} > ${DEST}/$(basename ${SRCFILE} .xz) || die ".xz unpack failed."
331		popd > /dev/null
332	fi	fi
333	;;	;;
334	tbz2)	tbz2|mpks|mpk)
335	tar --no-same-owner -xvjf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST}	tar --no-same-owner -xvjf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tbz2 unpack failed."
336	;;	;;
337	tgz)	tgz)
338	tar --no-same-owner -xvzf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST}	tar --no-same-owner -xvzf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tgz unpack failed."
339		;;
340		txz|mpkzs|mpkz)
341		tar --no-same-owner -xvJf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".txz unpack failed."
342		;;
343		rar)
344		unrar x ${SOURCEDIR}/${PNAME}/${SRCFILE} ${DEST}  || die ".rar unpack failed."
345		;;
346		zip|xpi)
347		unzip ${SOURCEDIR}/${PNAME}/${SRCFILE} -d ${DEST} || die ".zip unpack failed."
348		;;
349		rpm)
350		pushd ${DEST} > /dev/null
351		rpm2targz ${SOURCEDIR}/${PNAME}/${SRCFILE} || die "rpm2targz: .rpm unpack failed."
352		tar --no-same-owner -xvzf ${SRCFILE/.rpm/.tar.gz} || die "tar: .rpm unpack failed."
353		if [[ -f ${DEST}/${SRCFILE/.rpm/.tar.gz} ]]
354		then
355		rm ${DEST}/${SRCFILE/.rpm/.tar.gz}
356		fi
357	;;	;;
358	*)	*)
359	die "munpack failed"	die "munpack failed"
#	Line 314  munpack() {	Line 361  munpack() {
361	esac	esac
362	}	}
363
364	mpatch() {	mpatch()
365		{
366	local PATCHOPTS	local PATCHOPTS
367	local PATCHFILE	local PATCHFILE
368		local i
369
370	PATCHOPTS=$1	PATCHOPTS=$1
371	PATCHFILE=$2	PATCHFILE=$2
372
373		if [[ -z $2 ]]
374		then
375		PATCHFILE=$1
376
377		## patch level auto-detection, get patch level
378		for ((i=0; i < 10; i++))
379		do
380		patch --dry-run -Np${i} -i ${SOURCEDIR}/${PNAME}/${PATCHFILE} > /dev/null
381		if [[ $? = 0 ]]
382		then
383		PATCHOPTS="-Np${i}"
384		break
385		fi
386		done
387		fi
388
389		echo -e "${COLBLUE}*** ${COLGREEN}Applying patch '${PATCHFILE}'${COLDEFAULT}"
390	patch "${PATCHOPTS}" -i ${SOURCEDIR}/${PNAME}/${PATCHFILE}	patch "${PATCHOPTS}" -i ${SOURCEDIR}/${PNAME}/${PATCHFILE}
391	}	}
392
393		mlibtoolize()
394		{
395		local opts="$@"
396		[[ -z ${opts} ]] && opts="--verbose --install --force"
397
398		libtoolize ${opts} || die "running: mlibtoolize ${opts}"
399		}
400
401		mautoreconf()
402		{
403		local opts="$@"
404		[[ -z ${opts} ]] && opts="--verbose --install --force"
405
406		autoreconf ${opts} || die "running: mautoreconf ${opts}"
407		}
408
409	minstalldocs() {	minstalldocs()
410		{
411	local docfiles	local docfiles
412	docfiles="$@"	docfiles="$@"
413
414	if [ ! -d ${BINDIR}/usr/share/doc/${PNAME}-${PVER} ]	if [ ! -d ${BINDIR}/usr/share/doc/${PNAME}-${PVER} ]
415	then	then
416	install -d ${BINDIR}/usr/share/doc/${PNAME}-${PVER} || die "creating doc dirs."	install -d ${BINDIR}/usr/share/doc/${PNAME}-${PVER} || die "creating doc dirs."
417	fi	fi
418
419		local i
420	for i in ${docfiles}	for i in ${docfiles}
421	do	do
422	cat ${i} | gzip -9c > ${i}.gz || die "gzipping docs."	if [ -f ${i} ]
423	install -m 0644 ${SRCDIR}/${i}.gz \	then
424	${BINDIR}/usr/share/doc/${PNAME}-${PVER} || die "coping docs."	cat ${i} | gzip -9c > ${i}.gz || die "gzipping docs."
425		install -m 0644 ${SRCDIR}/${i}.gz \
426		${BINDIR}/usr/share/doc/${PNAME}-${PVER} || die "coping docs."
427		fi
428	done	done
429	}	}
430
431	mstriplibs() {	mstriplibs()
432		{
433	local stripdir="$@"	local stripdir="$@"
434
435	[ -z "${stripdir}" ] && stripdir=${BINDIR}	[[ -z ${stripdir} ]] && stripdir="${BINDIR}"
436	find ${stripdir} | xargs file | grep "shared object" | grep ELF | cut -f 1 -d : | xargs strip --strip-unneeded 2> /dev/null	[[ -z ${STRIP_DYN_LIB} ]] && STRIP_DYN_LIB="--strip-debug"
437		find ${stripdir} ! -type d | xargs file | grep "shared object" | grep ELF | cut -f 1 -d : | xargs --no-run-if-empty strip ${STRIP_DYN_LIB} 2> /dev/null
438	}	}
439
440	mstripbins() {	mstripbins()
441		{
442	local stripdir="$@"	local stripdir="$@"
443
444	[ -z "${stripdir}" ] && stripdir=${BINDIR}	[[ -z ${stripdir} ]] && stripdir="${BINDIR}"
445	find ${stripdir} | xargs file | grep "executable" | grep ELF | cut -f 1 -d : | xargs strip --strip-unneeded 2> /dev/null	[[ -z ${STRIP_DYN_BIN} ]] && STRIP_DYN_BIN="--strip-debug"
446		find ${stripdir} ! -type d | xargs file | grep "executable" | grep ELF | cut -f 1 -d : | xargs --no-run-if-empty strip ${STRIP_DYN_BIN} 2> /dev/null
447	}	}
448
449	setup_distcc_environment(){	mstripstatic()
450	if [ -x /usr/bin/distcc ]	{
451	then	local stripdir="$@"
	echo "Using DistCC for compilation ..."
	export PATH=/usr/lib/distcc/bin:${PATH} || die "distcc: could not export new $PATH"
452
453	#export distcc as compiler	[[ -z ${stripdir} ]] && stripdir="${BINDIR}"
454	# export CC="distcc"	[[ -z ${STRIP_STATIC_LIB} ]] && STRIP_STATIC_LIB="--strip-debug"
455	# export CXX=distcc	find ${stripdir} ! -type d | xargs file | grep "ar archive" | cut -f 1 -d : | xargs --no-run-if-empty strip ${STRIP_STATIC_LIB} 2> /dev/null
456		}
457
458	export DISTCC_DIR="${DISTCC_DIR}" || die "distcc_dir export failed"	mstriplibtoolarchive()
459		{
460		local stripdir="$@"
461
462		[[ -z ${stripdir} ]] && stripdir="${BINDIR}"
463		find ${stripdir} ! -type d -name \*.la | xargs file | grep "libtool library" | cut -f 1 -d : | xargs --no-run-if-empty rm -f -- 2> /dev/null
464		}
465
466		mpurgetargets()
467		{
468		local stripdir="$@"
469		local target
470
471	#ccache + distcc together	[[ -z ${stripdir} ]] && stripdir=${BINDIR}
472	if [ "${SMAGE_USE_CCACHE}" == "true" ]	# nothing to do in this case
473		[[ -z ${PURGE_TARGETS[*]} ]] && return
474
475		for target in ${PURGE_TARGETS[*]}
476		do
477		# check if target is a regex pattern without any slashes
478		if [[ ${target} = ${target//\/} ]]
479	then	then
480	if [ -x /usr/bin/ccache ]	find ${BINDIR} -type f -name "${target}" | xargs --no-run-if-empty rm -f -- 2> /dev/null
481	then	else
482	echo "Preparing DistCC to work together with CCache ..."	rm -f -- ${target} 2> /dev/null
	#export CCACHE_PREFIX="distcc" || die "distcc: could not set ccach_prefix"
	# export CC="ccache distcc"
	# export CXX="ccache distcc"
	fi
483	fi	fi
484		done
485		}
486
487		mcompressdocs()
488		{
489		local bindir="$@"
490
491		if [ -d ${bindir}/usr/share/man ]
492		then
493		echo -e "${COLBLUE}===${COLGREEN} compressing man-pages ...${COLDEFAULT}"
494		${MLIBDIR}/compressdoc -g -9 ${bindir}/usr/share/man
495		fi
496
497		if [ -d ${bindir}/usr/share/info ]
498		then
499		echo -e "${COLBLUE}===${COLGREEN} compressing info-pages ...${COLDEFAULT}"
500		${MLIBDIR}/compressdoc -g -9 ${bindir}/usr/share/info
501		fi
502		}
503
504	#creating distcc tempdir	sminclude()
505		{
506		local i
507
508		if [[ -n "$@" ]]
509		then
510		for i in $@
511		do
512		echo "--- Including ${SMAGESCRIPTSDIR}/include/${i}.sminc"
513		source ${SMAGESCRIPTSDIR}/include/${i}.sminc
514		done
515		echo
516		fi
517		}
518
519		setup_distcc_environment()
520		{
521		if [ -x /usr/bin/distcc ]
522		then
523		echo -e "${COLBLUE}---${COLGREEN} Using DistCC for compilation ...${COLDEFAULT}"
524		export PATH=/usr/$(mlibdir)/distcc/bin:${PATH} || die "distcc: could not export new $PATH"
525
526		export DISTCC_DIR="${DISTCC_DIR}" || die "distcc_dir export failed"
527
528		# creating distcc tempdir
529	install -o distcc -g daemon -d ${DISTCC_DIR}	install -o distcc -g daemon -d ${DISTCC_DIR}
530	chmod 1777 ${DISTCC_DIR}	chmod 1777 ${DISTCC_DIR}
531	fi	fi
532	}	}
533
534	setup_ccache_environment(){	setup_ccache_environment()
535		{
536	if [ -x /usr/bin/ccache ]	if [ -x /usr/bin/ccache ]
537	then	then
538	echo "Using CCache for compilation ..."	echo -e "${COLBLUE}---${COLGREEN} Using CCache for compilation ...${COLDEFAULT}"
539	export PATH=/usr/lib/ccache/bin:${PATH} || die "ccache: could not export new $PATH"	export PATH=/usr/$(mlibdir)/ccache/bin:${PATH} || die "ccache: could not export new $PATH"
540	#unset CC CXX	fi
541		}
542
543
544		# fixes given dependencies to match a MAGE_TARGET
545		# fix_mage_deps -target s/depend # <-- note -target !
546		fix_mage_deps()
547		{
548		local target="$1"
549		local depend="$2"
550		local NDEPEND
551		local sym dep cat pver pname
552
553		# deps and provides are special
554		# they must be fixed to match the target
555
556		# run this only if target and depend is not empty
557		if [ -n "${target}" ] && [ -n "${depend}" ]
558		then
559		# fix DEPEND
560		while read sym dep
561		do
562		# ignore empty lines
563		[[ -z ${dep} ]] && continue
564
565		cat="$(dirname ${dep})"
566		# change if not virtual
567		if [[ ${cat} = virtual ]]
568		then
569		pname="$(basename ${dep})"
570		else
571		# fix pver to target-pver
572		# to get pname-target-pver
573
574		# doing it backwards !
575		pver="${dep##*-}"
576		# full pver
577		pname="$(basename ${dep/-${pver}/})${target}-${pver}"
578		fi
579
580		# do not add empty lines
581		if [ -z "${NDEPEND}" ]
582		then
583		NDEPEND="${sym} ${cat}/${pname}"
584		else
585		NDEPEND="${NDEPEND}
586		${sym} ${cat}/${pname}"
587		fi
588
589		unset cat pname pver
590		done << EOF
591		${depend}
592		EOF
593		# set NDEPEND to DEPEND
594		depend="${NDEPEND}"
595		fi
596
597		echo "${depend}"
598		}
599
600		# build_mage_script(): helper functions for regen_mage_tree()
601		# generates an mage file with given information in smage file
602		# needs at least:
603		#   PNAME                 name of pkg
604		#   PVER                  version
605		#   PBUILD                revision
606		#   PCATEGORIE            categorie of the pkg
607		#   STATE                 state of pkg stable|unstable|old
608		#   DESCRIPTION           va short description (opt)
609		#   HOMEPAGE              homepage (opt)
610		#   DEPEND                runtime dependencies (opt)
611		#   SDEPEND               add. needed deps to build the pkg (opt)
612		#   PROVIDE               provides a virtual (opt)
613		#
614		# special tags:
615		#   PKGTYPE               type of pkg
616		#   INHERITS              which functions get included
617		#   SPECIAL_FUNCTIONS     special functions which should also be added
618		#                         warning: they get killed before the build starts !
619		#   SPLIT_PACKAGES        names of all subpackages which are splitted from parent
620		#   SPLIT_PACKAGE_BASE    base package name for splitpackages
621		#                         (only in the resulting magefile}
622		#
623		#   MAGE_TREE_DEST        target destination of the generated tree
624		#   REGEN_MAGE_TREE       set to 'true' to enable this
625		#
626		# gets called with build_mage_script target
627		build_mage_script()
628		{
629		local magefile
630		local dest
631		local target
632		local split_pkg_base
633		local sym
634		local depname
635
636		# if MAGE_TREE_DEST not set use BUILDDIR
637		: ${MAGE_TREE_DEST=${BUILDDIR}/mage-tree}
638
639		# determinate which suffix this mage file should get, if any
640		[[ $1 = --target ]] && shift && target="-$1"
641
642		# mark package as splitpackage
643		[[ $1 = --split-pkg-base ]] && shift && split_pkg_base="$1"
644
645		# name of magefile
646		magefile="${PNAME}${target}-${PVER}-${PBUILD}.mage"
647
648		# destination to magefile
649		dest="${MAGE_TREE_DEST}/${PCATEGORIE}/${PNAME}${target}/${magefile}"
650
651		# show what we are doing
652		echo -e "${COLBLUE}===${COLGREEN} generating mage file:${COLDEFAULT}"
653		echo "${dest}"
654
655		install -d "$(dirname ${dest})"
656		# now build the mage file
657		> ${dest}
658
659		# pgkname and state
660		echo "PKGNAME=\"${PNAME}${target}-${PVER}-\${ARCH}-${PBUILD}\"" >> ${dest}
661		echo "STATE=\"${STATE}\"" >> ${dest}
662
663		# description and homepage
664		echo "DESCRIPTION=\"${DESCRIPTION}\"" >> ${dest}
665		echo "HOMEPAGE=\"${HOMEPAGE}\"" >> ${dest}
666
667		# special tags and vars
668		echo "PKGTYPE=\"${PKGTYPE}\""  >> ${dest}
669
670		# echo MAGE_TARGETS ## note -target is needed !
671		echo "MAGE_TARGETS=\"${target}\"" >> ${dest}
672
673		# split package base
674		echo "SPLIT_PACKAGE_BASE=\"${split_pkg_base}\"" >> ${dest}
675
676		# add special vars
677		if [ -n "${SPECIAL_VARS}" ]
678		then
679		local i
680		for i in ${SPECIAL_VARS}
681		do
682		# being tricky here :)
683		echo "${i}=\"$(eval echo \$${i})\"" >> ${dest}
684		done
685		fi
686
687		# add at least all includes
688		if [ -n "${INHERITS}" ]
689		then
690		echo -n "minclude"  >> ${dest}
691		local i
692		for i in ${INHERITS}
693		do
694		echo -n " ${i}"  >> ${dest}
695		done
696		# a CRLF is needed here!
697		echo >> ${dest}
698		fi
699
700		# deps and provides
701		echo "DEPEND=\"$(fix_mage_deps "${target}" "${DEPEND}")\"" >> ${dest}
702		echo "SDEPEND=\"$(fix_mage_deps "${target}" "${SDEPEND}")\"" >> ${dest}
703		echo "PROVIDE=\"${PROVIDE}\"" >> ${dest}
704
705		# add special functions
706		if [ -n "${SPECIAL_FUNCTIONS}" ]
707		then
708		local i
709		for i in ${SPECIAL_FUNCTIONS}
710		do
711		# add to mage (quotes needed !)
712		typeset -f "${i}" >> ${dest}
713		# unset to be safe (quotes needed !)
714		#unset "${i}" <-- later to get every target built
715		done
716	fi	fi
717
718		# pre|post-install|removes
719		typeset -f preinstall >> ${dest}
720		typeset -f postinstall >> ${dest}
721		typeset -f preremove >> ${dest}
722		typeset -f postremove >> ${dest}
723	}	}
724
725		regen_mage_tree()
726		{
727		local subpackage
728
729		# build them only if requested
730		if [[ ${REGEN_MAGE_TREE} = true ]]
731		then
732		# run it without targets
733		if [[ -n ${MAGE_TARGETS} ]]
734		then
735		# build for each target a mage file
736		# run it with several targets
737		echo
738		for subpackage in ${MAGE_TARGETS}
739		do
740		build_mage_script --target "${subpackage}"
741		done
742		echo
743
744		# run it for splitpackages
745		elif [[ -n ${SPLIT_PACKAGES} ]]
746		then
747		local split_pkg_base="${PNAME}"
748		# save smage environment
749		split_save_variables
750		# build for each subpackage a mage file
751		# run it with several targets
752		echo
753		for subpackage in ${SPLIT_PACKAGES}
754		do
755		# get the right variables for the split
756		export PNAME="${subpackage}"
757		split_info_${subpackage}
758		# get the preinstall etc
759		split_export_inherits ${subpackage}
760		build_mage_script --split-pkg-base "${split_pkg_base}"
761		# delete split preinstall etc
762		split_delete_inherits ${subpackage}
763		# restore smage environment
764		split_restore_variables
765		done
766		echo
767		# unset all saved smage variables
768		split_unset_variables
769
770		else
771		echo
772		build_mage_script
773		echo
774		fi
775		fi
776
777		# now unset all uneeded vars to be safe
778		# unset PKGNAME <-- don't do that; smage needs this var
779		# unset to be safe (quotes needed !)
780		# for i in ${SPECIAL_FUNCTIONS}
781		# do
782		# unset "${i}"
783		# done
784		unset SPECIAL_FUNCTIONS
785		# for i in ${SPECIAL_VARS}
786		# do
787		# unset "${i}"
788		# done
789		unset SPECIAL_VARS
790		unset STATE
791		unset DESCRIPTION
792		unset HOMEPAGE
793		unset PKGTYPE
794		unset INHERITS
795		unset DEPEND
796		unset SDEPEND
797		unset PROVIDE
798		unset preinstall
799		unset postinstall
800		unset preremove
801		unset postremove
802		}
803
804		split_save_variables()
805		{
806		export SAVED_PNAME="${PNAME}"
807		export SAVED_PVER="${PVER}"
808		export SAVED_PBUILD="${PBUILD}"
809		export SAVED_PCATEGORIE="${PCATEGORIE}"
810		export SAVED_DESCRIPTION="${DESCRIPTION}"
811		export SAVED_HOMEPAGE="${HOMEPAGE}"
812		export SAVED_SPECIAL_VARS="${SPECIAL_VARS}"
813		export SAVED_STATE="${STATE}"
814		export SAVED_PKGTYPE="${PKGTYPE}"
815		export SAVED_INHERITS="${INHERITS}"
816		export SAVED_DEPEND="${DEPEND}"
817		export SAVED_SDEPEND="${SDEPEND}"
818		export SAVED_PROVIDE="${PROVIDE}"
819		export SAVED_NOPKGBUILD="${NOPKGBUILD}"
820
821		# bindir too
822		export SAVED_BINDIR="${BINDIR}"
823
824		# export the SPLIT_PACKAGE_BASE
825		export SPLIT_PACKAGE_BASE="${SAVED_PNAME}"
826
827		# functions
828		if [[ ! -z $(typeset -f preinstall) ]]
829		then
830		# rename the old one
831		local saved_preinstall
832		saved_preinstall=SAVED_$(typeset -f preinstall)
833		eval "${saved_preinstall}"
834		export -f SAVED_preinstall
835		fi
836
837		if [[ ! -z $(typeset -f postinstall) ]]
838		then
839		# rename the old one
840		local saved_postinstall
841		saved_postinstall=SAVED_$(typeset -f postinstall)
842		eval "${saved_postinstall}"
843		export -f SAVED_postinstall
844		fi
845
846		if [[ ! -z $(typeset -f preremove) ]]
847		then
848		# rename the old one
849		local saved_preremove
850		saved_preremove=SAVED_$(typeset -f preremove)
851		eval "${saved_preremove}"
852		export -f SAVED_preremove
853		fi
854
855		if [[ ! -z $(typeset -f postremove) ]]
856		then
857		# rename the old one
858		local saved_postremove
859		saved_postremove=SAVED_$(typeset -f postremove)
860		eval "${saved_postremove}"
861		export -f SAVED_postremove
862		fi
863		}
864
865		split_restore_variables()
866		{
867		export PNAME="${SAVED_PNAME}"
868		export PVER="${SAVED_PVER}"
869		export PBUILD="${SAVED_PBUILD}"
870		export PCATEGORIE="${SAVED_PCATEGORIE}"
871		export DESCRIPTION="${SAVED_DESCRIPTION}"
872		export HOMEPAGE="${SAVED_HOMEPAGE}"
873		export SPECIAL_VARS="${SAVED_SPECIAL_VARS}"
874		export STATE="${SAVED_STATE}"
875		export PKGTYPE="${SAVED_PKGTYPE}"
876		export INHERITS="${SAVED_INHERITS}"
877		export DEPEND="${SAVED_DEPEND}"
878		export SDEPEND="${SAVED_SDEPEND}"
879		export PROVIDE="${SAVED_PROVIDE}"
880		export NOPKGBUILD="${SAVED_NOPKGBUILD}"
881
882		# bindir too
883		export BINDIR="${SAVED_BINDIR}"
884
885		# functions
886		if [[ ! -z $(typeset -f SAVED_preinstall) ]]
887		then
888		# rename the old one
889		local saved_preinstall
890		saved_preinstall=$(typeset -f SAVED_preinstall)
891		eval "${saved_preinstall/SAVED_/}"
892		export -f preinstall
893		fi
894
895		if [[ ! -z $(typeset -f SAVED_postinstall) ]]
896		then
897		# rename the old one
898		local saved_postinstall
899		saved_postinstall=$(typeset -f SAVED_postinstall)
900		eval "${saved_postinstall/SAVED_/}"
901		export -f postinstall
902		fi
903
904		if [[ ! -z $(typeset -f SAVED_preremove) ]]
905		then
906		# rename the old one
907		local saved_preremove
908		saved_preremove=$(typeset -f SAVED_preremove)
909		eval "${saved_preremove/SAVED_/}"
910		export -f preremove
911		fi
912
913		if [[ ! -z $(typeset -f SAVED_postremove) ]]
914		then
915		# rename the old one
916		local saved_postremove
917		saved_postremove=$(typeset -f SAVED_postremove)
918		eval "${saved_postremove/SAVED_/}"
919		export -f postremove
920		fi
921		}
922
923		split_unset_variables()
924		{
925		# unset saved vars; not needed anymore
926		unset SAVED_PNAME
927		unset SAVED_PVER
928		unset SAVED_PBUILD
929		unset SAVED_PCATEGORIE
930		unset SAVED_DESCRIPTION
931		unset SAVED_HOMEPAGE
932		unset SAVED_SPECIAL_VARS
933		unset SAVED_STATE
934		unset SAVED_PKGTYPE
935		unset SAVED_INHERITS
936		unset SAVED_DEPEND
937		unset SAVED_SDEPEND
938		unset SAVED_PROVIDE
939		unset SAVED_BINDIR
940		unset SAVED_NOPKGBUILD
941		unset SPLIT_PACKAGE_BASE
942		unset -f SAVED_preinstall
943		unset -f SAVED_postinstall
944		unset -f SAVED_preremove
945		unset -f SAVED_postremove
946		}
947
948		split_export_inherits()
949		{
950		local subpackage="$1"
951		local func
952		local newfunc
953
954		for func in preinstall postinstall preremove postremove
955		do
956		if [[ ! -z $(typeset -f ${func}_${subpackage}) ]]
957		then
958		newfunc=$(typeset -f ${func}_${subpackage})
959		newfunc="${newfunc/_${subpackage} (/ (}"
960		eval "${newfunc}"
961		fi
962		done
963		}
964
965		split_delete_inherits()
966		{
967		local subpackage="$1"
968		local func
969
970		for func in preinstall postinstall preremove postremove
971		do
972		if [[ ! -z $(typeset -f ${func}_${subpackage}) ]]
973		then
974		unset -f ${func}
975		fi
976		done
977		}
978
979		export_inherits()
980		{
981		local include="$1"
982		shift
983
984		while [ "$1" ]
985		do
986		local functions="$1"
987
988		# sanity checks
989		[ -z "${include}" ] && die "export_inherits(): \$include not given."
990		[ -z "${functions}" ] && die "export_inherits(): \$functions not given."
991
992		eval "${functions}() { ${include}_${functions} ; }"
993
994		# debug
995		[[ ${MAGEDEBUG} = on ]] && typeset -f "${functions}"
996
997		shift
998		done
999		}
1000
1001		generate_package_md5sum()
1002		{
1003		local dest
1004		local pcat
1005		local pname
1006		local pver
1007		local pbuild
1008		local parch
1009		local target
1010		local pkgname
1011
1012		# very basic getops
1013		for i in $*
1014		do
1015		case $1 in
1016		--pcat|-c) shift; pcat="$1" ;;
1017		--pname|-n) shift; pname="$1" ;;
1018		--pver|-v) shift; pver="$1" ;;
1019		--pbuild|-b) shift; pbuild="$1" ;;
1020		--parch|a) shift; parch="$1" ;;
1021		--target|t) shift; target="$1" ;;
1022		esac
1023		shift
1024		done
1025
1026		# sanity checks; abort if not given
1027		[ -z "${pcat}" ] && die "generate_package_md5sum() \$pcat not given."
1028		[ -z "${pname}" ] && die "generate_package_md5sum() \$pname not given."
1029		[ -z "${pver}" ] && die "generate_package_md5sum() \$pver not given."
1030		[ -z "${pbuild}" ] && die "generate_package_md5sum() \$pbuild not given."
1031		[ -z "${parch}" ] && die "generate_package_md5sum() \$parch not given."
1032
1033		# check needed global vars
1034		[ -z "${PKGDIR}" ] && die "generate_package_md5sum() \$PKGDIR not set."
1035		[ -z "${PKGSUFFIX}" ] && die "generate_package_md5sum() \$PKGSUFFIX not set."
1036
1037		# fix target as it may be empty !
1038		[ -n "${target}" ] && target="-${target}"
1039
1040
1041		# build pkgname
1042		pkgname="${pname}${target}-${pver}-${parch}-${pbuild}"
1043
1044		# build pkg-md5-sum only if requested
1045		if [[ ${REGEN_MAGE_TREE} = true ]]
1046		then
1047		echo -ne "${COLBLUE}===${COLGREEN} generating md5's for ${pkgname}.${PKGSUFFIX} ... ${COLDEFAULT}"
1048
1049		# abort if not exist
1050		if [ ! -f ${PKGDIR}/${pkgname}.${PKGSUFFIX} ]
1051		then
1052		echo -e "${COLRED}! exists${COLDEFAULT}"
1053		return 0
1054		fi
1055
1056		# if MAGE_TREE_DEST not set use BUILDDIR
1057		: ${MAGE_TREE_DEST=${BUILDDIR}/mage-tree}
1058
1059		# setup md5 dir
1060		dest="${MAGE_TREE_DEST}/${pcat}/${pname}${target}/md5"
1061		install -d ${dest}
1062
1063		# gen md5sum
1064		( cd ${PKGDIR}; md5sum "${pkgname}.${PKGSUFFIX}" ) \
1065		> ${dest}/${pkgname}.md5
1066		echo -e "${COLGREEN}done${COLDEFAULT}"
1067		fi
1068		}
1069
1070		source_pkg_build()
1071		{
1072		if [[ ${PKGTYPE} = virtual ]]
1073		then
1074		echo "Virtual package detected; src-pkg-tarball not necessary ..."
1075		return 0
1076		fi
1077
1078		if [[ ! -d ${SOURCEDIR}/${PNAME} ]]
1079		then
1080		echo "No SRC_URI defined; src-pkg-tarball not necessary ..."
1081		return 0
1082		fi
1083
1084		[ -z "${SRCPKGDIR}" ] && die "\$SRCPKGDIR not found. Please setup your ${MAGERC} correctly."
1085
1086		echo -e "${COLGREEN}Creating source package tarball ... ${COLDEFAULT}"
1087
1088		# include the smage2 file
1089		cp ${SMAGENAME} ${SOURCEDIR}/${PNAME}
1090
1091		( cd ${SOURCEDIR}; tar cvjf ${BUILDDIR}/${PNAME}-${PVER}-${PBUILD}.tar.bz2 ${PNAME}; )
1092		[[ ! -d ${SRCPKGDIR} ]] && install -d ${SRCPKGDIR}
1093		mv ${BUILDDIR}/${PNAME}-${PVER}-${PBUILD}.tar.bz2 ${SRCPKGDIR}/${PNAME}-${PVER}-${PBUILD}.${SRCPKGSUFFIX}
1094
1095		echo -e "${COLGREEN}Source package ${COLBLUE}${PNAME}-${PVER}-${PBUILD}.${SRCPKGSUFFIX} ${COLGREEN}successfully builded.${COLDEFAULT}"
1096		}
1097
1098		step_by_step()
1099		{
1100		if [[ ${STEP_BY_STEP} = true ]]
1101		then
1102		echo -e "${COLRED}Step-by-step enabled! Paused after $1.${COLDEFAULT}"
1103		echo "Press [enter] to continue"
1104		read
1105		fi
1106		}
1107
1108
1109	# print out our version	# print out our version
1110	showversion	showversion
1111	echo	echo
#	Line 408  then	Line 1117  then
1117	exit 1	exit 1
1118	fi	fi
1119
1120	#updating smage2-scripts	# updating smage2-scripts
1121	if [ "$1" == "update" ]	if [[ $1 = update ]]
1122	then	then
1123	if [ ! -d ${SOURCEDIR} ]	if [ ! -d ${SOURCEDIR} ]
1124	then	then
#	Line 419  then	Line 1128  then
1128	exit 0	exit 0
1129	fi	fi
1130
1131	#creates md5sums for smages to given dir	# creates md5sums for smages to given dir
1132	if [ "$1" == "calcmd5" ]	if [[ $1 = calcmd5 ]]
1133	then	then
1134	if [ $# -ge 3 ]	if [ $# -ge 2 ]
1135	then	then
1136	SMAGENAME="$2"	SMAGENAME="$2"
1137	MD5DIR="$3"	MD5DIR="$3"
1138	source ${SMAGENAME} || die "download source failed"	[[ -z ${MD5DIR} ]] && MD5DIR="$(dirname ${SMAGENAME})/md5"
1139
1140		smagesource ${SMAGENAME} || die "download source failed"
1141
1142	# overridable sourcedir; must be declared after source of the smage2	# overridable sourcedir; must be declared after source of the smage2
1143	CALC_SOURCEDIR="${CALC_SOURCEDIR:="${SOURCEDIR}/${PNAME}"}"	CALC_SOURCEDIR="${CALC_SOURCEDIR:="${SOURCEDIR}/${PNAME}"}"
#	Line 472  then	Line 1183  then
1183	unset my_SRC_URI_MIRROR	unset my_SRC_URI_MIRROR
1184	unset my_SOURCEDIR	unset my_SOURCEDIR
1185	done	done
1186
1187	echo	echo
1188	echo "Calculating of md5 sums for '$(basename ${SMAGENAME} .${SMAGESUFFIX})' done."	echo "Calculating of md5 sums for '$(basename ${SMAGENAME} .${SMAGESUFFIX})' done."
1189	echo	echo
1190	else	else
1191	echo "Usage: Calculating MD5 Sums:"	echo "Usage: Calculating MD5 Sums:"
1192	echo "    $(basename $0) calcmd5 /path/to/SMAGENAME /path/to/MD5DIR"	echo "    $(basename $0) calcmd5 /path/to/SMAGENAME [/path/to/MD5DIR]"
1193	echo	echo
1194	echo	echo
1195	echo "Export the CALC_SOURCEDIR variable to override current SOURCEDIRs."	echo "Export the CALC_SOURCEDIR variable to override current SOURCEDIRs."
1196	echo	echo
1197	exit 1	exit 1
1198	fi	fi
1199
1200	exit 0	exit 0
1201	fi	fi
1202
1203	#download sources	# download sources
1204	if [ "$1" == "download" -a -n "$2" ]	if [ "$1" == "download" -a -n "$2" ]
1205	then	then
	showversion
1206	if [ ! -d ${SMAGESCRIPTSDIR} ]	if [ ! -d ${SMAGESCRIPTSDIR} ]
1207	then	then
1208	install -d ${SMAGESCRIPTSDIR}	install -d ${SMAGESCRIPTSDIR}
#	Line 501  then	Line 1211  then
1211	# get smage	# get smage
1212	SMAGENAME="$2"	SMAGENAME="$2"
1213	MD5DIR="$(dirname ${SMAGENAME})/md5"	MD5DIR="$(dirname ${SMAGENAME})/md5"
1214	source ${SMAGENAME} || die "download source failed"	smagesource ${SMAGENAME} || die "download source failed"
1215
1216	download_sources	download_sources
1217	exit 0	exit 0
1218	fi	fi
1219
1220	if [ ! -e ${MLIBDIR}/pkgbuild_dir.sh ]	# regen-mage-tree
1221		if [ "$1" == "only-regen-tree" -a -n "$2" ]
1222	then	then
1223	die "Error: ${MLIBDIR}/pkgbuild_dir.sh not found. Aborting."	# set correct SMAGENAME
1224	fi	SMAGENAME="$2"
1225		MD5DIR="$(dirname ${SMAGENAME})/md5"
1226		smagesource ${SMAGENAME} || die "regen: smage2 not found"
1227
1228	if [ -z "`basename ${SMAGENAME}|grep .${SMAGESUFFIX}`" ]	regen_mage_tree
	then
	die "File '`basename ${SMAGENAME}`' is not a sMage v${SMAGEVERSION} file. Aborting."
	fi
1229
1230	if [ -z "${SOURCEDIR}" ]	# build several targets
1231	then	if [[ -n ${MAGE_TARGETS} ]]
1232	die "\$SOURCEDIR not found. Please setup your mage.rc correctly."	then
1233	fi	for target in ${MAGE_TARGETS}
1234		do
1235		# build md5sum for existing packages
1236		generate_package_md5sum \
1237		--pcat "${PCATEGORIE}" \
1238		--pname "${PNAME}" \
1239		--pver "${PVER}" \
1240		--pbuild "${PBUILD}" \
1241		--parch "${ARCH}" \
1242		--target "${target}"
1243		done
1244
1245	if [ -z "${SMAGESCRIPTSDIR}" ]	# build several subpackages
1246	then	elif [[ -n ${SPLIT_PACKAGES} ]]
1247	die "\$SMAGESCRIPTSDIR not found. Please setup your mage.rc correctly."	then
1248	fi	split_save_variables
1249		for subpackage in ${SPLIT_PACKAGES}
1250		do
1251		# get the right variables for the split
1252		export PNAME="${subpackage}"
1253		split_info_${subpackage}
1254		# build md5sum for existing packages
1255		generate_package_md5sum \
1256		--pcat "${PCATEGORIE}" \
1257		--pname "${PNAME}" \
1258		--pver "${PVER}" \
1259		--pbuild "${PBUILD}" \
1260		--parch "${ARCH}"
1261		# restore smage environment
1262		split_restore_variables
1263		done
1264		# unset all saved smage variables
1265		split_unset_variables
1266
1267	if [ -z "${SMAGE2RSYNC}" ]	else
1268	then	# build md5sum for existing packages
1269	echo "\$SMAGE2RSYNC not found. Please setup your mage.rc correctly."	generate_package_md5sum \
1270	exit 1	--pcat "${PCATEGORIE}" \
1271	fi	--pname "${PNAME}" \
1272		--pver "${PVER}" \
1273		--pbuild "${PBUILD}" \
1274		--parch "${ARCH}"
1275		fi
1276
1277	if [ -z "${BINDIR}" ]	exit 0
	then
	die "no BINDIR variable found in /etc/mage.rc"
1278	fi	fi
1279
1280	if [ -z "${CHOST}" ]	if [ "$1" == "--create-src-tarball" -a -n "$2" ]
1281	then	then
1282	die "no CHOST variable found in /etc/mage.rc"	# set correct SMAGENAME
1283	fi	SMAGENAME="$2"
1284		MD5DIR="$(dirname ${SMAGENAME})/md5"
1285
1286	if [ -z "${CFLAGS}" ]	echo -e "${COLGREEN}create-src-tarball called for ${COLBLUE}${SMAGENAME}${COLGREEN} ...${COLDEFAULT}"
1287	then
1288	die "no CFLAGS variable found in /etc/mage.rc"	smagesource ${SMAGENAME} || die "regen: smage2 not found"
1289
1290		if [[ -d ${SOURCEDIR}/${PNAME} ]]
1291		then
1292		echo -e "${COLGREEN}Deleting old sourcefiles ${COLBLUE}${SOURCEDIR}/${PNAME}${COLGREEN} ...${COLDEFAULT}"
1293		rm -rf ${SOURCEDIR}/${PKGNAME}
1294		fi
1295
1296		download_sources
1297		source_pkg_build ${SMAGENAME}
1298		exit 0
1299	fi	fi
1300
1301	if [ -z "${CXXFLAGS}" ]	if [ "$1" == "--src-tarball" -a -n "$2" ] || [ "$1" == "-st" -a -n "$2" ]
1302	then	then
1303	die "no CXXFLAGS variable found in /etc/mage.rc"	SRCPKGTARBALL="${2}"
1304		USE_SRC_PKG_TARBALL=true
1305
1306		# abort if given file is not a source pkg
1307		[[ ${SRCPKGTARBALL##*.} != ${SRCPKGSUFFIX} ]] && die "${SRCPKGTARBALL} is not a valid src-pkg file."
1308
1309		# set correct SMAGENAME; use the one that the src_pkg provide
1310		# /path/to/SOURCEDIR/PNAME/SMAGENAME
1311		SMAGENAME="${SOURCEDIR}/$(basename ${SRCPKGTARBALL%-*-*})/$(basename ${SRCPKGTARBALL} .${SRCPKGSUFFIX}).${SMAGESUFFIX}"
1312
1313		echo -e "${COLGREEN}Using src-tarball ${COLBLUE}${SRCPKGTARBALL}${COLGREEN} ...${COLDEFAULT}"
1314
1315		[[ ! -d ${SOURCEDIR} ]] && install -d ${SOURCEDIR}
1316
1317		# unpack srctarball
1318		[[ ! -f ${SRCPKGTARBALL} ]] && die "Error: ${SRCPKGTARBALL} does not exist. Aborting."
1319
1320		tar xvjf ${SRCPKGTARBALL} -C ${SOURCEDIR} || die  "Error unpackung src-tarball ${SRCPKGTARBALL}"
1321
1322		[[ ! -f ${SMAGENAME} ]] && die "Included smage2 file in src-tarball not found: ${SMAGENAME}"
1323	fi	fi
1324
1325
1326	source ${SMAGENAME} || die "source failed"	[ ! -e ${MLIBDIR}/pkgbuild_dir.sh ] && die "Error: ${MLIBDIR}/pkgbuild_dir.sh not found. Aborting."
1327	PKGNAME="${PNAME}-${PVER}-${CHOST%%-*}-${PBUILD}"	[ -z "$(basename ${SMAGENAME} | grep .${SMAGESUFFIX})" ] &&
1328		die "File '$(basename ${SMAGENAME})' is not a sMage v${SMAGEVERSION} file. Aborting."
1329		[ -z "${SOURCEDIR}" ] && die "\$SOURCEDIR not found. Please setup your ${MAGERC} correctly."
1330		[ -z "${SMAGESCRIPTSDIR}" ] && die "\$SMAGESCRIPTSDIR not found. Please setup your ${MAGERC} correctly."
1331		[ -z "${SMAGE2RSYNC}" ] && die "\$SMAGE2RSYNC not found. Please setup your ${MAGERC} correctly."
1332		[ -z "${BINDIR}" ] && die "no BINDIR variable found in ${MAGERC}"
1333		[ -z "${CHOST}" ] && die "no CHOST variable found in ${MAGERC}"
1334		[ -z "${CFLAGS}" ] && die "no CFLAGS variable found in ${MAGERC}"
1335		[ -z "${CXXFLAGS}" ] && die "no CXXFLAGS variable found in ${MAGERC}"
1336
1337		smagesource ${SMAGENAME} || die "source failed"
1338		PKGNAME="${PNAME}-${PVER}-${ARCH}-${PBUILD}"
1339	MD5DIR="$(dirname ${SMAGENAME})/md5"	MD5DIR="$(dirname ${SMAGENAME})/md5"
1340		SMAGE_LOG_CMD="tee -a /var/log/smage/${PKGNAME}.log"
1341
1342	xtitle "Compiling ${PKGNAME}"	xtitle "Compiling ${PKGNAME}"
1343	echo "Compiling ${PKGNAME}"	echo -e "${COLGREEN}Compiling ${PKGNAME}${COLDEFAULT}"
1344
1345		# auto regen mage tree if requested
1346		regen_mage_tree
1347
1348	#download sources	if [[ ${CREATE_SRC_PKG_TARBALL} = true ]]
1349	download_sources	then
1350		if [[ -d ${SOURCEDIR}/${PNAME} ]]
1351		then
1352		echo -e "${COLBLUE}===${COLGREEN} deleting old sourcefiles ${COLBLUE}${SOURCEDIR}/${PNAME}${COLGREEN} ...${COLDEFAULT}"
1353		rm -rf ${SOURCEDIR}/${PNAME}
1354		fi
1355		fi
1356
1357		# download sources
1358		[[ ${USE_SRC_PKG_TARBALL} != true ]] && download_sources
1359
1360	#fixes some issues with these functions	# fixes some issues with these functions
1361	export -f src_prepare || die "src_prepare export failed"	export -f src_prepare || die "src_prepare export failed"
1362	export -f src_compile || die "src_compile export failed"	export -f src_compile || die "src_compile export failed"
1363		export -f src_check || die "src_check export failed"
1364	export -f src_install || die "src_install export failed"	export -f src_install || die "src_install export failed"
1365
1366	#fixes some compile issues	# fixes some compile issues
1367	export CHOST="${CHOST}" || die "CHOST export failed"	export CHOST="${CHOST}" || die "CHOST export failed"
1368	export CFLAGS="${CFLAGS}" || die "CFLAGS export failed"	export CFLAGS="${CFLAGS}" || die "CFLAGS export failed"
1369	export CXXFLAGS="${CFLAGS}" || die "CXXFLAGS export failed"	export CXXFLAGS="${CFLAGS}" || die "CXXFLAGS export failed"
#	Line 577  export BINDIR="${BINDIR}" || die "BINDIR	Line 1371  export BINDIR="${BINDIR}" || die "BINDIR
1371	export MAKEOPTS="${MAKEOPTS}" || die "MAKEOPTS export failed"	export MAKEOPTS="${MAKEOPTS}" || die "MAKEOPTS export failed"
1372
1373
1374	#setup distcc	# setup distcc
1375	#distcc mus be setup *before* ccache, as ccache need to be before distcc in path	# setup for distcc goes *before* ccache, so ccache comes before distcc in path
1376	if [ "${SMAGE_USE_DISTCC}" == "true" ]	[[ ${SMAGE_USE_DISTCC} = true ]] && setup_distcc_environment
	then
	setup_distcc_environment
	fi
	#setup ccache
	if [ "${SMAGE_USE_CCACHE}" == "true" ]
	then
	setup_ccache_environment
	fi
	# small sleep to show our settings
	sleep 1
1377
1378	#debug	# setup ccache
1379	#echo "CC=${CC}"	[[ ${SMAGE_USE_CCACHE} = true ]] && setup_ccache_environment
	#echo "CXX=${CXX}"
	#echo "DISTCC_DIR=${DISTCC_DIR}"
	#echo "PATH: ${PATH}"
	#echo "--------------------------------------"
	#env
	#echo "--------------------------------------"
	#read
	#debug end
1380
1381	#cleans up build if a previously one exists	# clean up builddir if a previously one exist
1382	if [ -d ${BUILDDIR} ]	if [ -d ${BUILDDIR} ]
1383	then	then
1384	rm -rf ${BUILDDIR}/* || die "couldn't cleanup \$BUILDDIR."	rm -rf ${BUILDDIR}/* || die "couldn't cleanup \$BUILDDIR."
1385	fi	fi
1386	install -d ${BUILDDIR} || die "couldn't create \$BUILDDIR."	install -d ${BUILDDIR} || die "couldn't create \$BUILDDIR."
1387
1388	#cleans up srcdir if a previously unpacked one exists	# clean up srcdir if a previously unpacked one exist
1389	if [ -d ${SRCDIR} ]	if [ -d ${SRCDIR} ]
1390	then	then
1391	rm -rf ${SRCDIR}	rm -rf ${SRCDIR}
1392	fi	fi
1393
1394	#cleans up bindir if a previous build exists or creates a new one	# clean up bindir if a previous build exist or create a new one
1395	if [ -d ${BINDIR} ]	if [ -d ${BINDIR} ]
1396	then	then
1397	rm -rf ${BINDIR}	rm -rf ${BINDIR}
1398	fi	fi
1399	install -d ${BINDIR} || die "couldn't create \$BINDIR."	install -d ${BINDIR} || die "couldn't create \$BINDIR."
1400
1401	#cleans up package temp dir if a previous build exists	# clean up package temp dir if a previous build exist
1402	if [ -d ${BUILDDIR}/${PKGNAME} ]	if [ -d ${BUILDDIR}/${PKGNAME} ]
1403	then	then
1404	rm -rf ${BUILDDIR}/${PKGNAME}	rm -rf ${BUILDDIR}/${PKGNAME}
1405	fi	fi
1406
1407	#cleans up timestamp if one exists	# setup build logging
1408	if [ -f /var/tmp/timestamp ]	[[ ! -d /var/log/smage ]] && install -d /var/log/smage
1409	then	echo -e "### Build started on $(date) ###\n" > /var/log/smage/${PKGNAME}.log
1410	mage rmstamp
1411		src_prepare | ${SMAGE_LOG_CMD}
1412		die_pipestatus 0 "src_prepare failed"
1413		step_by_step $_
1414
1415		src_compile | ${SMAGE_LOG_CMD}
1416		die_pipestatus 0 "src_compile failed"
1417		step_by_step $_
1418
1419		# only run checks if requested
1420		if [[ ${MAGE_CHECK} != true ]]
1421		then
1422		echo "MAGE_CHECK not requested; src_check() will not be run!" | ${SMAGE_LOG_CMD}
1423		step_by_step src_check
1424		else
1425		src_check | ${SMAGE_LOG_CMD}
1426		die_pipestatus 0 "src_check failed"
1427		step_by_step $_
1428		fi
1429
1430		# build several subpackages
1431		if [[ -n ${SPLIT_PACKAGES} ]]
1432		then
1433		# save bindir & pname
1434		split_save_variables
1435		export SAVED_BINDIR="${BINDIR}"
1436		for subpackage in ${SPLIT_PACKAGES}
1437		do
1438		if typeset -f src_install_${subpackage} > /dev/null
1439		then
1440		# export subpackage bindir
1441		export BINDIR="${SAVED_BINDIR}_${subpackage}"
1442		# export PNAME, several internal function and include
1443		# rely on this variable
1444		export PNAME="${subpackage}"
1445
1446		echo
1447		echo -en "${COLBLUE}*** ${COLDEFAULT}"
1448		echo -en "  Running ${COLGREEN}split src_install()${COLDEFAULT}"
1449		echo -en " for subpkg: ${COLBLUE}${PNAME}${COLDEFAULT}"
1450		echo -e " - basepkg: ${COLBLUE}${SPLIT_PACKAGE_BASE}${COLDEFAULT} ..."
1451
1452		src_install_${subpackage} | ${SMAGE_LOG_CMD}
1453		die_pipestatus 0 "src_install_${subpackage} failed"
1454		step_by_step $_
1455		fi
1456		done
1457		# restore bindir & pname
1458		split_restore_variables
1459		# unset all saved smage variables
1460		split_unset_variables
1461		else
1462		src_install | ${SMAGE_LOG_CMD}
1463		die_pipestatus 0 "src_install failed"
1464		step_by_step $_
1465	fi	fi
1466
1467	src_prepare || die "src_prepare failed"	# compressing doc, info & man files
1468	src_compile || die "src_compile failed"	if [[ -n ${SPLIT_PACKAGES} ]]
1469	src_install || die "src_install failed"	then
1470		for subpackage in ${SPLIT_PACKAGES}
1471		do
1472		mcompressdocs ${BINDIR}_${subpackage}
1473		done
1474		else
1475		mcompressdocs ${BINDIR}
1476		fi
1477
1478	#compressing doc, info & man files	if [[ ${SMAGE_STRIP_LIBTOOL} = true ]]
	echo -e "Compressing man-pages ..."
	if [ -d ${BUILDDIR}/builded/usr/share/man ]
1479	then	then
1480	${MLIBDIR}/compressdoc -g -9 ${BUILDDIR}/builded/usr/share/man	if [[ -n ${SPLIT_PACKAGES} ]]
1481		then
1482		for subpackage in ${SPLIT_PACKAGES}
1483		do
1484		echo -e "${COLBLUE}===${COLGREEN} stripping libtool archives for '${subpackage}' ...${COLDEFAULT}"
1485		mstriplibtoolarchive ${BINDIR}_${subpackage}
1486		done
1487		else
1488		echo -e "${COLBLUE}===${COLGREEN} stripping libtool archives ...${COLDEFAULT}"
1489		mstriplibtoolarchive ${BINDIR}
1490		fi
1491	fi	fi
1492
1493	echo -e "Compressing info-pages ..."	if [[ ${SMAGE_PURGE} = true ]]
	if [ -d ${BUILDDIR}/builded/usr/share/info ]
1494	then	then
1495	${MLIBDIR}/compressdoc -g -9 ${BUILDDIR}/builded/usr/share/info	if [[ -n ${SPLIT_PACKAGES} ]]
1496		then
1497		for subpackage in ${SPLIT_PACKAGES}
1498		do
1499		echo -e "${COLBLUE}===${COLGREEN} purging all purge targets in '${subpackage}' ...${COLDEFAULT}"
1500		mpurgetargets ${BINDIR}_${subpackage}
1501		done
1502		else
1503		echo -e "${COLBLUE}===${COLGREEN} purging all purge targets ...${COLDEFAULT}"
1504		mpurgetargets ${BINDIR}
1505		fi
1506	fi	fi
1507
1508	# stripping all bins and libs	# stripping all bins and libs
#	Line 661  case ${NOSTRIP} in	Line 1511  case ${NOSTRIP} in
1511	echo -e "NOSTRIP=true detected; Package will not be stripped ..."	echo -e "NOSTRIP=true detected; Package will not be stripped ..."
1512	;;	;;
1513	*)	*)
1514	echo -e "Stripping binaries ..."	if [[ -n ${SPLIT_PACKAGES} ]]
1515	mstripbins ${BINDIR}	then
1516	echo -e "Stripping libraries ..."	for subpackage in ${SPLIT_PACKAGES}
1517	mstriplibs ${BINDIR}	do
1518		echo -e "${COLBLUE}===${COLGREEN} stripping binaries for '${subpackage}' ...${COLDEFAULT}"
1519		mstripbins ${BINDIR}_${subpackage}
1520		echo -e "${COLBLUE}===${COLGREEN} stripping dynamic libraries for '${subpackage}' ...${COLDEFAULT}"
1521		mstriplibs ${BINDIR}_${subpackage}
1522		echo -e "${COLBLUE}===${COLGREEN} stripping static libraries for '${subpackage}' ...${COLDEFAULT}"
1523		mstripstatic ${BINDIR}_${subpackage}
1524		done
1525		else
1526		echo -e "${COLBLUE}===${COLGREEN} stripping binaries ...${COLDEFAULT}"
1527		mstripbins ${BINDIR}
1528		echo -e "${COLBLUE}===${COLGREEN} stripping dynamic libraries ...${COLDEFAULT}"
1529		mstriplibs ${BINDIR}
1530		echo -e "${COLBLUE}===${COLGREEN} stripping static libraries ...${COLDEFAULT}"
1531		mstripstatic ${BINDIR}
1532		fi
1533	;;	;;
1534	esac	esac
1535
1536	#the new buildpkg command	# the new buildpkg command
1537	case ${NOPKGBUILD} in	case ${NOPKGBUILD} in
1538	true|TRUE|yes|y)	true|TRUE|yes|y)
1539	echo -e "NOPGKBUILD=true detected; Package will not be build ..."	echo -e "NOPGKBUILD=true detected; Package will not be build ..."
1540	;;	;;
1541	*)	*)
1542	${MLIBDIR}/pkgbuild_dir.sh ${PKGNAME} ${BINDIR} || die "package-build failed"	# build several targets
1543	echo -e "\nPackage ${PKGNAME} successfully builded.\n"	if [[ -n ${MAGE_TARGETS} ]]
1544		then
1545		for target in ${MAGE_TARGETS}
1546		do
1547		# check if a special target_pkgbuild exists
1548		if typeset -f ${target}_pkgbuild > /dev/null
1549		then
1550		# run it
1551		${target}_pkgbuild
1552		fi
1553		# now create the target package
1554		${MLIBDIR}/pkgbuild_dir.sh \
1555		"${PNAME}-${target}-${PVER}-${ARCH}-${PBUILD}" \
1556		${BINDIR} || die "target: ${target} package-build failed"
1557
1558		# build pkg-md5-sum if requested
1559		generate_package_md5sum \
1560		--pcat "${PCATEGORIE}" \
1561		--pname "${PNAME}" \
1562		--pver "${PVER}" \
1563		--pbuild "${PBUILD}" \
1564		--parch "${ARCH}" \
1565		--target "${target}"
1566
1567		echo -e "${COLGREEN}\nPackage ${PNAME}-${target}-${PVER}-${ARCH}-${PBUILD} successfully builded.\n${COLDEFAULT}"
1568		done
1569
1570		# build several subpackages
1571		elif [[ -n ${SPLIT_PACKAGES} ]]
1572		then
1573		split_save_variables
1574		for subpackage in ${SPLIT_PACKAGES}
1575		do
1576		# get the right variables for the split
1577		export PNAME="${subpackage}"
1578		split_info_${PNAME}
1579
1580		# jump to next one if NOPKGBUILD is set in split_info
1581		case ${NOPKGBUILD} in
1582		true|TRUE|yes|y) continue ;;
1583		esac
1584
1585		# check if an special subpackage_pkgbuild exists
1586		if typeset -f ${PNAME}_pkgbuild > /dev/null
1587		then
1588		# run it
1589		${PNAME}_pkgbuild
1590		fi
1591		# now create the target package
1592		${MLIBDIR}/pkgbuild_dir.sh \
1593		"${PNAME}-${PVER}-${ARCH}-${PBUILD}" \
1594		"${BINDIR}_${PNAME}" || die "split_package: ${PNAME} package-build failed"
1595
1596		# build pkg-md5-sum if requested
1597		generate_package_md5sum \
1598		--pcat "${PCATEGORIE}" \
1599		--pname "${PNAME}" \
1600		--pver "${PVER}" \
1601		--pbuild "${PBUILD}" \
1602		--parch "${ARCH}"
1603
1604		echo -e "${COLGREEN}\nPackage ${PNAME}-${PVER}-${ARCH}-${PBUILD} successfully builded.\n${COLDEFAULT}"
1605
1606		# restore smage environment
1607		split_restore_variables
1608		done
1609		# unset all saved smage variables
1610		split_unset_variables
1611
1612		else
1613		${MLIBDIR}/pkgbuild_dir.sh ${PKGNAME} ${BINDIR} || die "package-build failed"
1614
1615		# build pkg-md5-sum if requested
1616		generate_package_md5sum \
1617		--pcat "${PCATEGORIE}" \
1618		--pname "${PNAME}" \
1619		--pver "${PVER}" \
1620		--pbuild "${PBUILD}" \
1621		--parch "${ARCH}"
1622
1623		echo -e "${COLGREEN}\nPackage ${PKGNAME} successfully builded.\n${COLDEFAULT}"
1624		fi
1625
1626		# build src-pkg-tarball if requested
1627		[[ ${CREATE_SRC_PKG_TARBALL} = true ]] && source_pkg_build ${SMAGENAME}
1628	;;	;;
1629	esac	esac
1630
1631	#for sure	if [[ ${SMAGE_BUILD_LOGGING} != false ]]
1632		then
1633		bzip2 -9f /var/log/smage/${PKGNAME}.log
1634		else
1635		[[ -f /var/log/smage/${PKGNAME}.log ]] && rm /var/log/smage/${PKGNAME}.log
1636		fi
1637
1638		# for sure
1639	unset NOPKGBUILD	unset NOPKGBUILD
1640	unset NOSTRIP	unset NOSTRIP
1641
1642	xtitleclean	xtitleclean
	#echo -e "\nPackage ${PKGNAME} successfully builded.\n"

---

Colored Diff Long Colored Diff Full Colored Diff Unidiff Context Diff Side by Side

Legend: Removed from v.169   changed lines   Added in v.1580