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

Parent Directory | Revision Log | Patch

	revision 33 by niro, Thu Jan 6 02:57:12 2005 UTC	revision 1207 by niro, Fri Jan 28 20:34:38 2011 UTC
#	Line 4	Line 4
4	# needs pkgbuild_dir (mage)	# needs pkgbuild_dir (mage)
5
6	# SMAGE2	# SMAGE2
7	# version: 0.3.6-r9	# $Header: /home/cvsd/magellan-cvs/magellan-src/mage/usr/lib/mage/smage2.sh,v 1.62 2007-11-28 10:47:50 niro Exp $
8
9	#01.10.2004	#01.10.2004
10	# added ccache support	# added ccache support
11	# added distcc support	# added distcc support
12
13		# set default user mage.rc
14		: ${MAGERC="/etc/mage.rc"}
15
16	## setup ##	## setup ##
	SMAGEVERSION=0.3.6-r8
17	PKGSUFFIX="mpk"	PKGSUFFIX="mpk"
18		SRCPKGSUFFIX="mpks"
19	SMAGENAME="$1"	SMAGENAME="$1"
20	SMAGESUFFIX="smage2"	SMAGESUFFIX="smage2"
	#SOURCEDIR="/bootstrap/sources"
	#SMAGESCRIPTSDIR="/bootstrap/smage2-install-scripts"
	#SMAGE2RSYNC="rsync://192.168.0.2/smage2-scripts"
