Diff of /trunk/mage/usr/lib/mage/smage2.sh

Parent Directory | Revision Log | Patch

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