# hdw - linux create cross environment script
#
# author: hackbard@hackdaworld.dyndns.org
#
# this script is used to create the cross env
#

#
# hopefully obsolete, as toolchain gets build in every build now!
#
# just kept for nostalgic reasons, and damn it was a lot work to type
# this bullshit here ...
#

echo "create cross environment script obsolete now."
echo "we build a tool-chain in the beginning of stage 1"
echo "aborting ..."

exit

# some usefull functions
patch_it() {
	package=$1
	patches=`ls $hdw_home_dir/packages/base/$package/*.patch`
	for patch in $patches; do
		echo "applying patch $patch ..."
		patch -Nfp1 < $patch
	done
	patches=`ls $hdw_home_dir/packages/base/$package/*.patch.${hdw_arch}`
	for patch in $patches; do
		echo "applying patch $patch ..."
		patch -Nfp1 < $patch
	done
	patches=`ls $hdw_home_dir/misc/crossbuild/$package/*.patch`
	for patch in $patches; do
		echo "applying patch $patch ..."
		patch -Nfp1 < $patch
	done
	patches=`ls $hdw_home_dir/misc/crossbuild/$package/*.patch.${hdw_arch}`
	for patch in $patches; do
		echo "applying patch $patch ..."
		patch -Nfp1 < $patch
	done
}

run_it() {
	echo "running: $@"
	$@
	return $?
}

set_cflags()	{
	echo "set apropriate compiler flags ..."
	export CC=cc AS=as LD=ld AR=ar NM=nm F77=f77 CXX=c++ 
	export STRIP=strip GASP=gasp RANLIB=ranlib KCC=kcc
	unset CFLAGS
}
	
# start

cross_root=""
no_glibc="0"

if [ ! -z "$1" ] ; then
	# this seems to be a standalone call
	. ./scripts/Config -stage 1 # no reason for other stage
	. ./scripts/subroutines
	# arguments
	while [ "$1" ] ; do
		case "$1" in
			-cross_root)	cross_root="$2"	; shift 2 ;;
			-standalone)	echo "default standalone call"
					shift 1 ;;
			-no_glibc)	no_glibc="1" 
					echo "not building glibc"
					shift 1 ;;
			*)		echo "usage:"
					echo "$0 -cross_root foobar"
					echo "$0 -standalone"
					echo ; exit 1 ;;
		esac
	done
fi

# small check
if [ -z "$hdw_build_dir" ] ; then
	echo "debug: \$hdw_build_dir variable not set"
	exit 1
fi

[ -z "$cross_root" ] && cross_root="$hdw_build_dir/crossenv-$hdw_arch"