21	MLIBDIR=/usr/lib/mage	MLIBDIR=/usr/lib/mage
22		SMAGEVERSION="$( < ${MLIBDIR}/version)"
23
24		## only for tests -> normally in /etc/rc.d/init.d/functions
25		COLRED="\033[1;6m\033[31m"
26		COLGREEN="\033[1;6m\033[32m"
27		COLYELLOW="\033[1;6m\033[33m"
28		COLBLUE="\033[1;6m\033[34m"
29		COLMAGENTA="\033[1;6m\033[35m"
30		COLWHITE="\033[1;6m\033[37m"
31		COLGRAY="\033[0;6m\033[37m"
32		COLBOLD="\033[1m"
33		COLDEFAULT="\033[0m"
34
35		if [[ ${NOCOLORS} = true ]]
36		then
37		COLRED=""
38		COLGREEN=""
39		COLYELLOW=""
40		COLBLUE=""
41		COLMAGENTA=""
42		COLWHITE=""
43		COLGRAY=""
44		COLBOLD=""
45		COLDEFAULT=""
46		fi
47
48		# export default C locale
49		export LC_ALL=C
50
51	source /etc/mage.rc	source /etc/mage.rc.global
52		source ${MAGERC}
53
54	showversion() {	# set PKGDIR and BUILDDIR and BINDIR to MROOT
55		if [[ -n ${MROOT} ]]
56		then
57		export PKGDIR=${MROOT}/${PKGDIR}
58		export BUILDDIR=${MROOT}/${BUILDDIR}
59		export BINDIR=${MROOT}/${BINDIR}
60		fi
61
62		showversion()
63		{
64	echo -en "Magellan Source Install v${SMAGEVERSION} "	echo -en "Magellan Source Install v${SMAGEVERSION} "
65	echo -e  "-- Niels Rogalla (niro@magellan-linux.de)"	echo -e  "-- Niels Rogalla (niro@magellan-linux.de)"
66	}	}
67
68	die() {	die()
69		{
70	xtitleclean	xtitleclean
71		echo -e ${COLRED}"Exited ${BASH_SOURCE} at line no ${BASH_LINENO}."${COLDEFAULT}
72	echo "SMAGE failed: $@"	echo "SMAGE failed: $@"
73	exit 1	exit 1
74	}	}
75
76	xtitle() {	die_pipestatus()
77	if [ ${TERM} == "xterm" ]	{
78		# the status change if we do any parameter declarations!!
79		# dont do this anymore, keep this in mind!
80		#
81		# local pos="$1"
82		# local comment="$2"
83		#
84		# [ ${PIPESTATUS[${pos}]} -ne 0 ] && die "${comment}"
85		#
86		[ ${PIPESTATUS[$1]} -ne 0 ] && die "$2"
87		}
88
89		xtitle()
90		{
91		if [[ ${TERM} = xterm ]]
92	then	then
93	echo -ne "\033]0;[sMage: $@]\007"	echo -ne "\033]0;[sMage: $@]\007"
94	fi	fi
95	return 0	return 0
96	}	}
97
98	xtitleclean() {	xtitleclean()
99	if [ ${TERM} == "xterm" ]	{
100		if [[ ${TERM} = xterm ]]
101	then	then
102	echo -ne "\033]0;\007"	echo -ne "\033]0;\007"
103	fi	fi
104	return 0	return 0
105	}	}
106
107	syncsmage2() {	syncsmage2()
108		{
109	xtitle "Updating smage2-script tree ..."	xtitle "Updating smage2-script tree ..."
110	local i	local i
111	for i in ${SMAGE2RSYNC}	for i in ${SMAGE2RSYNC}
112	do	do
113	rsync \	rsync ${RSYNC_FETCH_OPTIONS} ${i} ${SMAGESCRIPTSDIR}
114	--recursive \	if [[ $? = 0 ]]
	--links \
	--perms \
	--times \
	--devices \
	--timeout=600 \
	--verbose \
	--compress \
	--progress \
	--stats \
	--delete \
	--delete-after \
	${i} ${SMAGESCRIPTSDIR}
	if [ "$?" == "0" ]
115	then	then
116	break	break
117	else	else
118	continue	continue
119	fi	fi
120	done	done
121
122	#clean up backup files (foo~)	# clean up backup files (foo~)
123	find ${SMAGESCRIPTSDIR} -name *~ -exec rm '{}' ';'	find ${SMAGESCRIPTSDIR} -name *~ -exec rm '{}' ';'
124
125	xtitleclean	xtitleclean
126	}	}
127
128		# $1 filename
129		get_db_md5_sum()
130		{
131		local DB_FILE
132		local MD5_FILE
133		local i
134
135		DB_ENTRY="$(basename $1)"
136		MD5_FILE="${MD5DIR}/$(basename ${SMAGENAME} ${SMAGESUFFIX})"
137
138		i="$(cat ${MD5_FILE}| grep ${DB_ENTRY} | cut -d' ' -f1)"
139
140		echo "${i}"
141		}
142
143		download_sources()
144		{
145
146		[ -z "${SRC_URI}" ] && echo -e "\nNothing declared to download.\n" && return 0
147
148		local EOA=${#SRC_URI[*]}
149		local my_SRC_URI
150		local my_SRC_URI_DEST
151		local my_SRC_URI_MIRROR
152		local my_SOURCEDIR
153		local DB_MD5_SUM_FILE="${MD5DIR}/$(basename ${SMAGENAME} .${SMAGESUFFIX}).md5"
154		local FETCHING
155		local i mirror
156
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 --check ${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_FETCH_OPTIONS} \
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_FETCH_OPTIONS} \
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_FETCH_OPTIONS} \
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_FETCH_OPTIONS} \
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_FETCH_OPTIONS} \
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_FETCH_OPTIONS} \
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 --check ${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 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)	tbz2|mpks|mpk)
442	tar --no-same-owner -xvjf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST}	tar --no-same-owner -xvjf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tbz2 unpack failed."
443	;;	;;
444	tgz)	tgz)
445	tar --no-same-owner -xvzf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST}	tar --no-same-owner -xvzf ${SOURCEDIR}/${PNAME}/${SRCFILE} -C ${DEST} || die ".tgz unpack failed."
446		;;
447		rar)
448		unrar x ${SOURCEDIR}/${PNAME}/${SRCFILE} ${DEST}  || die ".rar unpack failed."
449		;;
450		zip|xpi)
451		unzip ${SOURCEDIR}/${PNAME}/${SRCFILE} -d ${DEST} || die ".zip unpack failed."
452		;;
453		rpm)
454		pushd ${DEST} > /dev/null
455		rpm2targz ${SOURCEDIR}/${PNAME}/${SRCFILE} || die "rpm2targz: .rpm unpack failed."
456		tar --no-same-owner -xvzf ${SRCFILE/.rpm/.tar.gz} || die "tar: .rpm unpack failed."
457		if [[ -f ${DEST}/${SRCFILE/.rpm/.tar.gz} ]]
458		then
459		rm ${DEST}/${SRCFILE/.rpm/.tar.gz}
460		fi
461	;;	;;
462	*)	*)
463	die "munpack failed"	die "munpack failed"
#	Line 189  munpack() {	Line 465  munpack() {
465	esac	esac
466	}	}
467
468	mpatch() {	mpatch()
469		{
470	local PATCHOPTS	local PATCHOPTS
471	local PATCHFILE	local PATCHFILE
472		local i
473
474	PATCHOPTS=$1	PATCHOPTS=$1
475	PATCHFILE=$2	PATCHFILE=$2
476
477		if [[ -z $2 ]]
478		then
479		PATCHFILE=$1
480
481		## patch level auto-detection, get patch level
482		for ((i=0; i < 10; i++))
483		do
484		patch --dry-run -Np${i} -i ${SOURCEDIR}/${PNAME}/${PATCHFILE} > /dev/null
485		if [[ $? = 0 ]]
486		then
487		PATCHOPTS="-Np${i}"
488		break
489		fi
490		done
491		fi
492
493		echo -e "${COLBLUE}*** ${COLGREEN}Applying patch '${PATCHFILE}'${COLDEFAULT}"
494	patch "${PATCHOPTS}" -i ${SOURCEDIR}/${PNAME}/${PATCHFILE}	patch "${PATCHOPTS}" -i ${SOURCEDIR}/${PNAME}/${PATCHFILE}
495	}	}
496
497		mlibtoolize()
498		{
499		local opts="$@"
500		[[ -z ${opts} ]] && opts="--copy --force"
501
502	minstalldocs() {	libtoolize ${opts} || die "running: mlibtoolize ${opts}"
503		}
504
505		minstalldocs()
506		{
507	local docfiles	local docfiles
508	docfiles="$@"	docfiles="$@"
509
510	if [ ! -d ${BINDIR}/usr/share/doc/${PNAME}-${PVER} ]	if [ ! -d ${BINDIR}/usr/share/doc/${PNAME}-${PVER} ]
511	then	then
512	install -d ${BINDIR}/usr/share/doc/${PNAME}-${PVER} || die "creating doc dirs."	install -d ${BINDIR}/usr/share/doc/${PNAME}-${PVER} || die "creating doc dirs."
513	fi	fi
514
515		local i
516	for i in ${docfiles}	for i in ${docfiles}
517	do	do
518	cat ${i} | gzip -9c > ${i}.gz || die "gzipping docs."	if [ -f ${i} ]
519	install -m 0644 ${SRCDIR}/${i}.gz \	then
520	${BINDIR}/usr/share/doc/${PNAME}-${PVER} || die "coping docs."	cat ${i} | gzip -9c > ${i}.gz || die "gzipping docs."
521		install -m 0644 ${SRCDIR}/${i}.gz \
522		${BINDIR}/usr/share/doc/${PNAME}-${PVER} || die "coping docs."
523		fi
524	done	done
525	}	}
526
527	setup_distcc_environment(){	mstriplibs()
528	if [ -x /usr/bin/distcc ]	{
529		local stripdir="$@"
530
531		[ -z "${stripdir}" ] && stripdir=${BINDIR}
532		find ${stripdir} | xargs file | grep "shared object" | grep ELF | cut -f 1 -d : | xargs strip --strip-unneeded 2> /dev/null
533		}
534
535		mstripbins()
536		{
537		local stripdir="$@"
538
539		[ -z "${stripdir}" ] && stripdir=${BINDIR}
540		find ${stripdir} | xargs file | grep "executable" | grep ELF | cut -f 1 -d : | xargs strip --strip-unneeded 2> /dev/null
541		}
542
543		mcompressdocs()
544		{
545		local bindir="$@"
546
547		if [ -d ${bindir}/usr/share/man ]
548		then
549		echo -e "${COLBLUE}===${COLGREEN} compressing man-pages ...${COLDEFAULT}"
550		${MLIBDIR}/compressdoc -g -9 ${bindir}/usr/share/man
551		fi
552
553		if [ -d ${bindir}/usr/share/info ]
554	then	then
555	echo "Using DistCC for compilation ..."	echo -e "${COLBLUE}===${COLGREEN} compressing info-pages ...${COLDEFAULT}"
556	export PATH=/usr/lib/distcc/bin:${PATH} || die "distcc: could not export new $PATH"	${MLIBDIR}/compressdoc -g -9 ${bindir}/usr/share/info
557		fi
558		}
559
560		sminclude()
561		{
562		local i
563
564		if [[ -n "$@" ]]
565		then
566		for i in $@
567		do
568		echo "--- Including ${SMAGESCRIPTSDIR}/include/${i}.sminc"
569		source ${SMAGESCRIPTSDIR}/include/${i}.sminc
570		done
571		echo
572		fi
573		}
574
575	#export distcc as compiler	setup_distcc_environment()
576	# export CC="distcc"	{
577	# export CXX=distcc	if [ -x /usr/bin/distcc ]
578		then
579		echo -e "${COLBLUE}---${COLGREEN} Using DistCC for compilation ...${COLDEFAULT}"
580		export PATH=/usr/$(mlibdir)/distcc/bin:${PATH} || die "distcc: could not export new $PATH"
581
582	export DISTCC_DIR="${DISTCC_DIR}" || die "distcc_dir export failed"	export DISTCC_DIR="${DISTCC_DIR}" || die "distcc_dir export failed"
583
584		# creating distcc tempdir
585		install -o distcc -g daemon -d ${DISTCC_DIR}
586		chmod 1777 ${DISTCC_DIR}
587		fi
588		}
589
590	#ccache + distcc together	setup_ccache_environment()
591	if [ "${SMAGE_USE_CCACHE}" == "true" ]	{
592	then	if [ -x /usr/bin/ccache ]
593	if [ -x /usr/bin/ccache ]	then
594		echo -e "${COLBLUE}---${COLGREEN} Using CCache for compilation ...${COLDEFAULT}"
595		export PATH=/usr/$(mlibdir)/ccache/bin:${PATH} || die "ccache: could not export new $PATH"
596		fi
597		}
598
599
600		# fixes given dependencies to match a MAGE_TARGET
601		# fix_mage_deps -target s/depend # <-- note -target !
602		fix_mage_deps()
603		{
604		local target="$1"
605		local depend="$2"
606		local NDEPEND
607		local sym dep cat pver pname
608
609		# deps and provides are special
610		# they must be fixed to match the target
611
612		# run this only if target and depend is not empty
613		if [ -n "${target}" ] && [ -n "${depend}" ]
614		then
615		# fix DEPEND
616		while read sym dep
617		do
618		# ignore empty lines
619		[[ -z ${dep} ]] && continue
620
621		cat="$(dirname ${dep})"
622		# change if not virtual
623		if [[ ${cat} = virtual ]]
624		then
625		pname="$(basename ${dep})"
626		else
627		# fix pver to target-pver
628		# to get pname-target-pver
629
630		# doing it backwards !
631		pver="${dep##*-}"
632		# full pver
633		pname="$(basename ${dep/-${pver}/})${target}-${pver}"
634		fi
635
636		# do not add empty lines
637		if [ -z "${NDEPEND}" ]
638	then	then
639	echo "Preparing DistCC to work together with CCache ..."	NDEPEND="${sym} ${cat}/${pname}"
640	#export CCACHE_PREFIX="distcc" || die "distcc: could not set ccach_prefix"	else
641	# export CC="ccache distcc"	NDEPEND="${NDEPEND}
642	# export CXX="ccache distcc"	${sym} ${cat}/${pname}"
643	fi	fi
644
645		unset cat pname pver
646		done << EOF
647		${depend}
648		EOF
649		# set NDEPEND to DEPEND
650		depend="${NDEPEND}"
651		fi
652
653		echo "${depend}"
654		}
655
656		# build_mage_script(): helper functions for regen_mage_tree()
657		# generates an mage file with given information in smage file
658		# needs at least:
659		#   PNAME                 name of pkg
660		#   PVER                  version
661		#   PBUILD                revision
662		#   PCATEGORIE            categorie of the pkg
663		#   STATE                 state of pkg stable|unstable|old
664		#   DESCRIPTION           va short description (opt)
665		#   HOMEPAGE              homepage (opt)
666		#   DEPEND                runtime dependencies (opt)
667		#   SDEPEND               add. needed deps to build the pkg (opt)
668		#   PROVIDE               provides a virtual (opt)
669		#
670		# special tags:
671		#   PKGTYPE               type of pkg
672		#   INHERITS              which functions get included
673		#   SPECIAL_FUNCTIONS     special functions which should also be added
674		#                         warning: they get killed before the build starts !
675		#   SPLIT_PACKAGES        names of all subpackages which are splitted from parent
676		#   SPLIT_PACKAGE_BASE    base package name for splitpackages
677		#                         (only in the resulting magefile}
678		#
679		#   MAGE_TREE_DEST        target destination of the generated tree
680		#   REGEN_MAGE_TREE       set to 'true' to enable this
681		#
682		# gets called with build_mage_script target
683		build_mage_script()
684		{
685		local magefile
686		local dest
687		local target
688		local split_pkg_base
689		local sym
690		local depname
691
692		# if MAGE_TREE_DEST not set use BUILDDIR
693		: ${MAGE_TREE_DEST=${BUILDDIR}/mage-tree}
694
695		# determinate which suffix this mage file should get, if any
696		[[ $1 = --target ]] && shift && target="-$1"
697
698		# mark package as splitpackage
699		[[ $1 = --split-pkg-base ]] && shift && split_pkg_base="$1"
700
701		# name of magefile
702		magefile="${PNAME}${target}-${PVER}-${PBUILD}.mage"
703
704		# destination to magefile
705		dest="${MAGE_TREE_DEST}/${PCATEGORIE}/${PNAME}${target}/${magefile}"
706
707		# show what we are doing
708		echo -e "${COLBLUE}===${COLGREEN} generating mage file:${COLDEFAULT}"
709		echo "${dest}"
710
711		install -d "$(dirname ${dest})"
712		# now build the mage file
713		> ${dest}
714
715		# header
716		echo '# $Header: /home/cvsd/magellan-cvs/magellan-src/mage/usr/lib/mage/smage2.sh,v 1.62 2007-11-28 10:47:50 niro Exp $' >> ${dest}
717		echo  >> ${dest}
718
719		# pgkname and state
720		echo "PKGNAME=\"${PNAME}${target}-${PVER}-\${ARCH}-${PBUILD}\"" >> ${dest}
721		echo "STATE=\"${STATE}\"" >> ${dest}
722		echo >> ${dest}
723
724		# description and homepage
725		echo "DESCRIPTION=\"${DESCRIPTION}\"" >> ${dest}
726		echo "HOMEPAGE=\"${HOMEPAGE}\"" >> ${dest}
727		echo >> ${dest}
728
729		# special tags and vars
730		echo "PKGTYPE=\"${PKGTYPE}\""  >> ${dest}
731
732		# echo MAGE_TARGETS ## note -target is needed !
733		echo "MAGE_TARGETS=\"${target}\"" >> ${dest}
734		echo >> ${dest}
735
736		# split package base
737		echo "SPLIT_PACKAGE_BASE=\"${split_pkg_base}\"" >> ${dest}
738		echo >> ${dest}
739
740		# add special vars
741		if [ -n "${SPECIAL_VARS}" ]
742		then
743		local i
744		for i in ${SPECIAL_VARS}
745		do
746		# being tricky here :)
747		echo "${i}=\"$(eval echo \$${i})\"" >> ${dest}
748		done
749		echo  >> ${dest}
750		fi
751
752		# add at least all includes
753		if [ -n "${INHERITS}" ]
754		then
755		echo -n "minclude"  >> ${dest}
756		local i
757		for i in ${INHERITS}
758		do
759		echo -n " ${i}"  >> ${dest}
760		done
761		echo  >> ${dest}
762		fi
763		echo >> ${dest}
764
765		# deps and provides
766		echo "DEPEND=\"$(fix_mage_deps "${target}" "${DEPEND}")\"" >> ${dest}
767		echo >> ${dest}
768		echo "SDEPEND=\"$(fix_mage_deps "${target}" "${SDEPEND}")\"" >> ${dest}
769		echo >> ${dest}
770		echo "PROVIDE=\"${PROVIDE}\"" >> ${dest}
771		echo >> ${dest}
772
773		# add special functions
774		if [ -n "${SPECIAL_FUNCTIONS}" ]
775		then
776		local i
777		for i in ${SPECIAL_FUNCTIONS}
778		do
779		# add to mage (quotes needed !)
780		typeset -f "${i}" >> ${dest}
781		echo >> ${dest}
782		# unset to be safe (quotes needed !)
783		#unset "${i}" <-- later to get every target built
784		done
785		echo  >> ${dest}
786		fi
787
788		# pre|post-install|removes
789		typeset -f preinstall >> ${dest}
790		echo  >> ${dest}
791		typeset -f postinstall >> ${dest}
792		echo  >> ${dest}
793		typeset -f preremove >> ${dest}
794		echo  >> ${dest}
795		typeset -f postremove >> ${dest}
796		echo  >> ${dest}
797		}
798
799		regen_mage_tree()
800		{
801		local i
802
803		# build them only if requested
804		if [[ ${REGEN_MAGE_TREE} = true ]]
805		then
806		# run it without targets
807		if [[ -n ${MAGE_TARGETS} ]]
808		then
809		# build for each target a mage file
810		# run it with several targets
811		echo
812		for i in ${MAGE_TARGETS}
813		do
814		build_mage_script --target "${i}"
815		done
816		echo
817
818		# run it for splitpackages
819		elif [[ -n ${SPLIT_PACKAGES} ]]
820		then
821		local split_pkg_base="${PNAME}"
822		# save smage environment
823		split_save_variables
824		# build for each subpackage a mage file
825		# run it with several targets
826		echo
827		for i in ${SPLIT_PACKAGES}
828		do
829		# get the right variables for the split
830		export PNAME="${i}"
831		split_info_${i}
832		build_mage_script --split-pkg-base "${split_pkg_base}"
833		# restore smage environment
834		split_restore_variables
835		done
836		echo
837		# unset all saved smage variables
838		split_unset_variables
839
840		else
841		echo
842		build_mage_script
843		echo
844	fi	fi
845		fi
846
847	#creating distcc tempdir	# now unset all uneeded vars to be safe
848	install -o distcc -g daemon -d ${DISTCC_DIR}	# unset PKGNAME <-- don't do that; smage needs this var
849	chmod 1777 ${DISTCC_DIR}	# unset to be safe (quotes needed !)
850		# for i in ${SPECIAL_FUNCTIONS}
851		# do
852		# unset "${i}"
853		# done
854		unset SPECIAL_FUNCTIONS
855		# for i in ${SPECIAL_VARS}
856		# do
857		# unset "${i}"
858		# done
859		unset SPECIAL_VARS
860		unset STATE
861		unset DESCRIPTION
862		unset HOMEPAGE
863		unset PKGTYPE
864		unset INHERITS
865		unset DEPEND
866		unset SDEPEND
867		unset PROVIDE
868		unset preinstall
869		unset postinstall
870		unset preremove
871		unset postremove
872		}
873
874		split_save_variables()
875		{
876		export SAVED_PNAME="${PNAME}"
877		export SAVED_PVER="${PVER}"
878		export SAVED_PBUILD="${PBUILD}"
879		export SAVED_PCATEGORIE="${PCATEGORIE}"
880		export SAVED_DESCRIPTION="${DESCRIPTION}"
881		export SAVED_HOMEPAGE="${HOMEPAGE}"
882		export SAVED_SPECIAL_VARS="${SPECIAL_VARS}"
883		export SAVED_STATE="${STATE}"
884		export SAVED_PKGTYPE="${PKGTYPE}"
885		export SAVED_INHERITS="${INHERITS}"
886		export SAVED_DEPEND="${DEPEND}"
887		export SAVED_SDEPEND="${SDEPEND}"
888		export SAVED_PROVIDE="${PROVIDE}"
889		export SAVED_NOPKGBUILD="${NOPKGBUILD}"
890
891		# bindir too
892		export SAVED_BINDIR="${BINDIR}"
893
894		# export the SPLIT_PACKAGE_BASE
895		export SPLIT_PACKAGE_BASE="${SAVED_PNAME}"
896
897		# functions
898		if [[ ! -z $(typeset -f preinstall) ]]
899		then
900		# rename the old one
901		local saved_preinstall
902		saved_preinstall=SAVED_$(typeset -f preinstall)
903		eval "${saved_preinstall}"
904		export -f SAVED_preinstall
905		fi
906
907		if [[ ! -z $(typeset -f postinstall) ]]
908		then
909		# rename the old one
910		local saved_postinstall
911		saved_postinstall=SAVED_$(typeset -f postinstall)
912		eval "${saved_postinstall}"
913		export -f SAVED_postinstall
914		fi
915
916		if [[ ! -z $(typeset -f preremove) ]]
917		then
918		# rename the old one
919		local saved_preremove
920		saved_preremove=SAVED_$(typeset -f preremove)
921		eval "${saved_preremove}"
922		export -f SAVED_preremove
923		fi
924
925		if [[ ! -z $(typeset -f postremove) ]]
926		then
927		# rename the old one
928		local saved_postremove
929		saved_postremove=SAVED_$(typeset -f postremove)
930		eval "${saved_postremove}"
931		export -f SAVED_postremove
932	fi	fi
933	}	}
934
935	setup_ccache_environment(){	split_restore_variables()
936	if [ -x /usr/bin/ccache ]	{
937		export PNAME="${SAVED_PNAME}"
938		export PVER="${SAVED_PVER}"
939		export PBUILD="${SAVED_PBUILD}"
940		export PCATEGORIE="${SAVED_PCATEGORIE}"
941		export DESCRIPTION="${SAVED_DESCRIPTION}"
942		export HOMEPAGE="${SAVED_HOMEPAGE}"
943		export SPECIAL_VARS="${SAVED_SPECIAL_VARS}"
944		export STATE="${SAVED_STATE}"
945		export PKGTYPE="${SAVED_PKGTYPE}"
946		export INHERITS="${SAVED_INHERITS}"
947		export DEPEND="${SAVED_DEPEND}"
948		export SDEPEND="${SAVED_SDEPEND}"
949		export PROVIDE="${SAVED_PROVIDE}"
950		export NOPKGBUILD="${SAVED_NOPKGBUILD}"
951
952		# bindir too
953		export BINDIR="${SAVED_BINDIR}"
954
955		# functions
956		if [[ ! -z $(typeset -f SAVED_preinstall) ]]
957		then
958		# rename the old one
959		local saved_preinstall
960		saved_preinstall=$(typeset -f SAVED_preinstall)
961		eval "${saved_preinstall/SAVED_/}"
962		export -f preinstall
963		fi
964
965		if [[ ! -z $(typeset -f SAVED_postinstall) ]]
966		then
967		# rename the old one
968		local saved_postinstall
969		saved_postinstall=$(typeset -f SAVED_postinstall)
970		eval "${saved_postinstall/SAVED_/}"
971		export -f postinstall
972		fi
973
974		if [[ ! -z $(typeset -f SAVED_preremove) ]]
975		then
976		# rename the old one
977		local saved_preremove
978		saved_preremove=$(typeset -f SAVED_preremove)
979		eval "${saved_preremove/SAVED_/}"
980		export -f preremove
981		fi
982
983		if [[ ! -z $(typeset -f SAVED_postremove) ]]
984		then
985		# rename the old one
986		local saved_postremove
987		saved_postremove=$(typeset -f SAVED_postremove)
988		eval "${saved_postremove/SAVED_/}"
989		export -f postremove
990		fi
991		}
992
993		split_unset_variables()
994		{
995		# unset saved vars; not needed anymore
996		unset SAVED_PNAME
997		unset SAVED_PVER
998		unset SAVED_PBUILD
999		unset SAVED_PCATEGORIE
1000		unset SAVED_DESCRIPTION
1001		unset SAVED_HOMEPAGE
1002		unset SAVED_SPECIAL_VARS
1003		unset SAVED_STATE
1004		unset SAVED_PKGTYPE
1005		unset SAVED_INHERITS
1006		unset SAVED_DEPEND
1007		unset SAVED_SDEPEND
1008		unset SAVED_PROVIDE
1009		unset SAVED_BINDIR
1010		unset SAVED_NOPKGBUILD
1011		unset SPLIT_PACKAGE_BASE
1012		unset -f SAVED_preinstall
1013		unset -f SAVED_postinstall
1014		unset -f SAVED_preremove
1015		unset -f SAVED_postremove
1016		}
1017
1018		export_inherits()
1019		{
1020		local include="$1"
1021		shift
1022
1023		while [ "$1" ]
1024		do
1025		local functions="$1"
1026
1027		# sanity checks
1028		[ -z "${include}" ] && die "export_inherits(): \$include not given."
1029		[ -z "${functions}" ] && die "export_inherits(): \$functions not given."
1030
1031		eval "${functions}() { ${include}_${functions} ; }"
1032
1033		# debug
1034		[[ ${MAGEDEBUG} = on ]] && typeset -f "${functions}"
1035
1036		shift
1037		done
1038		}
1039
1040		generate_package_md5sum()
1041		{
1042		local dest
1043		local pcat
1044		local pname
1045		local pver
1046		local pbuild
1047		local parch
1048		local target
1049		local pkgname
1050
1051		# very basic getops
1052		for i in $*
1053		do
1054		case $1 in
1055		--pcat|-c) shift; pcat="$1" ;;
1056		--pname|-n) shift; pname="$1" ;;
1057		--pver|-v) shift; pver="$1" ;;
1058		--pbuild|-b) shift; pbuild="$1" ;;
1059		--parch|a) shift; parch="$1" ;;
1060		--target|t) shift; target="$1" ;;
1061		esac
1062		shift
1063		done
1064
1065		# sanity checks; abort if not given
1066		[ -z "${pcat}" ] && die "generate_package_md5sum() \$pcat not given."
1067		[ -z "${pname}" ] && die "generate_package_md5sum() \$pname not given."
1068		[ -z "${pver}" ] && die "generate_package_md5sum() \$pver not given."
1069		[ -z "${pbuild}" ] && die "generate_package_md5sum() \$pbuild not given."
1070		[ -z "${parch}" ] && die "generate_package_md5sum() \$parch not given."
1071
1072		# check needed global vars
1073		[ -z "${PKGDIR}" ] && die "generate_package_md5sum() \$PKGDIR not set."
1074		[ -z "${PKGSUFFIX}" ] && die "generate_package_md5sum() \$PKGSUFFIX not set."
1075
1076		# fix target as it may be empty !
1077		[ -n "${target}" ] && target="-${target}"
1078
1079
1080		# build pkgname
1081		pkgname="${pname}${target}-${pver}-${parch}-${pbuild}"
1082
1083		# build pkg-md5-sum only if requested
1084		if [[ ${REGEN_MAGE_TREE} = true ]]
1085		then
1086		echo -ne "${COLBLUE}===${COLGREEN} generating md5's for ${pkgname}.${PKGSUFFIX} ... ${COLDEFAULT}"
1087
1088		# abort if not exist
1089		if [ ! -f ${PKGDIR}/${pkgname}.${PKGSUFFIX} ]
1090		then
1091		echo -e "${COLRED}! exists${COLDEFAULT}"
1092		return 0
1093		fi
1094
1095		# if MAGE_TREE_DEST not set use BUILDDIR
1096		: ${MAGE_TREE_DEST=${BUILDDIR}/mage-tree}
1097
1098		# setup md5 dir
1099		dest="${MAGE_TREE_DEST}/${pcat}/${pname}${target}/md5"
1100		install -d ${dest}
1101
1102		# gen md5sum
1103		( cd ${PKGDIR}; md5sum "${pkgname}.${PKGSUFFIX}" ) \
1104		> ${dest}/${pkgname}.md5
1105		echo -e "${COLGREEN}done${COLDEFAULT}"
1106		fi
1107		}
1108
1109		source_pkg_build()
1110		{
1111		if [[ ${PKGTYPE} = virtual ]]
1112		then
1113		echo "Virtual package detected; src-pkg-tarball not necessary ..."
1114		return 0
1115		fi
1116
1117		if [[ ! -d ${SOURCEDIR}/${PNAME} ]]
1118	then	then
1119	echo "Using CCache for compilation ..."	echo "No SRC_URI defined; src-pkg-tarball not necessary ..."
1120	export PATH=/usr/lib/ccache/bin:${PATH} || die "ccache: could not export new $PATH"	return 0
	#unset CC CXX
1121	fi	fi
1122
1123		[ -z "${SRCPKGDIR}" ] && die "\$SRCPKGDIR not found. Please setup your ${MAGERC} correctly."
1124
1125		echo -e "${COLGREEN}Creating source package tarball ... ${COLDEFAULT}"
1126
1127		# include the smage2 file
1128		cp ${SMAGENAME} ${SOURCEDIR}/${PNAME}
1129
1130		( cd ${SOURCEDIR}; tar cvjf ${BUILDDIR}/${PNAME}-${PVER}-${PBUILD}.tar.bz2 ${PNAME}; )
1131		[[ ! -d ${SRCPKGDIR} ]] && install -d ${SRCPKGDIR}
1132		mv ${BUILDDIR}/${PNAME}-${PVER}-${PBUILD}.tar.bz2 ${SRCPKGDIR}/${PNAME}-${PVER}-${PBUILD}.${SRCPKGSUFFIX}
1133
1134		echo -e "${COLGREEN}Source package ${COLBLUE}${PNAME}-${PVER}-${PBUILD}.${SRCPKGSUFFIX} ${COLGREEN}successfully builded.${COLDEFAULT}"
1135	}	}
1136
1137		step_by_step()
1138		{
1139		if [[ ${STEP_BY_STEP} = true ]]
1140		then
1141		echo -e "${COLRED}Step-by-step enabled! Paused after $1.${COLDEFAULT}"
1142		echo "Press [enter] to continue"
1143		read
1144		fi
1145		}
1146
1147
1148		# print out our version
1149		showversion
1150		echo
1151
1152	if [ -z "$1" ]	if [ -z "$1" ]
1153	then	then
	showversion
	echo
