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

Parent Directory | Revision Log | Patch

	revision 43 by niro, Mon Jan 10 01:59:03 2005 UTC	revision 1581 by niro, Wed Dec 28 12:01:03 2011 UTC
#	Line 1	Line 1
1	#!/bin/bash	#!/bin/bash
2		# $Id$
3
4	# compiles/installs .smage2 source install scripts	# compiles/installs .smage2 source install scripts
5	# needs pkgbuild_dir (mage)	# needs pkgbuild_dir (mage)
6
7	# SMAGE2	# TODO: record dynlib, gz | xz database
	# version: 0.3.6-r11
8
9	#01.10.2004
10	# added ccache support	# set default user mage.rc
11	# added distcc support	: ${MAGERC="/etc/mage.rc"}
12
13	## setup ##	## setup ##
	SMAGEVERSION=0.3.6-r11
	PKGSUFFIX="mpk"
14	SMAGENAME="$1"	SMAGENAME="$1"
15	SMAGESUFFIX="smage2"	SMAGEVERSION="$( < ${MLIBDIR}/version)"
16	#SOURCEDIR="/bootstrap/sources"
17	#SMAGESCRIPTSDIR="/bootstrap/smage2-install-scripts"	# export default C locale
18	#SMAGE2RSYNC="rsync://192.168.0.2/smage2-scripts"	export LC_ALL=C
19	MLIBDIR=/usr/lib/mage
20		source /etc/mage.rc.global
21		source ${MAGERC}
22		source ${MLIBDIR}/mage4.functions.sh
23
24		# set PKGDIR and BUILDDIR and BINDIR to MROOT
25		if [[ -n ${MROOT} ]]
26		then
27		export PKGDIR=${MROOT}/${PKGDIR}
28		export BUILDDIR=${MROOT}/${BUILDDIR}
29		export BINDIR=${MROOT}/${BINDIR}
30		fi
31
32	source /etc/mage.rc	# sources the smage file and uses state from distribution file if exist
33		# may helpful for repository support later on
34		smagesource()
35		{
36		local file="$1"
37		local mystate
38		local mycodename
39
40		source ${file}
41
42		[[ -n ${STATE} ]] && mystate="${STATE}"
43
44		# do not overide if local state was broken or disabled!
45		case ${STATE} in
46		broken) return ;;
47		disabled) return ;;
48		esac
49
50		if [ -f ${SMAGESCRIPTSDIR}/distribution ]
51		then
52		source ${SMAGESCRIPTSDIR}/distribution
53		[[ -n ${STATE} ]] && mystate="${STATE}"
54		fi
55		# now switch state and export it
56		STATE="${mystate}"
57		}
58
59	showversion() {	showversion()
60		{
61	echo -en "Magellan Source Install v${SMAGEVERSION} "	echo -en "Magellan Source Install v${SMAGEVERSION} "
62	echo -e  "-- Niels Rogalla (niro@magellan-linux.de)"	echo -e  "-- Niels Rogalla (niro@magellan-linux.de)"
63	}	}
64
65	die() {	die()
66		{
67	xtitleclean	xtitleclean
68		echo -e ${COLRED}"Exited ${BASH_SOURCE} at line no ${BASH_LINENO}."${COLDEFAULT}
69	echo "SMAGE failed: $@"	echo "SMAGE failed: $@"
70	exit 1	exit 1
71	}	}
72
73	xtitle() {	die_pipestatus()
74	if [ ${TERM} == "xterm" ]	{
75		# the status change if we do any parameter declarations!!
76		# dont do this anymore, keep this in mind!
77		#
78		# local pos="$1"
79		# local comment="$2"
80		#
81		# [ ${PIPESTATUS[${pos}]} -ne 0 ] && die "${comment}"
82		#
83		[ ${PIPESTATUS[$1]} -ne 0 ] && die "$2"
84		}
85
86		xtitle()
87		{
88		if [[ ${TERM} = xterm ]]
89	then	then
90	echo -ne "\033]0;[sMage: $@]\007"	echo -ne "\033]0;[sMage: $@]\007"
91	fi	fi
92	return 0	return 0
93	}	}
94
95	xtitleclean() {	xtitleclean()
96	if [ ${TERM} == "xterm" ]	{
97		if [[ ${TERM} = xterm ]]
98	then	then
99	echo -ne "\033]0;\007"	echo -ne "\033]0;\007"
100	fi	fi
101	return 0	return 0
102	}	}
103
104	syncsmage2() {	syncsmage2()
105		{
106	xtitle "Updating smage2-script tree ..."	xtitle "Updating smage2-script tree ..."
107	local i	local i
108	for i in ${SMAGE2RSYNC}	for i in ${SMAGE2RSYNC}
109	do	do
110	rsync \	rsync ${RSYNC_FETCH_OPTIONS} ${i} ${SMAGESCRIPTSDIR}
111	--recursive \	if [[ $? = 0 ]]
	--links \
	--perms \
	--times \
	--devices \
	--timeout=600 \
	--verbose \
	--compress \
	--progress \
	--stats \
	--delete \
	--delete-after \
	${i} ${SMAGESCRIPTSDIR}
	if [ "$?" == "0" ]
112	then	then
113	break	break
114	else	else
115	continue	continue
116	fi	fi
117	done	done
118
119	#clean up backup files (foo~)	# clean up backup files (foo~)
120	find ${SMAGESCRIPTSDIR} -name *~ -exec rm '{}' ';'	find ${SMAGESCRIPTSDIR} -name *~ -exec rm '{}' ';'
121
122	xtitleclean	xtitleclean
123	}	}
124
125	# dummy function, used if that not exist in smage file	# $1 filename
126	src_prepare() {	get_db_md5_sum()
127		{
128		local DB_FILE
129		local MD5_FILE
130		local i
131
132		DB_ENTRY="$(basename $1)"
133		MD5_FILE="${MD5DIR}/$(basename ${SMAGENAME} ${SMAGESUFFIX})"
134
135		i="$(cat ${MD5_FILE}| grep ${DB_ENTRY} | cut -d' ' -f1)"
136
137		echo "${i}"
138		}
139
140		download_sources()
141		{
142		[ -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
825		# bindir too
826		export SAVED_BINDIR="${BINDIR}"
827
828		# export the SPLIT_PACKAGE_BASE
829		export SPLIT_PACKAGE_BASE="${SAVED_PNAME}"
830
831		# functions
832		if [[ ! -z $(typeset -f preinstall) ]]
833		then
834		# rename the old one
835		local saved_preinstall
836		saved_preinstall=SAVED_$(typeset -f preinstall)
837		eval "${saved_preinstall}"
838		export -f SAVED_preinstall
839		fi
840
841		if [[ ! -z $(typeset -f postinstall) ]]
842		then
843		# rename the old one
844		local saved_postinstall
845		saved_postinstall=SAVED_$(typeset -f postinstall)
846		eval "${saved_postinstall}"
847		export -f SAVED_postinstall
848		fi
849
850		if [[ ! -z $(typeset -f preremove) ]]
851		then
852		# rename the old one
853		local saved_preremove
854		saved_preremove=SAVED_$(typeset -f preremove)
855		eval "${saved_preremove}"
856		export -f SAVED_preremove
857		fi
858
859		if [[ ! -z $(typeset -f postremove) ]]
860		then
861		# rename the old one
862		local saved_postremove
863		saved_postremove=SAVED_$(typeset -f postremove)
864		eval "${saved_postremove}"
865		export -f SAVED_postremove
866		fi
867		}
868
869		split_restore_variables()
870		{
871		export PNAME="${SAVED_PNAME}"
872		export PVER="${SAVED_PVER}"
873		export PBUILD="${SAVED_PBUILD}"
874		export PCATEGORIE="${SAVED_PCATEGORIE}"
875		export DESCRIPTION="${SAVED_DESCRIPTION}"
876		export HOMEPAGE="${SAVED_HOMEPAGE}"
877		export SPECIAL_VARS="${SAVED_SPECIAL_VARS}"
878		export STATE="${SAVED_STATE}"
879		export PKGTYPE="${SAVED_PKGTYPE}"
880		export INHERITS="${SAVED_INHERITS}"
881		export DEPEND="${SAVED_DEPEND}"
882		export SDEPEND="${SAVED_SDEPEND}"
883		export PROVIDE="${SAVED_PROVIDE}"
884		export NOPKGBUILD="${SAVED_NOPKGBUILD}"
885
886		# bindir too
887		export BINDIR="${SAVED_BINDIR}"
888
889		# functions
890		if [[ ! -z $(typeset -f SAVED_preinstall) ]]
891		then
892		# rename the old one
893		local saved_preinstall
894		saved_preinstall=$(typeset -f SAVED_preinstall)
895		eval "${saved_preinstall/SAVED_/}"
896		export -f preinstall
897		fi
898
899		if [[ ! -z $(typeset -f SAVED_postinstall) ]]
900		then
901		# rename the old one
902		local saved_postinstall
903		saved_postinstall=$(typeset -f SAVED_postinstall)
904		eval "${saved_postinstall/SAVED_/}"
905		export -f postinstall
906		fi
907
908		if [[ ! -z $(typeset -f SAVED_preremove) ]]
909		then
910		# rename the old one
911		local saved_preremove
912		saved_preremove=$(typeset -f SAVED_preremove)
913		eval "${saved_preremove/SAVED_/}"
914		export -f preremove
915		fi
916
917		if [[ ! -z $(typeset -f SAVED_postremove) ]]
918		then
919		# rename the old one
920		local saved_postremove
921		saved_postremove=$(typeset -f SAVED_postremove)
922		eval "${saved_postremove/SAVED_/}"
923		export -f postremove
924	fi	fi
925	}	}
926
927		split_unset_variables()
928		{
929		# unset saved vars; not needed anymore
930		unset SAVED_PNAME
931		unset SAVED_PVER
932		unset SAVED_PBUILD
933		unset SAVED_PCATEGORIE
934		unset SAVED_DESCRIPTION
935		unset SAVED_HOMEPAGE
936		unset SAVED_SPECIAL_VARS
937		unset SAVED_STATE
938		unset SAVED_PKGTYPE
939		unset SAVED_INHERITS
940		unset SAVED_DEPEND
941		unset SAVED_SDEPEND
942		unset SAVED_PROVIDE
943		unset SAVED_BINDIR
944		unset SAVED_NOPKGBUILD
945		unset SPLIT_PACKAGE_BASE
946		unset -f SAVED_preinstall
947		unset -f SAVED_postinstall
948		unset -f SAVED_preremove
949		unset -f SAVED_postremove
950		}
951
952		split_export_inherits()
953		{
954		local subpackage="$1"
955		local func
956		local newfunc
957
958		for func in preinstall postinstall preremove postremove
959		do
960		if [[ ! -z $(typeset -f ${func}_${subpackage}) ]]
961		then
962		newfunc=$(typeset -f ${func}_${subpackage})
963		newfunc="${newfunc/_${subpackage} (/ (}"
964		eval "${newfunc}"
965		fi
966		done
967		}
968
969		split_delete_inherits()
970		{
971		local subpackage="$1"
972		local func
973
974		for func in preinstall postinstall preremove postremove
975		do
976		if [[ ! -z $(typeset -f ${func}_${subpackage}) ]]
977		then
978		unset -f ${func}
979		fi
980		done
981		}
982
983		export_inherits()
984		{
985		local include="$1"
986		shift
987
988		while [ "$1" ]
989		do
990		local functions="$1"
991
992		# sanity checks
993		[ -z "${include}" ] && die "export_inherits(): \$include not given."
994		[ -z "${functions}" ] && die "export_inherits(): \$functions not given."
995
996		eval "${functions}() { ${include}_${functions} ; }"
997
998		# debug
999		[[ ${MAGEDEBUG} = on ]] && typeset -f "${functions}"
1000
1001		shift
1002		done
1003		}
1004
1005		generate_package_md5sum()
1006		{
1007		local dest
1008		local pcat
1009		local pname
1010		local pver
1011		local pbuild
1012		local parch
1013		local target
1014		local pkgname
1015
1016		# very basic getops
1017		for i in $*
1018		do
1019		case $1 in
1020		--pcat|-c) shift; pcat="$1" ;;
1021		--pname|-n) shift; pname="$1" ;;
1022		--pver|-v) shift; pver="$1" ;;
1023		--pbuild|-b) shift; pbuild="$1" ;;
1024		--parch|a) shift; parch="$1" ;;
1025		--target|t) shift; target="$1" ;;
1026		esac
1027		shift
1028		done
1029
1030		# sanity checks; abort if not given
1031		[ -z "${pcat}" ] && die "generate_package_md5sum() \$pcat not given."
1032		[ -z "${pname}" ] && die "generate_package_md5sum() \$pname not given."
1033		[ -z "${pver}" ] && die "generate_package_md5sum() \$pver not given."
1034		[ -z "${pbuild}" ] && die "generate_package_md5sum() \$pbuild not given."
1035		[ -z "${parch}" ] && die "generate_package_md5sum() \$parch not given."
1036
1037		# check needed global vars
1038		[ -z "${PKGDIR}" ] && die "generate_package_md5sum() \$PKGDIR not set."
1039		[ -z "${PKGSUFFIX}" ] && die "generate_package_md5sum() \$PKGSUFFIX not set."
1040
1041		# fix target as it may be empty !
1042		[ -n "${target}" ] && target="-${target}"
1043
1044
1045		# build pkgname
1046		pkgname="${pname}${target}-${pver}-${parch}-${pbuild}"
1047
1048		# build pkg-md5-sum only if requested
1049		if [[ ${REGEN_MAGE_TREE} = true ]]
1050		then
1051		echo -ne "${COLBLUE}===${COLGREEN} generating md5's for ${pkgname}.${PKGSUFFIX} ... ${COLDEFAULT}"
1052
1053		# abort if not exist
1054		if [ ! -f ${PKGDIR}/${pkgname}.${PKGSUFFIX} ]
1055		then
1056		echo -e "${COLRED}! exists${COLDEFAULT}"
1057		return 0
1058		fi
1059
1060		# if MAGE_TREE_DEST not set use BUILDDIR
1061		: ${MAGE_TREE_DEST=${BUILDDIR}/mage-tree}
1062
1063		# setup md5 dir
1064		dest="${MAGE_TREE_DEST}/${pcat}/${pname}${target}/md5"
1065		install -d ${dest}
1066
1067		# gen md5sum
1068		( cd ${PKGDIR}; md5sum "${pkgname}.${PKGSUFFIX}" ) \
1069		> ${dest}/${pkgname}.md5
1070		echo -e "${COLGREEN}done${COLDEFAULT}"
1071		fi
1072		}
1073
1074		source_pkg_build()
1075		{
1076		if [[ ${PKGTYPE} = virtual ]]
1077		then
1078		echo "Virtual package detected; src-pkg-tarball not necessary ..."
1079		return 0
1080		fi
1081
1082		if [[ ! -d ${SOURCEDIR}/${PNAME} ]]
1083		then
1084		echo "No SRC_URI defined; src-pkg-tarball not necessary ..."
1085		return 0
1086		fi
1087
1088		[ -z "${SRCPKGDIR}" ] && die "\$SRCPKGDIR not found. Please setup your ${MAGERC} correctly."
1089
1090		echo -e "${COLGREEN}Creating source package tarball ... ${COLDEFAULT}"
1091
1092		# include the smage2 file
1093		cp ${SMAGENAME} ${SOURCEDIR}/${PNAME}
1094
1095		( cd ${SOURCEDIR}; tar cvjf ${BUILDDIR}/${PNAME}-${PVER}-${PBUILD}.tar.bz2 ${PNAME}; )
1096		[[ ! -d ${SRCPKGDIR} ]] && install -d ${SRCPKGDIR}
1097		mv ${BUILDDIR}/${PNAME}-${PVER}-${PBUILD}.tar.bz2 ${SRCPKGDIR}/${PNAME}-${PVER}-${PBUILD}.${SRCPKGSUFFIX}
1098
1099		echo -e "${COLGREEN}Source package ${COLBLUE}${PNAME}-${PVER}-${PBUILD}.${SRCPKGSUFFIX} ${COLGREEN}successfully builded.${COLDEFAULT}"
1100		}
1101
1102		step_by_step()
1103		{
1104		if [[ ${STEP_BY_STEP} = true ]]
1105		then
1106		echo -e "${COLRED}Step-by-step enabled! Paused after $1.${COLDEFAULT}"
1107		echo "Press [enter] to continue"
1108		read
1109		fi
1110		}
1111
1112
1113		# print out our version
1114		showversion
1115		echo
1116
1117	if [ -z "$1" ]	if [ -z "$1" ]
1118	then	then
	showversion
	echo
