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