1154	echo "No .smage2 file given. Exiting."	echo "No .smage2 file given. Exiting."
1155	echo	echo
1156	exit 1	exit 1
1157	fi	fi
1158
1159	#updating smage2-scripts	# updating smage2-scripts
1160	if [ "$1" == "update" ]	if [[ $1 = update ]]
1161	then	then
1162	showversion	if [ ! -d ${SOURCEDIR} ]
	if [ ! -d ${SMAGESCRIPTSDIR} ]
1163	then	then
1164	install -d ${SMAGESCRIPTSDIR}	install -d ${SOURCEDIR}
1165	fi	fi
1166	syncsmage2	syncsmage2
1167	exit 0	exit 0
1168	fi	fi
1169
1170		# creates md5sums for smages to given dir
1171	if [ ! -e ${MLIBDIR}/pkgbuild_dir.sh ]	if [[ $1 = calcmd5 ]]
1172	then	then
1173	die "Error: ${MLIBDIR}/pkgbuild_dir.sh not found. Aborting."	if [ $# -ge 2 ]
1174	fi	then
1175		SMAGENAME="$2"
1176		MD5DIR="$3"
1177		[[ -z ${MD5DIR} ]] && MD5DIR="$(dirname ${SMAGENAME})/md5"
1178
1179	if [ -z "`basename ${SMAGENAME}|grep .${SMAGESUFFIX}`" ]	source ${SMAGENAME} || die "download source failed"
	then
	die "File '`basename ${SMAGENAME}`' is not a sMage v${SMAGEVERSION} file. Aborting."
	fi
1180
1181	if [ -z "${SOURCEDIR}" ]	# overridable sourcedir; must be declared after source of the smage2
1182	then	CALC_SOURCEDIR="${CALC_SOURCEDIR:="${SOURCEDIR}/${PNAME}"}"
	die "\$SOURCEDIR not found. Please setup your mage.rc correctly."
	fi
1183
1184	if [ -z "${SMAGESCRIPTSDIR}" ]	[ -z "${SRC_URI}" ] && die "Nothing declared to calculate."
	then
	die "\$SMAGESCRIPTSDIR not found. Please setup your mage.rc correctly."
	fi
1185
1186	if [ -z "${SMAGE2RSYNC}" ]	# end of array
1187	then	EOA=${#SRC_URI[*]}
1188	echo "\$SMAGE2RSYNC not found. Please setup your mage.rc correctly."
1189	exit 1	[ ! -d ${MD5DIR} ] && install -d ${MD5DIR}
1190
1191		# clear md5sum file
1192		MY_MD5_FILE="${MD5DIR}/$(basename ${SMAGENAME} .${SMAGESUFFIX}).md5"
1193		echo -n > ${MY_MD5_FILE}
1194
1195		for ((i=0; i < EOA; i++))
1196		do
1197		# url to file
1198		my_SRC_URI="$(echo ${SRC_URI[${i}]} | cut -d' ' -f1)"
1199
1200		# subdir in sources dir; the my_SRCI_URI file goes to there
1201		my_SRC_URI_DEST="$(echo ${SRC_URI[${i}]} | cut -d' ' -f2)"
1202
1203		# if my_src_uri_dest is not equal my_src_uri; than an other dir is used
1204		if [[ ${my_SRC_URI_DEST} != ${my_SRC_URI} ]]
1205		then
1206		MY_SRC_FILE="${my_SRC_URI_DEST}/$(basename ${SRC_URI[${i}]})"
1207		else
1208		MY_SRC_FILE="$(basename ${SRC_URI[${i}]})"
1209		fi
1210
1211		if [ -e "${CALC_SOURCEDIR}/${MY_SRC_FILE}" ]
1212		then
1213		echo "calculating $(basename ${MY_SRC_FILE}) ..."
1214		( cd ${CALC_SOURCEDIR}; md5sum "${MY_SRC_FILE}" ) >> ${MY_MD5_FILE}
1215		else
1216		echo "WARNING: File '$(basename ${MY_SRC_FILE}) not found in ${CALC_SOURCEDIR}."
1217		fi
1218
1219		# unset them to be shure
1220		unset my_SRC_URI
1221		unset my_SRC_URI_DEST
1222		unset my_SRC_URI_MIRROR
1223		unset my_SOURCEDIR
1224		done
1225
1226		echo
1227		echo "Calculating of md5 sums for '$(basename ${SMAGENAME} .${SMAGESUFFIX})' done."
1228		echo
1229		else
1230		echo "Usage: Calculating MD5 Sums:"
1231		echo "    $(basename $0) calcmd5 /path/to/SMAGENAME [/path/to/MD5DIR]"
1232		echo
1233		echo
1234		echo "Export the CALC_SOURCEDIR variable to override current SOURCEDIRs."
1235		echo
1236		exit 1
1237		fi
1238
1239		exit 0
1240	fi	fi
1241
1242	if [ -z "${BINDIR}" ]	# download sources
1243		if [ "$1" == "download" -a -n "$2" ]
1244	then	then
1245	die "no BINDIR variable found in /etc/mage.rc"	if [ ! -d ${SMAGESCRIPTSDIR} ]
1246		then
1247		install -d ${SMAGESCRIPTSDIR}
1248		fi
1249
1250		# get smage
1251		SMAGENAME="$2"
1252		MD5DIR="$(dirname ${SMAGENAME})/md5"
1253		source ${SMAGENAME} || die "download source failed"
1254
1255		download_sources
1256		exit 0
1257	fi	fi
1258
1259	if [ -z "${CHOST}" ]	# regen-mage-tree
1260		if [ "$1" == "only-regen-tree" -a -n "$2" ]
1261	then	then
1262	die "no CHOST variable found in /etc/mage.rc"	# set correct SMAGENAME
1263		SMAGENAME="$2"
1264		MD5DIR="$(dirname ${SMAGENAME})/md5"
1265		source ${SMAGENAME} || die "regen: smage2 not found"
1266
1267		regen_mage_tree
1268
1269		# build several targets
1270		if [[ -n ${MAGE_TARGETS} ]]
1271		then
1272		for target in ${MAGE_TARGETS}
1273		do
1274		# build md5sum for existing packages
1275		generate_package_md5sum \
1276		--pcat "${PCATEGORIE}" \
1277		--pname "${PNAME}" \
1278		--pver "${PVER}" \
1279		--pbuild "${PBUILD}" \
1280		--parch "${ARCH}" \
1281		--target "${target}"
1282		done
1283
1284		# build several subpackages
1285		elif [[ -n ${SPLIT_PACKAGES} ]]
1286		then
1287		split_save_variables
1288		for subpackage in ${SPLIT_PACKAGES}
1289		do
1290		# get the right variables for the split
1291		export PNAME="${subpackage}"
1292		split_info_${subpackage}
1293		# build md5sum for existing packages
1294		generate_package_md5sum \
1295		--pcat "${PCATEGORIE}" \
1296		--pname "${PNAME}" \
1297		--pver "${PVER}" \
1298		--pbuild "${PBUILD}" \
1299		--parch "${ARCH}"
1300		# restore smage environment
1301		split_restore_variables
1302		done
1303		# unset all saved smage variables
1304		split_unset_variables
1305
1306		else
1307		# build md5sum for existing packages
1308		generate_package_md5sum \
1309		--pcat "${PCATEGORIE}" \
1310		--pname "${PNAME}" \
1311		--pver "${PVER}" \
1312		--pbuild "${PBUILD}" \
1313		--parch "${ARCH}"
1314		fi
1315
1316		exit 0
1317	fi	fi
1318
1319	if [ -z "${CFLAGS}" ]	if [ "$1" == "--create-src-tarball" -a -n "$2" ]
1320	then	then
1321	die "no CFLAGS variable found in /etc/mage.rc"	# set correct SMAGENAME
1322		SMAGENAME="$2"
1323		MD5DIR="$(dirname ${SMAGENAME})/md5"
1324
1325		echo -e "${COLGREEN}create-src-tarball called for ${COLBLUE}${SMAGENAME}${COLGREEN} ...${COLDEFAULT}"
1326
1327		source ${SMAGENAME} || die "regen: smage2 not found"
1328
1329		if [[ -d ${SOURCEDIR}/${PNAME} ]]
1330		then
1331		echo -e "${COLGREEN}Deleting old sourcefiles ${COLBLUE}${SOURCEDIR}/${PNAME}${COLGREEN} ...${COLDEFAULT}"
1332		rm -rf ${SOURCEDIR}/${PKGNAME}
1333		fi
1334
1335		download_sources
1336		source_pkg_build ${SMAGENAME}
1337		exit 0
1338	fi	fi
1339
1340	if [ -z "${CXXFLAGS}" ]	if [ "$1" == "--src-tarball" -a -n "$2" ] || [ "$1" == "-st" -a -n "$2" ]
1341	then	then
1342	die "no CXXFLAGS variable found in /etc/mage.rc"	SRCPKGTARBALL="${2}"
1343		USE_SRC_PKG_TARBALL=true
1344
1345		# abort if given file is not a source pkg
1346		[[ ${SRCPKGTARBALL##*.} != ${SRCPKGSUFFIX} ]] && die "${SRCPKGTARBALL} is not a valid src-pkg file."
1347
1348		# set correct SMAGENAME; use the one that the src_pkg provide
1349		# /path/to/SOURCEDIR/PNAME/SMAGENAME
1350		SMAGENAME="${SOURCEDIR}/$(basename ${SRCPKGTARBALL%-*-*})/$(basename ${SRCPKGTARBALL} .${SRCPKGSUFFIX}).${SMAGESUFFIX}"
1351
1352		echo -e "${COLGREEN}Using src-tarball ${COLBLUE}${SRCPKGTARBALL}${COLGREEN} ...${COLDEFAULT}"
1353
1354		[[ ! -d ${SOURCEDIR} ]] && install -d ${SOURCEDIR}
1355
1356		# unpack srctarball
1357		[[ ! -f ${SRCPKGTARBALL} ]] && die "Error: ${SRCPKGTARBALL} does not exist. Aborting."
1358
1359		tar xvjf ${SRCPKGTARBALL} -C ${SOURCEDIR} || die  "Error unpackung src-tarball ${SRCPKGTARBALL}"
1360
1361		[[ ! -f ${SMAGENAME} ]] && die "Included smage2 file in src-tarball not found: ${SMAGENAME}"
1362	fi	fi
1363
1364
1365		[ ! -e ${MLIBDIR}/pkgbuild_dir.sh ] && die "Error: ${MLIBDIR}/pkgbuild_dir.sh not found. Aborting."
1366		[ -z "$(basename ${SMAGENAME} | grep .${SMAGESUFFIX})" ] &&
1367		die "File '$(basename ${SMAGENAME})' is not a sMage v${SMAGEVERSION} file. Aborting."
1368		[ -z "${SOURCEDIR}" ] && die "\$SOURCEDIR not found. Please setup your ${MAGERC} correctly."
1369		[ -z "${SMAGESCRIPTSDIR}" ] && die "\$SMAGESCRIPTSDIR not found. Please setup your ${MAGERC} correctly."
1370		[ -z "${SMAGE2RSYNC}" ] && die "\$SMAGE2RSYNC not found. Please setup your ${MAGERC} correctly."
1371		[ -z "${BINDIR}" ] && die "no BINDIR variable found in ${MAGERC}"
1372		[ -z "${CHOST}" ] && die "no CHOST variable found in ${MAGERC}"
1373		[ -z "${CFLAGS}" ] && die "no CFLAGS variable found in ${MAGERC}"
1374		[ -z "${CXXFLAGS}" ] && die "no CXXFLAGS variable found in ${MAGERC}"
1375
1376	source ${SMAGENAME} || die "source failed"	source ${SMAGENAME} || die "source failed"
1377	PKGNAME="${PNAME}-${PVER}-${CHOST%%-*}-${PBUILD}"	PKGNAME="${PNAME}-${PVER}-${ARCH}-${PBUILD}"
1378		MD5DIR="$(dirname ${SMAGENAME})/md5"
1379		SMAGE_LOG_CMD="tee -a /var/log/smage/${PKGNAME}.log"
1380
1381	xtitle "Compiling ${PKGNAME}"	xtitle "Compiling ${PKGNAME}"
1382	#fixes some issues with these functions	echo -e "${COLGREEN}Compiling ${PKGNAME}${COLDEFAULT}"
1383
1384		# auto regen mage tree if requested
1385		regen_mage_tree
1386
1387		if [[ ${CREATE_SRC_PKG_TARBALL} = true ]]
1388		then
1389		if [[ -d ${SOURCEDIR}/${PNAME} ]]
1390		then
1391		echo -e "${COLBLUE}===${COLGREEN} deleting old sourcefiles ${COLBLUE}${SOURCEDIR}/${PNAME}${COLGREEN} ...${COLDEFAULT}"
1392		rm -rf ${SOURCEDIR}/${PNAME}
1393		fi
1394		fi
1395
1396		# download sources
1397		[[ ${USE_SRC_PKG_TARBALL} != true ]] && download_sources
1398
1399		# fixes some issues with these functions
1400	export -f src_prepare || die "src_prepare export failed"	export -f src_prepare || die "src_prepare export failed"
1401	export -f src_compile || die "src_compile export failed"	export -f src_compile || die "src_compile export failed"
1402	export -f src_install || die "src_install export failed"	export -f src_install || die "src_install export failed"
1403
1404	#fixes some compile issues	# fixes some compile issues
1405	export CHOST="${CHOST}" || die "CHOST export failed"	export CHOST="${CHOST}" || die "CHOST export failed"
1406	export CFLAGS="${CFLAGS}" || die "CFLAGS export failed"	export CFLAGS="${CFLAGS}" || die "CFLAGS export failed"
1407	export CXXFLAGS="${CFLAGS}" || die "CXXFLAGS export failed"	export CXXFLAGS="${CFLAGS}" || die "CXXFLAGS export failed"
#	Line 344  export BINDIR="${BINDIR}" || die "BINDIR	Line 1409  export BINDIR="${BINDIR}" || die "BINDIR
1409	export MAKEOPTS="${MAKEOPTS}" || die "MAKEOPTS export failed"	export MAKEOPTS="${MAKEOPTS}" || die "MAKEOPTS export failed"
1410
1411
1412	#setup distcc	# setup distcc
1413	#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
1414	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
1415
1416		# setup ccache
1417		[[ ${SMAGE_USE_CCACHE} = true ]] && setup_ccache_environment
1418
1419	# small sleep to show our settings	# small sleep to show our settings
1420	sleep 1	sleep 1
1421
1422	#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
1423	if [ -d ${BUILDDIR} ]	if [ -d ${BUILDDIR} ]
1424	then	then
1425	rm -rf ${BUILDDIR}/* || die "couldn't cleanup \$BUILDDIR."	rm -rf ${BUILDDIR}/* || die "couldn't cleanup \$BUILDDIR."
1426	fi	fi
1427	install -d ${BUILDDIR} || die "couldn't create \$BUILDDIR."	install -d ${BUILDDIR} || die "couldn't create \$BUILDDIR."
1428
1429	#cleans up srcdir if a previously unpacked one exists	# cleans up srcdir if a previously unpacked one exists
1430	if [ -d ${SRCDIR} ]	if [ -d ${SRCDIR} ]
1431	then	then
1432	rm -rf ${SRCDIR}	rm -rf ${SRCDIR}
1433	fi	fi
1434
1435	#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
1436	if [ -d ${BINDIR} ]	if [ -d ${BINDIR} ]
1437	then	then
1438	rm -rf ${BINDIR}	rm -rf ${BINDIR}
1439	fi	fi
1440	install -d ${BINDIR} || die "couldn't create \$BINDIR."	install -d ${BINDIR} || die "couldn't create \$BINDIR."
1441
1442	#cleans up package temp dir if a previous build exists	# cleans up package temp dir if a previous build exists
1443	if [ -d ${BUILDDIR}/${PKGNAME} ]	if [ -d ${BUILDDIR}/${PKGNAME} ]
1444	then	then
1445	rm -rf ${BUILDDIR}/${PKGNAME}	rm -rf ${BUILDDIR}/${PKGNAME}
1446	fi	fi
1447
1448	#cleans up timestamp if one exists	# cleans up timestamp if one exists
1449	if [ -f /var/tmp/timestamp ]	if [ -f /var/tmp/timestamp ]
1450	then	then
1451	mage rmstamp	mage rmstamp
1452	fi	fi
1453
1454	src_prepare || die "src_prepare failed"	# setup build loggins
1455	src_compile || die "src_compile failed"	[[ ! -d /var/log/smage ]] && install -d /var/log/smage
1456	src_install || die "src_install failed"	echo -e "### Build started on $(date) ###\n" > /var/log/smage/${PKGNAME}.log
1457
1458		src_prepare | ${SMAGE_LOG_CMD}
1459		die_pipestatus 0 "src_prepare failed"
1460		step_by_step $_
1461
1462		src_compile | ${SMAGE_LOG_CMD}
1463		die_pipestatus 0 "src_compile failed"
1464		step_by_step $_
1465
1466		# build several subpackages
1467	#compressing doc, info & man files	if [[ -n ${SPLIT_PACKAGES} ]]
	echo -e "Compressing man-pages ..."
	if [ -d ${BUILDDIR}/builded/usr/share/man ]
1468	then	then
1469	${MLIBDIR}/compressdoc -g -9 ${BUILDDIR}/builded/usr/share/man	# save bindir & pname
1470		split_save_variables
1471		export SAVED_BINDIR="${BINDIR}"
1472		for subpackage in ${SPLIT_PACKAGES}
1473		do
1474		if typeset -f src_install_${subpackage} > /dev/null
1475		then
1476		# export subpackage bindir
1477		export BINDIR="${SAVED_BINDIR}_${subpackage}"
1478		# export PNAME, several internal function and include
1479		# rely on this variable
1480		export PNAME="${subpackage}"
1481
1482		echo
1483		echo -en "${COLBLUE}*** ${COLDEFAULT}"
1484		echo -en "  Running ${COLGREEN}split src_install()${COLDEFAULT}"
1485		echo -en " for subpkg: ${COLBLUE}${PNAME}${COLDEFAULT}"
1486		echo -e " - basepkg: ${COLBLUE}${SPLIT_PACKAGE_BASE}${COLDEFAULT} ..."
1487
1488		src_install_${subpackage} | ${SMAGE_LOG_CMD}
1489		die_pipestatus 0 "src_install_${subpackage} failed"
1490		step_by_step $_
1491		fi
1492		done
1493		# restore bindir & pname
1494		split_restore_variables
1495		# unset all saved smage variables
1496		split_unset_variables
1497		else
1498		src_install | ${SMAGE_LOG_CMD}
1499		die_pipestatus 0 "src_install failed"
1500		step_by_step $_
1501	fi	fi
1502
1503	echo -e "Compressing info-pages ..."	# compressing doc, info & man files
1504	if [ -d ${BUILDDIR}/builded/usr/share/info ]	if [[ -n ${SPLIT_PACKAGES} ]]
1505	then	then
1506	${MLIBDIR}/compressdoc -g -9 ${BUILDDIR}/builded/usr/share/info	for subpackage in ${SPLIT_PACKAGES}
1507		do
1508		mcompressdocs ${BINDIR}_${subpackage}
1509		done
1510		else
1511		mcompressdocs ${BINDIR}
1512	fi	fi
1513
1514	#the new buildpkg command
1515		# stripping all bins and libs
1516		case ${NOSTRIP} in
1517		true|TRUE|yes|y)
1518		echo -e "NOSTRIP=true detected; Package will not be stripped ..."
1519		;;
1520		*)
1521		if [[ -n ${SPLIT_PACKAGES} ]]
1522		then
1523		for subpackage in ${SPLIT_PACKAGES}
1524		do
1525		echo -e "${COLBLUE}===${COLGREEN} stripping binaries for '${subpackage}' ...${COLDEFAULT}"
1526		mstripbins ${BINDIR}_${subpackage}
1527		echo -e "${COLBLUE}===${COLGREEN} stripping libraries for '${subpackage}' ...${COLDEFAULT}"
1528		mstriplibs ${BINDIR}_${subpackage}
1529		done
1530		else
1531		echo -e "${COLBLUE}===${COLGREEN} stripping binaries ...${COLDEFAULT}"
1532		mstripbins ${BINDIR}
1533		echo -e "${COLBLUE}===${COLGREEN} stripping libraries ...${COLDEFAULT}"
1534		mstriplibs ${BINDIR}
1535		fi
1536		;;
1537		esac
1538
1539		# the new buildpkg command
1540	case ${NOPKGBUILD} in	case ${NOPKGBUILD} in
1541	true|TRUE|yes|y)	true|TRUE|yes|y)
1542	echo -e "NOPGKBUILD=true detected; Package will not be build ..."	echo -e "NOPGKBUILD=true detected; Package will not be build ..."
1543	;;	;;
1544	*)	*)
1545	${MLIBDIR}/pkgbuild_dir.sh ${PKGNAME} ${BINDIR} || die "package-build failed"	# build several targets
1546	echo -e "\nPackage ${PKGNAME} successfully builded.\n"	if [[ -n ${MAGE_TARGETS} ]]
1547		then
1548		for target in ${MAGE_TARGETS}
1549		do
1550		# check if an special target_pkgbuild exists
1551		if typeset -f ${target}_pkgbuild > /dev/null
1552		then
1553		# run it
1554		${target}_pkgbuild
1555		fi
1556		# now create the target package
1557		${MLIBDIR}/pkgbuild_dir.sh \
1558		"${PNAME}-${target}-${PVER}-${ARCH}-${PBUILD}" \
1559		${BINDIR} || die "target: ${target} package-build failed"
1560
1561		# build pkg-md5-sum if requested
1562		generate_package_md5sum \
1563		--pcat "${PCATEGORIE}" \
1564		--pname "${PNAME}" \
1565		--pver "${PVER}" \
1566		--pbuild "${PBUILD}" \
1567		--parch "${ARCH}" \
1568		--target "${target}"
1569
1570		echo -e "${COLGREEN}\nPackage ${PNAME}-${target}-${PVER}-${ARCH}-${PBUILD} successfully builded.\n${COLDEFAULT}"
1571		done
1572
1573		# build several subpackages
1574		elif [[ -n ${SPLIT_PACKAGES} ]]
1575		then
1576		split_save_variables
1577		for subpackage in ${SPLIT_PACKAGES}
1578		do
1579		# get the right variables for the split
1580		export PNAME="${subpackage}"
1581		split_info_${PNAME}
1582
1583		# jump to next one if NOPKGBUILD is set in split_info
1584		case ${NOPKGBUILD} in
1585		true|TRUE|yes|y) continue ;;
1586		esac
1587
1588		# check if an special subpackage_pkgbuild exists
1589		if typeset -f ${PNAME}_pkgbuild > /dev/null
1590		then
1591		# run it
1592		${PNAME}_pkgbuild
1593		fi
1594		# now create the target package
1595		${MLIBDIR}/pkgbuild_dir.sh \
1596		"${PNAME}-${PVER}-${ARCH}-${PBUILD}" \
1597		"${BINDIR}_${PNAME}" || die "split_package: ${PNAME} package-build failed"
1598
1599		# build pkg-md5-sum if requested
1600		generate_package_md5sum \
1601		--pcat "${PCATEGORIE}" \
1602		--pname "${PNAME}" \
1603		--pver "${PVER}" \
1604		--pbuild "${PBUILD}" \
1605		--parch "${ARCH}"
1606
1607		echo -e "${COLGREEN}\nPackage ${PNAME}-${PVER}-${ARCH}-${PBUILD} successfully builded.\n${COLDEFAULT}"
1608
1609		# restore smage environment
1610		split_restore_variables
1611		done
1612		# unset all saved smage variables
1613		split_unset_variables
1614
1615		else
1616		${MLIBDIR}/pkgbuild_dir.sh ${PKGNAME} ${BINDIR} || die "package-build failed"
1617
1618		# build pkg-md5-sum if requested
1619		generate_package_md5sum \
1620		--pcat "${PCATEGORIE}" \
1621		--pname "${PNAME}" \
1622		--pver "${PVER}" \
1623		--pbuild "${PBUILD}" \
1624		--parch "${ARCH}"
1625
1626		echo -e "${COLGREEN}\nPackage ${PKGNAME} successfully builded.\n${COLDEFAULT}"
1627		fi
1628
1629		# build src-pkg-tarball if requested
1630		[[ ${CREATE_SRC_PKG_TARBALL} = true ]] && source_pkg_build ${SMAGENAME}
1631	;;	;;
1632	esac	esac
1633
1634	#for sure	if [[ ${SMAGE_BUILD_LOGGING} != false ]]
1635		then
1636		bzip2 -9f /var/log/smage/${PKGNAME}.log
1637		else
1638		[[ -f /var/log/smage/${PKGNAME}.log ]] && rm /var/log/smage/${PKGNAME}.log
1639		fi
1640
1641		# for sure
1642	unset NOPKGBUILD	unset NOPKGBUILD
1643		unset NOSTRIP
1644
1645	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.33   changed lines   Added in v.1207