1119	echo "No .smage2 file given. Exiting."	echo "No .smage2 file given. Exiting."
1120	echo	echo
1121	exit 1	exit 1
1122	fi	fi
1123
1124	#updating smage2-scripts	# updating smage2-scripts
1125	if [ "$1" == "update" ]	if [[ $1 = update ]]
1126	then	then
1127	showversion	if [ ! -d ${SOURCEDIR} ]
	if [ ! -d ${SMAGESCRIPTSDIR} ]
1128	then	then
1129	install -d ${SMAGESCRIPTSDIR}	install -d ${SOURCEDIR}
1130	fi	fi
1131	syncsmage2	syncsmage2
1132	exit 0	exit 0
1133	fi	fi
1134
1135		# creates md5sums for smages to given dir
1136	if [ ! -e ${MLIBDIR}/pkgbuild_dir.sh ]	if [[ $1 = calcmd5 ]]
1137	then	then
1138	die "Error: ${MLIBDIR}/pkgbuild_dir.sh not found. Aborting."	if [ $# -ge 2 ]
1139	fi	then
1140		SMAGENAME="$2"
1141		MD5DIR="$3"
1142		[[ -z ${MD5DIR} ]] && MD5DIR="$(dirname ${SMAGENAME})/md5"
1143
1144	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
1145
1146	if [ -z "${SOURCEDIR}" ]	# overridable sourcedir; must be declared after source of the smage2
1147	then	CALC_SOURCEDIR="${CALC_SOURCEDIR:="${SOURCEDIR}/${PNAME}"}"
	die "\$SOURCEDIR not found. Please setup your mage.rc correctly."
	fi
1148
1149	if [ -z "${SMAGESCRIPTSDIR}" ]	[ -z "${SRC_URI}" ] && die "Nothing declared to calculate."
	then
	die "\$SMAGESCRIPTSDIR not found. Please setup your mage.rc correctly."
	fi
1150
1151	if [ -z "${SMAGE2RSYNC}" ]	# end of array
1152	then	EOA=${#SRC_URI[*]}
1153	echo "\$SMAGE2RSYNC not found. Please setup your mage.rc correctly."
1154	exit 1	[ ! -d ${MD5DIR} ] && install -d ${MD5DIR}
1155
1156		# clear md5sum file
1157		MY_MD5_FILE="${MD5DIR}/$(basename ${SMAGENAME} .${SMAGESUFFIX}).md5"
1158		echo -n > ${MY_MD5_FILE}
1159
1160		for ((i=0; i < EOA; i++))
1161		do
1162		# url to file
1163		my_SRC_URI="$(echo ${SRC_URI[${i}]} | cut -d' ' -f1)"
1164
1165		# subdir in sources dir; the my_SRCI_URI file goes to there
1166		my_SRC_URI_DEST="$(echo ${SRC_URI[${i}]} | cut -d' ' -f2)"
1167
1168		# if my_src_uri_dest is not equal my_src_uri; than an other dir is used
1169		if [[ ${my_SRC_URI_DEST} != ${my_SRC_URI} ]]
1170		then
1171		MY_SRC_FILE="${my_SRC_URI_DEST}/$(basename ${SRC_URI[${i}]})"
1172		else
1173		MY_SRC_FILE="$(basename ${SRC_URI[${i}]})"
1174		fi
1175
1176		if [ -e "${CALC_SOURCEDIR}/${MY_SRC_FILE}" ]
1177		then
1178		echo "calculating $(basename ${MY_SRC_FILE}) ..."
1179		( cd ${CALC_SOURCEDIR}; md5sum "${MY_SRC_FILE}" ) >> ${MY_MD5_FILE}
1180		else
1181		echo "WARNING: File '$(basename ${MY_SRC_FILE}) not found in ${CALC_SOURCEDIR}."
1182		fi
1183
1184		# unset them to be shure
1185		unset my_SRC_URI
1186		unset my_SRC_URI_DEST
1187		unset my_SRC_URI_MIRROR
1188		unset my_SOURCEDIR
1189		done
1190
1191		echo
1192		echo "Calculating of md5 sums for '$(basename ${SMAGENAME} .${SMAGESUFFIX})' done."
1193		echo
1194		else
1195		echo "Usage: Calculating MD5 Sums:"
1196		echo "    $(basename $0) calcmd5 /path/to/SMAGENAME [/path/to/MD5DIR]"
1197		echo
1198		echo
1199		echo "Export the CALC_SOURCEDIR variable to override current SOURCEDIRs."
1200		echo
1201		exit 1
1202		fi
1203
1204		exit 0
1205	fi	fi
1206
1207	if [ -z "${BINDIR}" ]	# download sources
1208		if [ "$1" == "download" -a -n "$2" ]
1209	then	then
1210	die "no BINDIR variable found in /etc/mage.rc"	if [ ! -d ${SMAGESCRIPTSDIR} ]
1211		then
1212		install -d ${SMAGESCRIPTSDIR}
1213		fi
1214
1215		# get smage
1216		SMAGENAME="$2"
1217		MD5DIR="$(dirname ${SMAGENAME})/md5"
1218		smagesource ${SMAGENAME} || die "download source failed"
1219
1220		download_sources
1221		exit 0
1222	fi	fi
1223
1224	if [ -z "${CHOST}" ]	# regen-mage-tree
1225		if [ "$1" == "only-regen-tree" -a -n "$2" ]
1226	then	then
1227	die "no CHOST variable found in /etc/mage.rc"	# set correct SMAGENAME
1228		SMAGENAME="$2"
1229		MD5DIR="$(dirname ${SMAGENAME})/md5"
1230		smagesource ${SMAGENAME} || die "regen: smage2 not found"
1231
1232		regen_mage_tree
1233
1234		# build several targets
1235		if [[ -n ${MAGE_TARGETS} ]]
1236		then
1237		for target in ${MAGE_TARGETS}
1238		do
1239		# build md5sum for existing packages
1240		generate_package_md5sum \
1241		--pcat "${PCATEGORIE}" \
1242		--pname "${PNAME}" \
1243		--pver "${PVER}" \
1244		--pbuild "${PBUILD}" \
1245		--parch "${ARCH}" \
1246		--target "${target}"
1247		done
1248
1249		# build several subpackages
1250		elif [[ -n ${SPLIT_PACKAGES} ]]
1251		then
1252		split_save_variables
1253		for subpackage in ${SPLIT_PACKAGES}
1254		do
1255		# get the right variables for the split
1256		export PNAME="${subpackage}"
1257		split_info_${subpackage}
1258		# build md5sum for existing packages
1259		generate_package_md5sum \
1260		--pcat "${PCATEGORIE}" \
1261		--pname "${PNAME}" \
1262		--pver "${PVER}" \
1263		--pbuild "${PBUILD}" \
1264		--parch "${ARCH}"
1265		# restore smage environment
1266		split_restore_variables
1267		done
1268		# unset all saved smage variables
1269		split_unset_variables
1270
1271		else
1272		# build md5sum for existing packages
1273		generate_package_md5sum \
1274		--pcat "${PCATEGORIE}" \
1275		--pname "${PNAME}" \
1276		--pver "${PVER}" \
1277		--pbuild "${PBUILD}" \
1278		--parch "${ARCH}"
1279		fi
1280
1281		exit 0
1282	fi	fi
1283
1284	if [ -z "${CFLAGS}" ]	if [ "$1" == "--create-src-tarball" -a -n "$2" ]
1285	then	then
1286	die "no CFLAGS variable found in /etc/mage.rc"	# set correct SMAGENAME
1287		SMAGENAME="$2"
1288		MD5DIR="$(dirname ${SMAGENAME})/md5"
1289
1290		echo -e "${COLGREEN}create-src-tarball called for ${COLBLUE}${SMAGENAME}${COLGREEN} ...${COLDEFAULT}"
1291
1292		smagesource ${SMAGENAME} || die "regen: smage2 not found"
1293
1294		if [[ -d ${SOURCEDIR}/${PNAME} ]]
1295		then
1296		echo -e "${COLGREEN}Deleting old sourcefiles ${COLBLUE}${SOURCEDIR}/${PNAME}${COLGREEN} ...${COLDEFAULT}"
1297		rm -rf ${SOURCEDIR}/${PKGNAME}
1298		fi
1299
1300		download_sources
1301		source_pkg_build ${SMAGENAME}
1302		exit 0
1303	fi	fi
1304
1305	if [ -z "${CXXFLAGS}" ]	if [ "$1" == "--src-tarball" -a -n "$2" ] || [ "$1" == "-st" -a -n "$2" ]
1306	then	then
1307	die "no CXXFLAGS variable found in /etc/mage.rc"	SRCPKGTARBALL="${2}"
1308		USE_SRC_PKG_TARBALL=true
1309
1310		# abort if given file is not a source pkg
1311		[[ ${SRCPKGTARBALL##*.} != ${SRCPKGSUFFIX} ]] && die "${SRCPKGTARBALL} is not a valid src-pkg file."
1312
1313		# set correct SMAGENAME; use the one that the src_pkg provide
1314		# /path/to/SOURCEDIR/PNAME/SMAGENAME
1315		SMAGENAME="${SOURCEDIR}/$(basename ${SRCPKGTARBALL%-*-*})/$(basename ${SRCPKGTARBALL} .${SRCPKGSUFFIX}).${SMAGESUFFIX}"
1316
1317		echo -e "${COLGREEN}Using src-tarball ${COLBLUE}${SRCPKGTARBALL}${COLGREEN} ...${COLDEFAULT}"
1318
1319		[[ ! -d ${SOURCEDIR} ]] && install -d ${SOURCEDIR}
1320
1321		# unpack srctarball
1322		[[ ! -f ${SRCPKGTARBALL} ]] && die "Error: ${SRCPKGTARBALL} does not exist. Aborting."
1323
1324		tar xvjf ${SRCPKGTARBALL} -C ${SOURCEDIR} || die  "Error unpackung src-tarball ${SRCPKGTARBALL}"
1325
1326		[[ ! -f ${SMAGENAME} ]] && die "Included smage2 file in src-tarball not found: ${SMAGENAME}"
1327	fi	fi
1328
1329
1330	source ${SMAGENAME} || die "source failed"	[ ! -e ${MLIBDIR}/pkgbuild_dir.sh ] && die "Error: ${MLIBDIR}/pkgbuild_dir.sh not found. Aborting."
1331	PKGNAME="${PNAME}-${PVER}-${CHOST%%-*}-${PBUILD}"	[ -z "$(basename ${SMAGENAME} | grep .${SMAGESUFFIX})" ] &&
1332		die "File '$(basename ${SMAGENAME})' is not a sMage v${SMAGEVERSION} file. Aborting."
1333		[ -z "${SOURCEDIR}" ] && die "\$SOURCEDIR not found. Please setup your ${MAGERC} correctly."
1334		[ -z "${SMAGESCRIPTSDIR}" ] && die "\$SMAGESCRIPTSDIR not found. Please setup your ${MAGERC} correctly."
1335		[ -z "${SMAGE2RSYNC}" ] && die "\$SMAGE2RSYNC not found. Please setup your ${MAGERC} correctly."
1336		[ -z "${BINDIR}" ] && die "no BINDIR variable found in ${MAGERC}"
1337		[ -z "${CHOST}" ] && die "no CHOST variable found in ${MAGERC}"
1338		[ -z "${CFLAGS}" ] && die "no CFLAGS variable found in ${MAGERC}"
1339		[ -z "${CXXFLAGS}" ] && die "no CXXFLAGS variable found in ${MAGERC}"
1340
1341		smagesource ${SMAGENAME} || die "source failed"
1342		PKGNAME="${PNAME}-${PVER}-${ARCH}-${PBUILD}"
1343		MD5DIR="$(dirname ${SMAGENAME})/md5"
1344		SMAGE_LOG_CMD="tee -a /var/log/smage/${PKGNAME}.log"
1345
1346	xtitle "Compiling ${PKGNAME}"	xtitle "Compiling ${PKGNAME}"
1347	#fixes some issues with these functions	echo -e "${COLGREEN}Compiling ${PKGNAME}${COLDEFAULT}"
1348
1349		# auto regen mage tree if requested
1350		regen_mage_tree
1351
1352		if [[ ${CREATE_SRC_PKG_TARBALL} = true ]]
1353		then
1354		if [[ -d ${SOURCEDIR}/${PNAME} ]]
1355		then
1356		echo -e "${COLBLUE}===${COLGREEN} deleting old sourcefiles ${COLBLUE}${SOURCEDIR}/${PNAME}${COLGREEN} ...${COLDEFAULT}"
1357		rm -rf ${SOURCEDIR}/${PNAME}
1358		fi
1359		fi
1360
1361		# download sources
1362		[[ ${USE_SRC_PKG_TARBALL} != true ]] && download_sources
1363
1364		# fixes some issues with these functions
1365	export -f src_prepare || die "src_prepare export failed"	export -f src_prepare || die "src_prepare export failed"
1366	export -f src_compile || die "src_compile export failed"	export -f src_compile || die "src_compile export failed"
1367		export -f src_check || die "src_check export failed"
1368	export -f src_install || die "src_install export failed"	export -f src_install || die "src_install export failed"
1369
1370	#fixes some compile issues	# fixes some compile issues
1371	export CHOST="${CHOST}" || die "CHOST export failed"	export CHOST="${CHOST}" || die "CHOST export failed"
1372	export CFLAGS="${CFLAGS}" || die "CFLAGS export failed"	export CFLAGS="${CFLAGS}" || die "CFLAGS export failed"
1373	export CXXFLAGS="${CFLAGS}" || die "CXXFLAGS export failed"	export CXXFLAGS="${CFLAGS}" || die "CXXFLAGS export failed"
#	Line 344  export BINDIR="${BINDIR}" || die "BINDIR	Line 1375  export BINDIR="${BINDIR}" || die "BINDIR
1375	export MAKEOPTS="${MAKEOPTS}" || die "MAKEOPTS export failed"	export MAKEOPTS="${MAKEOPTS}" || die "MAKEOPTS export failed"
1376
1377
1378	#setup distcc	# setup distcc
1379	#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
1380	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
1381
1382	#debug	# setup ccache
1383	#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
1384
1385	#cleans up build if a previously one exists	# clean up builddir if a previously one exist
1386	if [ -d ${BUILDDIR} ]	if [ -d ${BUILDDIR} ]
1387	then	then
1388	rm -rf ${BUILDDIR}/* || die "couldn't cleanup \$BUILDDIR."	rm -rf ${BUILDDIR}/* || die "couldn't cleanup \$BUILDDIR."
1389	fi	fi
1390	install -d ${BUILDDIR} || die "couldn't create \$BUILDDIR."	install -d ${BUILDDIR} || die "couldn't create \$BUILDDIR."
1391
1392	#cleans up srcdir if a previously unpacked one exists	# clean up srcdir if a previously unpacked one exist
1393	if [ -d ${SRCDIR} ]	if [ -d ${SRCDIR} ]
1394	then	then
1395	rm -rf ${SRCDIR}	rm -rf ${SRCDIR}
1396	fi	fi
1397
1398	#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
1399	if [ -d ${BINDIR} ]	if [ -d ${BINDIR} ]
1400	then	then
1401	rm -rf ${BINDIR}	rm -rf ${BINDIR}
1402	fi	fi
1403	install -d ${BINDIR} || die "couldn't create \$BINDIR."	install -d ${BINDIR} || die "couldn't create \$BINDIR."
1404
1405	#cleans up package temp dir if a previous build exists	# clean up package temp dir if a previous build exist
1406	if [ -d ${BUILDDIR}/${PKGNAME} ]	if [ -d ${BUILDDIR}/${PKGNAME} ]
1407	then	then
1408	rm -rf ${BUILDDIR}/${PKGNAME}	rm -rf ${BUILDDIR}/${PKGNAME}
1409	fi	fi
1410
1411	#cleans up timestamp if one exists	# setup build logging
1412	if [ -f /var/tmp/timestamp ]	[[ ! -d /var/log/smage ]] && install -d /var/log/smage
1413		echo -e "### Build started on $(date) ###\n" > /var/log/smage/${PKGNAME}.log
1414
1415		src_prepare | ${SMAGE_LOG_CMD}
1416		die_pipestatus 0 "src_prepare failed"
1417		step_by_step $_
1418
1419		src_compile | ${SMAGE_LOG_CMD}
1420		die_pipestatus 0 "src_compile failed"
1421		step_by_step $_
1422
1423		# only run checks if requested
1424		if [[ ${MAGE_CHECK} != true ]]
1425	then	then
1426	mage rmstamp	echo "MAGE_CHECK not requested; src_check() will not be run!" | ${SMAGE_LOG_CMD}
1427		step_by_step src_check
1428		else
1429		src_check | ${SMAGE_LOG_CMD}
1430		die_pipestatus 0 "src_check failed"
1431		step_by_step $_
1432	fi	fi
1433
1434	src_prepare || die "src_prepare failed"	# build several subpackages
1435	src_compile || die "src_compile failed"	if [[ -n ${SPLIT_PACKAGES} ]]
1436	src_install || die "src_install failed"	then
1437		# save bindir & pname
1438		split_save_variables
1439		export SAVED_BINDIR="${BINDIR}"
1440		for subpackage in ${SPLIT_PACKAGES}
1441		do
1442		if typeset -f src_install_${subpackage} > /dev/null
1443		then
1444		# export subpackage bindir
1445		export BINDIR="${SAVED_BINDIR}_${subpackage}"
1446		# export PNAME, several internal function and include
1447		# rely on this variable
1448		export PNAME="${subpackage}"
1449
1450		echo
1451		echo -en "${COLBLUE}*** ${COLDEFAULT}"
1452		echo -en "  Running ${COLGREEN}split src_install()${COLDEFAULT}"
1453		echo -en " for subpkg: ${COLBLUE}${PNAME}${COLDEFAULT}"
1454		echo -e " - basepkg: ${COLBLUE}${SPLIT_PACKAGE_BASE}${COLDEFAULT} ..."
1455
1456		src_install_${subpackage} | ${SMAGE_LOG_CMD}
1457		die_pipestatus 0 "src_install_${subpackage} failed"
1458		step_by_step $_
1459		fi
1460		done
1461		# restore bindir & pname
1462		split_restore_variables
1463		# unset all saved smage variables
1464		split_unset_variables
1465		else
1466		src_install | ${SMAGE_LOG_CMD}
1467		die_pipestatus 0 "src_install failed"
1468		step_by_step $_
1469		fi
1470
1471		# compressing doc, info & man files
1472		if [[ -n ${SPLIT_PACKAGES} ]]
1473		then
1474		for subpackage in ${SPLIT_PACKAGES}
1475		do
1476		mcompressdocs ${BINDIR}_${subpackage}
1477		done
1478		else
1479		mcompressdocs ${BINDIR}
1480		fi
1481
1482	#compressing doc, info & man files	if [[ ${SMAGE_STRIP_LIBTOOL} = true ]]
	echo -e "Compressing man-pages ..."
	if [ -d ${BUILDDIR}/builded/usr/share/man ]
1483	then	then
1484	${MLIBDIR}/compressdoc -g -9 ${BUILDDIR}/builded/usr/share/man	if [[ -n ${SPLIT_PACKAGES} ]]
1485		then
1486		for subpackage in ${SPLIT_PACKAGES}
1487		do
1488		echo -e "${COLBLUE}===${COLGREEN} stripping libtool archives for '${subpackage}' ...${COLDEFAULT}"
1489		mstriplibtoolarchive ${BINDIR}_${subpackage}
1490		done
1491		else
1492		echo -e "${COLBLUE}===${COLGREEN} stripping libtool archives ...${COLDEFAULT}"
1493		mstriplibtoolarchive ${BINDIR}
1494		fi
1495	fi	fi
1496
1497	echo -e "Compressing info-pages ..."	if [[ ${SMAGE_PURGE} = true ]]
	if [ -d ${BUILDDIR}/builded/usr/share/info ]
1498	then	then
1499	${MLIBDIR}/compressdoc -g -9 ${BUILDDIR}/builded/usr/share/info	if [[ -n ${SPLIT_PACKAGES} ]]
1500		then
1501		for subpackage in ${SPLIT_PACKAGES}
1502		do
1503		echo -e "${COLBLUE}===${COLGREEN} purging all purge targets in '${subpackage}' ...${COLDEFAULT}"
1504		mpurgetargets ${BINDIR}_${subpackage}
1505		done
1506		else
1507		echo -e "${COLBLUE}===${COLGREEN} purging all purge targets ...${COLDEFAULT}"
1508		mpurgetargets ${BINDIR}
1509		fi
1510	fi	fi
1511
1512	#the new buildpkg command	# stripping all bins and libs
1513		case ${NOSTRIP} in
1514		true|TRUE|yes|y)
1515		echo -e "NOSTRIP=true detected; Package will not be stripped ..."
1516		;;
1517		*)
1518		if [[ -n ${SPLIT_PACKAGES} ]]
1519		then
1520		for subpackage in ${SPLIT_PACKAGES}
1521		do
1522		echo -e "${COLBLUE}===${COLGREEN} stripping binaries for '${subpackage}' ...${COLDEFAULT}"
1523		mstripbins ${BINDIR}_${subpackage}
1524		echo -e "${COLBLUE}===${COLGREEN} stripping dynamic libraries for '${subpackage}' ...${COLDEFAULT}"
1525		mstriplibs ${BINDIR}_${subpackage}
1526		echo -e "${COLBLUE}===${COLGREEN} stripping static libraries for '${subpackage}' ...${COLDEFAULT}"
1527		mstripstatic ${BINDIR}_${subpackage}
1528		done
1529		else
1530		echo -e "${COLBLUE}===${COLGREEN} stripping binaries ...${COLDEFAULT}"
1531		mstripbins ${BINDIR}
1532		echo -e "${COLBLUE}===${COLGREEN} stripping dynamic libraries ...${COLDEFAULT}"
1533		mstriplibs ${BINDIR}
1534		echo -e "${COLBLUE}===${COLGREEN} stripping static libraries ...${COLDEFAULT}"
1535		mstripstatic ${BINDIR}
1536		fi
1537		;;
1538		esac
1539
1540		# the new buildpkg command
1541	case ${NOPKGBUILD} in	case ${NOPKGBUILD} in
1542	true|TRUE|yes|y)	true|TRUE|yes|y)
1543	echo -e "NOPGKBUILD=true detected; Package will not be build ..."	echo -e "NOPGKBUILD=true detected; Package will not be build ..."
1544	;;	;;
1545	*)	*)
1546	${MLIBDIR}/pkgbuild_dir.sh ${PKGNAME} ${BINDIR} || die "package-build failed"	# build several targets
1547	echo -e "\nPackage ${PKGNAME} successfully builded.\n"	if [[ -n ${MAGE_TARGETS} ]]
1548		then
1549		for target in ${MAGE_TARGETS}
1550		do
1551		# check if a special target_pkgbuild exists
1552		if typeset -f ${target}_pkgbuild > /dev/null
1553		then
1554		# run it
1555		${target}_pkgbuild
1556		fi
1557		# now create the target package
1558		${MLIBDIR}/pkgbuild_dir.sh \
1559		"${PNAME}-${target}-${PVER}-${ARCH}-${PBUILD}" \
1560		${BINDIR} || die "target: ${target} package-build failed"
1561
1562		# build pkg-md5-sum if requested
1563		generate_package_md5sum \
1564		--pcat "${PCATEGORIE}" \
1565		--pname "${PNAME}" \
1566		--pver "${PVER}" \
1567		--pbuild "${PBUILD}" \
1568		--parch "${ARCH}" \
1569		--target "${target}"
1570
1571		echo -e "${COLGREEN}\nPackage ${PNAME}-${target}-${PVER}-${ARCH}-${PBUILD} successfully builded.\n${COLDEFAULT}"
1572		done
1573
1574		# build several subpackages
1575		elif [[ -n ${SPLIT_PACKAGES} ]]
1576		then
1577		split_save_variables
1578		for subpackage in ${SPLIT_PACKAGES}
1579		do
1580		# get the right variables for the split
1581		export PNAME="${subpackage}"
1582		split_info_${PNAME}
1583
1584		# jump to next one if NOPKGBUILD is set in split_info
1585		case ${NOPKGBUILD} in
1586		true|TRUE|yes|y) continue ;;
1587		esac
1588
1589		# check if an special subpackage_pkgbuild exists
1590		if typeset -f ${PNAME}_pkgbuild > /dev/null
1591		then
1592		# run it
1593		${PNAME}_pkgbuild
1594		fi
1595		# now create the target package
1596		${MLIBDIR}/pkgbuild_dir.sh \
1597		"${PNAME}-${PVER}-${ARCH}-${PBUILD}" \
1598		"${BINDIR}_${PNAME}" || die "split_package: ${PNAME} package-build failed"
1599
1600		# build pkg-md5-sum if requested
1601		generate_package_md5sum \
1602		--pcat "${PCATEGORIE}" \
1603		--pname "${PNAME}" \
1604		--pver "${PVER}" \
1605		--pbuild "${PBUILD}" \
1606		--parch "${ARCH}"
1607
1608		echo -e "${COLGREEN}\nPackage ${PNAME}-${PVER}-${ARCH}-${PBUILD} successfully builded.\n${COLDEFAULT}"
1609
1610		# restore smage environment
1611		split_restore_variables
1612		done
1613		# unset all saved smage variables
1614		split_unset_variables
1615
1616		else
1617		${MLIBDIR}/pkgbuild_dir.sh ${PKGNAME} ${BINDIR} || die "package-build failed"
1618
1619		# build pkg-md5-sum if requested
1620		generate_package_md5sum \
1621		--pcat "${PCATEGORIE}" \
1622		--pname "${PNAME}" \
1623		--pver "${PVER}" \
1624		--pbuild "${PBUILD}" \
1625		--parch "${ARCH}"
1626
1627		echo -e "${COLGREEN}\nPackage ${PKGNAME} successfully builded.\n${COLDEFAULT}"
1628		fi
1629
1630		# build src-pkg-tarball if requested
1631		[[ ${CREATE_SRC_PKG_TARBALL} = true ]] && source_pkg_build ${SMAGENAME}
1632	;;	;;
1633	esac	esac
1634
1635	#for sure	if [[ ${SMAGE_BUILD_LOGGING} != false ]]
1636		then
1637		bzip2 -9f /var/log/smage/${PKGNAME}.log
1638		else
1639		[[ -f /var/log/smage/${PKGNAME}.log ]] && rm /var/log/smage/${PKGNAME}.log
1640		fi
1641
1642		# for sure
1643	unset NOPKGBUILD	unset NOPKGBUILD
1644		unset NOSTRIP
1645
1646	xtitleclean	xtitleclean
	#echo -e "\nPackage ${PKGNAME} successfully builded.\n"

---

Colored Diff Long Colored Diff Full Colored Diff Unidiff Context Diff Side by Side

Legend: Removed from v.43   changed lines   Added in v.1581