haiku/build/scripts/build_haiku_image

#!/bin/sh
set -o errexit

# The first argument is the shell script that initializes the variables:
# sourceDir
# outputDir
# tmpDir
# addBuildCompatibilityLibDir
# gccVersion
# isHybridBuild
# The following are only for image types:
# installDir
# isImage
# imagePath
# imageSize
# imageLabel
# updateOnly
# dontClearImage
# isVMwareImage
# optionalPackageDescriptions
#
# addattr
# copyattr
# rc
# rmAttrs
# unzip
# The following are only for image types:
# bfsShell
# fsShellCommand
# makebootable
# resattr
# vmdkimage
# The following is only for cd types:
# generate_attribute_stores
# isCD
#
if [ $# -gt 0 ]; then
	. $1
	shift
fi

if [ ! $isCD ]; then
	# If the haiku image path is a symlink resolve it now (makebootable needs the
	# path of the actual device path under Linux).
	normalizedImagePath=''
	if readlink -f "$imagePath" > /dev/null 2>&1 ; then
		normalizedImagePath=$(readlink -f "$imagePath")
	elif realpath "$imagePath" > /dev/null 2>&1 ; then
		normalizedImagePath=$(realpath "$imagePath")
	elif greadlink -f "$imagePath" > /dev/null 2>&1 ; then
		normalizedImagePath=$(greadlink -f "$imagePath")
	fi
	if [ -n "$normalizedImagePath" ]; then
		imagePath="$normalizedImagePath"
	fi
fi

# this adds the build library dir to LD_LIBRARY_PATH
eval "$addBuildCompatibilityLibDir"

# map the shell commands
if [ $isCD ]; then
	outputDir=$tmpDir/cdsource

	sPrefix=
	tPrefix="$outputDir/"
	cd=cd
	scd=:
	cp="$copyattr -d"
	copyAttrs="$copyattr"
	ln=ln
	mkdir=mkdir
	rm=rm
elif [ $isImage ]; then
	sPrefix=:
	tPrefix=/myfs/
	cd="$fsShellCommand cd"
	scd="$fsShellCommand cd"
	cp="$fsShellCommand cp -f"
	copyAttrs="$fsShellCommand cp -a"
	ln="$fsShellCommand ln"
	mkdir="$fsShellCommand mkdir"
	rm="$fsShellCommand rm"
	mkindex="$fsShellCommand mkindex"
else
	sPrefix=
	# TODO: This should come from the environment.
	tPrefix="$installDir/"
	cd=cd
	scd=:
	cp="$copyattr -d"
	copyAttrs="$copyattr"
	ln=ln
	mkdir=mkdir
	rm=rm
	mkindex=mkindex
fi


extractFile()
{
	# extractFile <archive> <directory>
	archiveFile=$1
	targetExtractedDir=$2
	extractedSubDir=$3
	isGCCAgnostic=$4

	echo "Extracting $archiveFile ..."

	extractDir=$tmpDir/extract
	$rmAttrs -rf "$extractDir"
	mkdir -p "$extractDir"

	case "$archiveFile" in
		*.zip)
			$unzip -q -d "$extractDir" "$archiveFile"
			;;
		*.tgz|*.tar.gz)
			tar -C "$extractDir" -xf "$archiveFile"
			;;
		*)
			echo "Unhandled archive extension in build_haiku_image extractFile()"
			exit 1
			;;
	esac

	if [ -f $extractDir/.OptionalPackageDescription ]; then
		cat $extractDir/.OptionalPackageDescription >> $copyrightsFile
		echo >> $copyrightsFile
		rm $extractDir/.OptionalPackageDescription
	fi

	if [ "$isGCCAgnostic" = "true" ] && [ $isHybridBuild ] ; then
		extractedLibs=`find "$extractDir/$extractedSubDir/" -name "*.so"`
		moreExtractedLibs=`find "$extractDir/$extractedSubDir/" -name "*.so.*"`
		staticLibs=`find "$extractDir/$extractedSubDir/" -name "*.a"`
		#NOTE: should we symlink libtool's *.la files?
		#laLibs=`find "$extractDir/$extractedSubDir/" -name "*.la"`
		createSymlinksForHybrid $extractedLibs $moreExtractedLibs $staticLibs
	fi

	$cp -r "${sPrefix}$extractDir/$extractedSubDir/." "${tPrefix}$targetExtractedDir"

	$rmAttrs -rf "$extractDir"
}


createSymlinksForHybrid()
{
	# createSymlinksForHybrid <libraries>

	# Determine the alternative gcc subdir.
	if [ $gccVersion -eq 2 ]; then
		gccAltDir=gcc4
	else
		gccAltDir=gcc2
	fi

	# Iterate over the library file paths that were passed in.
	for srcPathLib in $@; do
		# determine the relative path of the library
		relPathLib=`echo $srcPathLib | \
			sed -e "s:${extractDir}/${extractedSubDir}/::"`
		relPath=`dirname $relPathLib`

		# check if that relative path is one of the standard library paths
		standardLibPaths="system/lib common/lib home/config/lib"
		isStandardPath=
		for stdLibPath in $standardLibPaths; do
			if [ "$relPath" = "$stdLibPath" ]; then
				isStandardPath=true
				break
			fi
		done

		# create alt gcc symlinks for libs inside standard paths
		if [ $isStandardPath ]; then
			srcPath=`dirname $srcPathLib`
			srcLib=`basename $srcPathLib`
			destLinkDir="${srcPath}/${gccAltDir}"
			destLinkTarget="../$srcLib"

			mkdir -p $destLinkDir
			ln -sf $destLinkTarget $destLinkDir
		fi
	done
}


