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

Parent Directory | Revision Log | Patch

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