if [ ! -f $cross_root/.cross_env ] ; then
	# prepare
	echo
	echo_r "warning: " 
	echo_y "crossbuilding is devel right now - you might crash your system!"
	echo
	echo_g "creating crossenv:"
	echo -e "\a" ; sleep 2
	# creating the cross root directory
	mkdir -p $cross_root
	
	# look for sources
	for object in linux binutils; do
		eval ${object}_src=`awk '/^# \[D\]/ { print $3 }' \
			packages/base/$object/$object | sort -r | tail -1`
		eval ${object}_ver=`awk '/^# \[V\]/ { print $3 }' \
			packages/base/$object/$object`
		eval tmp=\$${object}_src
		if [ -f download/base/$object/$tmp ] ; then
			echo "found $object package -> $tmp"
		else 
			echo "$tmp missing, aborting."
			exit 1
		fi
	done
	# gcc & glibc
	gcc_src=`awk '/^# \[D\]/ { print $3 }' packages/base/gcc/gcc`
	gcc_ver=`awk '/^# \[V\]/ { print $3 }' packages/base/gcc/gcc`
	glibc_src=`awk '/^# \[D\]/ { print $3 }' packages/base/glibc/glibc`
	glibc_ver=`awk '/^# \[V\]/ { print $3 }' packages/base/glibc/glibc`
	for i in $gcc_src; do
		if [ -f download/base/gcc/$i ] ; then
			echo "found gcc package -> $i"
		else
			echo "$i missing, aborting."
			exit 1
		fi
	done
	for i in $glibc_src; do
		if [ -f download/base/glibc/$i ] ; then
			echo "found glibc package -> $i"
		else
			echo "$i missing, aborting."
			exit 1
		fi
	done
	gcc1_src=`echo $gcc_src | awk '{ print $1 }'`
	gcc2_src=`echo $gcc_src | awk '{ print $2 }'`
	g_a="" ; [ "$gcc_ver" != "cvs" ] && g_a="-$gcc_ver"

	# we need it in PATH
	export PATH="$PATH:$cross_root/bin:$cross_root/$hdw_arch_target/bin"

	# create directories
	echo
	echo "creating build and crossenv directories ..."
	mkdir -p $hdw_build_dir/src.crossenv
	mkdir -p $cross_root/$hdw_arch_target/include
	
	#
	# prepare confopt, make_conf, install_conf and cmd variables
	#
	# variables
	set_cflags
	
	# build:
	cd $hdw_build_dir/src.crossenv

	# essential headers
	# linux headers
	echo "creating linux-headers"
	if [ -f .linux-header ] ; then
		echo "linux headers already build, skipping ..."
		echo "build date: -> `cat .linux-header`"
	else
		(
		echo "extracting linux source ..."
		tar --use-compress-program=bzip2 \
			-xvf $hdw_home_dir/download/base/linux/$linux_src
		cd linux-$linux_ver* &&
		# patching
		patch_it linux
		# make headers
		run_it make include/linux/version.h
		# copy them
		echo "copy headers ..."
		cp -rv include/linux $cross_root/$hdw_arch_target/include
		cp -rv include/asm-$hdw_arch \
			$cross_root/$hdw_arch_target/include/asm
		
		cd ..
		echo "`date`" > .linux-header
		) > linux-header.log 2>&1
	fi
	# glibc headers
	echo "creating glibc-headers"
	if [ -f .glibc-header ] ; then
		echo "glibc headers already build, skipping ..."
		echo "build date: -> `cat .glibc-header`"
	else
		(
		for s_src in $glibc_src; do
			echo "extracting $s_src ..."
			foo=""
			[ ! -z "`echo $s_src | grep threads`" ] &&
				foo="-C glibc-$glibc_ver"
			tar --use-compress-program=bzip2 \
			-xvf $hdw_home_dir/download/base/glibc/$s_src $foo
		done
		mkdir -p glibc-build
		cd glibc-build &&
		cd ../glibc-$glibc_ver
		# patching
		patch_it glibc
		cd -
		# install headers
		run_it ../glibc-$glibc_ver/configure --prefix=$cross_root/$hdw_arch_target --enable-add-ons --with-headers=$cross_root/$hdw_arch_target/include --target=$hdw_arch_target $hdw_arch_build
		abort_when_package_build_failed $? $_
		# according to Roland McGrath <roland at gnu dot org>
		run_it make crosscompiling=yes no_deps=t install-headers
		# ignore errors ..
		# abort_when_package_build_failed $? $_
		# copying some files
		cd ../glibc-$glibc_ver
		mkdir -p $cross_root/$hdw_arch_target/include/{gnu,bits}
		cp -v include/features.h $cross_root/$hdw_arch_target/include
		# cp bits/stdio_lim.h $cross_root/$hdw_arch_target/include/bits
		touch $cross_root/$hdw_arch_target/include/gnu/stubs.h
		cd ..
		echo "`date`" > .glibc-header
		) > glibc-header.log 2>&1
	fi
	# binutils
	echo "creating cross binutils"
	if [ -f .binutils ] ; then
		echo "binutils already build, skipping ..."
		echo "build date: -> `cat .binutils`"
	else
		(
		echo "extracting binutils source ..."
		tar --use-compress-program=bzip2 \
			-xvf $hdw_home_dir/download/base/binutils/$binutils_src
		cd binutils-* &&
		# patching
		patch_it binutils
		#build
		run_it ./configure --prefix=$cross_root --program-prefix=$hdw_arch_prefix --target=$hdw_arch_target $hdw_arch_build
		abort_when_package_build_failed $? $_
		run_it make all install
		abort_when_package_build_failed $? $_
		cd ..
		echo "`date`" > .binutils
		) > binutils.log 2>&1
	fi
	# bootstrap gcc
	echo "creating bootstrap gcc"
	if [ -f .bootstrap-gcc ] ; then
		echo "bootstrap gcc already build, skipping ..."
		echo "build date: -> `cat .bootstrap-gcc`"
	else
		(
		echo "extracting gcc source ..."
		tar --use-compress-program=bzip2 \
			-xvf $hdw_home_dir/download/base/gcc/$gcc1_src
		mkdir gcc-build
		cd gcc-build &&
		cd ../gcc${g_a}
		# patching
		patch_it gcc
		cd -
		# build
		run_it ../gcc${g_a}/configure --prefix=$cross_root --program-prefix=$hdw_arch_prefix --disable-cpp --disable-shared --disable-multilib --enable-languages=c --target=$hdw_arch_target $hdw_arch_build
		abort_when_package_build_failed $? $_
		run_it make all install
		abort_when_package_build_failed $? $_
		cd ..
		echo "`date`" > .bootstrap-gcc
		) > bootstrap-gcc.log 2>&1
	fi
	
	# end here for a kernel crosscompiler
	if [ "$no_glibc" = "1" ] ; then
		echo
		echo "finished creating crossenvironment"
		echo "you should now be able to build kernels for your alien."
		echo "add $cross_root/bin to your PATH variable"
		echo "edit ARCH and CROSS_COMPILE in your kernel's Makefile."
		echo "have fun ..."
		echo
		exit 0
	fi
	
	# we need to specify the tools now
	echo
	echo "running optimization script to specify build tools"
	echo
	. $hdw_home_dir/scripts/optimization
	
	# glibc
	echo "creating glibc"
	if [ -f .glibc ] ; then
		echo "glibc already build, skipping ..."
		echo "build date: -> `cat .glibc`"
	else
		(
		echo "recreating build directory ..."
		rm -rf glibc-build && mkdir glibc-build
		cd glibc-build &&
		# build cross glibc
		echo "debug: env variables"
		set
		echo
		run_it ../glibc-$glibc_ver/configure --enable-add-ons --enable-shared --with-headers=$cross_root/$hdw_arch_target/include --build=$hdw_arch_build --host=$hdw_arch_target --prefix=
		abort_when_package_build_failed $? $_
		run_it make
		abort_when_package_build_failed $? $_
		run_it make install_root=$cross_root/$hdw_arch_target install
		abort_when_package_build_failed $? $_
		cd ..
		echo "`date`" > .glibc
		) > glibc.log 2>&1
	fi
	# cross gcc
	# we again need diffrent cflags
	set_cflags
	echo "creating cross gcc"
	if [ -f .gcc ] ; then
		echo "cross gcc already build, skipping ..."
		echo "build date: -> `cat .gcc`"
	else
		(
		tar --use-compress-program=bzip2 \
		-xvf $hdw_home_dir/download/base/gcc/$gcc2_src
		echo "recreating build directory ..."
		rm -rf gcc-build && mkdir gcc-build
		cd gcc-build &&
		#build
		echo "debug: env variables"
		set
		echo
		run_it ../gcc${g_a}/configure --prefix=$cross_root --program-prefix=$hdw_arch_prefix --enable-languages="c,c++" --enable-shared --enable-threads --disable-multilib --target=$hdw_arch_target $hdw_arch_build # --host=$hdw_arch_build --build=$hdw_arch_build
		abort_when_package_build_failed $? $_
		run_it make
		abort_when_package_build_failed $? $_
		run_it make install
		abort_when_package_build_failed $? $_
		echo "`date`" > .gcc
		) > gcc.log 2>&1
	fi
	

	# making note
	date > $cross_root/.cross_env
	echo "crossenvironment ready - here we go now ;) ..."
else
	echo "crossenv allready existing, build at:"
	echo "-> `cat $cross_root/.cross_env`"
	if [ -z "`echo $PATH | grep $cross_root\/bin`" ] ; then	
		echo "just updating PATH variable ..."
		export PATH="$PATH:$cross_root/bin"
		export PATH="$PATH:$cross_root/$hdw_arch_target/bin"
	fi
fi

# return to home directory
cd $hdw_home_dir