mkdir -p $tmpDir
copyrightsFile=$tmpDir/copyrights
$rmAttrs -f $copyrightsFile
if [ "$optionalPackageDescriptions" ]; then
	cp "$optionalPackageDescriptions" $copyrightsFile
fi

if [ $isCD ]; then
	# setup output dir
	$rmAttrs -rf "$outputDir"
	mkdir -p "$outputDir"
fi

# create the image and mount it
if [ $isImage ]; then
	echo

	imageOffsetFlags=
	if [ $isVMwareImage ]; then
		imageOffsetFlags="--start-offset 65536"
	fi

	if [ ! $updateOnly ]; then
		echo "Creating image ..."

		imageFlags="-i${imageSize}M"
		if [ ! "$dontClearImage" ]; then
			imageFlags="$imageFlags -c"
		fi

		if [ $isVMwareImage ]; then
			$vmdkimage -h 64k $imageFlags "$imagePath"
		else
			$createImage $imageFlags "$imagePath"
		fi

		$bfsShell --initialize $imageOffsetFlags "$imagePath" \
			"$imageLabel" "block_size 2048"
		$makebootable $imageOffsetFlags "$imagePath"
	fi
	$bfsShell -n $imageOffsetFlags "$imagePath" > /dev/null &
	sleep 1
	# bail out, if mounting fails
	$cd .
fi

echo "Populating image ..."
while [ $# -gt 0 ]; do
	. $1
	shift
done


# install MIME database
# TODO: It should be possible to do that in the build system too.

if [ ! $updateOnly ]; then
	mimeDBSource=$sourceDir/src/data/beos_mime
	mimeDBDest=${tPrefix}home/config/settings/beos_mime

	echo "Deleting old MIME database ..."

	$rm -rf $mimeDBDest
	$mkdir -p $mimeDBDest
	mimeTmpDir=$tmpDir/mime
	mimeDBTmpDir=$tmpDir/mime/db
	mimeTmpIndex=0
	mimeTmpFile=$mimeTmpDir/mimedb$$.rsrc

	# create tmp dir for the MIME conversion stuff
	mkdir -p $mimeDBTmpDir

	echo "Installing MIME database ..."

	for inSuperFile in $mimeDBSource/*.super; do
		superType=$(basename $inSuperFile .super)
		tmpSuperDir=$mimeDBTmpDir/$superType

		# compile rdef to rsrc file and the rsrc file to attributes
		$rc -o $mimeTmpFile $inSuperFile
		mkdir -p $tmpSuperDir
		$resattr -O -o $tmpSuperDir $mimeTmpFile
		$rmAttrs $mimeTmpFile

		# iterate through the sub types
		for inSubFile in $mimeDBSource/$superType/*; do
			# check, if the type exists
			if test -f $inSubFile && grep META:TYPE $inSubFile > /dev/null 2>&1 ; then
				subType=$(basename $inSubFile)
				tmpSubFile=$mimeDBTmpDir/$superType/$subType

				# compile rdef to rsrc file and the rsrc file to attributes
				$rc -o $mimeTmpFile $inSubFile
				$resattr -O -o $tmpSubFile $mimeTmpFile
				$rmAttrs $mimeTmpFile
			fi
		done
	done

	$cp -r ${sPrefix}$mimeDBTmpDir/. $mimeDBDest

	# cleanup tmp dir
	$rmAttrs -rf $mimeTmpDir
fi	# ! updateOnly


# add the concatenated copyrights as an attribute to AboutSystem

if [ ! $updateOnly ]; then
	if [ -f $copyrightsFile ]; then
		copyrightAttrs=$tmpDir/copyrightAttrs
		$rmAttrs -f $copyrightAttrs
		touch $copyrightAttrs
		$addattr -f $copyrightsFile COPYRIGHTS $copyrightAttrs
		$copyAttrs ${sPrefix}$copyrightAttrs ${tPrefix}system/apps/AboutSystem
	fi
fi

if [ $isCD ]; then
	# generate the attribute stores
	echo "Generating attribute stores ..."
	$generate_attribute_stores "$tPrefix"

	echo "Copying boot image ..."
	$cp "$cdBootFloppy" "$outputDir"

	# build the iso image
	echo "Building CD image ..."
	mkisofs -uid 0 -gid 0 -b `basename $cdBootFloppy` -R -V "$cdLabel" -o "$cdImagePath" "$tPrefix"

	# cleanup output dir
	$rmAttrs -rf "$outputDir"
fi

# unmount
if [ $isImage ]; then
	echo "Unmounting ..."
	$fsShellCommand sync
	$fsShellCommand quit
fi