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

Parent Directory | Revision Log | Patch

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