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