#!/bin/sh
#
# Ronny Wichers Schreur
#
#set -vx # shell debug options
#set -e

# strategy:
# get all sources from CVS
# copy and build from non-clean sources
# copy build from clean sources (with distribution)
# build distribution step 1
# test
# copy build from clean sources (with new build)
# test

# TODO
#   ... reduce number of C compilers
#   ... build *everything* from CVS 
#   ... also for other platforms, mac should be easiest
#   ... test bootstrap

BUILDSCRIPT=`cygpath --unix --absolute "$0"`
BUILDDIR=`dirname "$BUILDSCRIPT"`

#
# Configure section
#

# Where to build
ROOT="$BUILDDIR"

# dos command shell
COMMAND=`cygpath --unix $COMSPEC`

# CVS command
if test -e "C:\Program Files\TortoiseCVS"; then
	TORTOISE_ROOT=`cygpath --unix "C:\Program Files\TortoiseCVS"`
	CVS_RSH=TortoisePlinkSSH2.bat
else
	TORTOISE_ROOT=`cygpath --unix "C:\Program Files (x86)\TortoiseCVS"`
	CVS_RSH=TortoisePlink.exe
fi
PATH=$TORTOISE_ROOT:$PATH
CVS=cvs

# CVS options
CVS_CLEAN_INTERNAL=":ext:@leto.cs.kun.nl:/vol/st/repository"
CVS_CLEAN_PUBLIC=":pserver:anonymous@cvs-srv.cs.kun.nl:/clean"
CVS_ROOT="$CVS_CLEAN_INTERNAL"
CVS_REVISION=HEAD
CVS_QUIET=-Q
CVS_GET_CMD="export -r "$CVS_REVISION"" # also possible 'checkout'

# Clean System
CLEANROOT=`cygpath --unix "C:\Documents and Settings\ronny\Desktop\build Clean 2.1.1b1\Clean 2.1.0"`

# CodeWarrior
if test -e "C:\Program Files\Metrowerks\CodeWarrior\bin\IDE.exe"; then
	CWIDE=`cygpath --unix "C:\Program Files\Metrowerks\CodeWarrior\bin\IDE.exe"`
else
	CWIDE=`cygpath --unix "C:\Program Files (x86)\Metrowerks\CodeWarrior\bin\IDE.exe"`
fi

# MS Visual .NET
if test -e "C:\Program Files\Microsoft Visual Studio .NET 2003"; then
	VSROOT="C:\Program Files\Microsoft Visual Studio .NET 2003"
	VSDEVENV=`cygpath --unix "$VSROOT\Common7\IDE\devenv.exe"`
	VSVARS="$VSROOT\Common7\Tools\vsvars32.bat"
	VSCC="$VSROOT\VC7\BIN\cl.exe"
else
	VSROOT="C:\Program Files (x86)\Microsoft Visual Studio"
	VSDEVENV=`cygpath --unix "$VSROOT\Common\MSDev98\Bin\msdev.exe"`
	VSVARS="$VSROOT\VC98\Bin\vcvars32.bat"
	VSCC="$VSROOT\VC98\Bin\cl.exe"
fi

STDENV_SYSTEM_MODULES="StdBool StdChar StdFile StdInt StdMisc StdReal StdString"


log ()
	# $1: message
{
	echo "$1"
}

fatal ()
	# $1: message
{
	log "$1"
	exit 1
}

checkreturncodeoptionallyfail ()
	# $1: where
	# $2: error message
	# $3: return code
	# $4: 0: don't fail, otherwise: fail
{
	if test $3 -ne 0; then
		if test $4 -eq 0; then
			log "$1: warning ($3) $2"
		else
			fatal "$1: error ($3) $2"
		fi
	fi
}

checkreturncode ()
	# $1: where
	# $2: error message
	# $3: return code
{
	checkreturncodeoptionallyfail "$1" "$2" $3 1
}

checkcleanreturncode ()
	# $1: clean system dir
	# $2: where
	# $3: error message
	# $4: return code
{
	if test "$1" = "$CLEANROOT" ; then
		checkcleanreturncode_fail=0
	else
		checkcleanreturncode_fail=1
	fi

	checkreturncodeoptionallyfail "$2" "$3" $4 $checkcleanreturncode_fail
}

cvsget ()
	# $1: destination directory
	# $2: cvs module
{
	# for some reason 
	#   % cvs -d destination/cvsmodule cvsmodule
	# doesn't seem to work that's why we cd to the destination dir

	log "CVS '$CVS_EXPORT_CMD' '$2'"

	(	cd "$1"
		$CVS -d "$CVS_ROOT" $CVS_QUIET $CVS_GET_CMD "$2"
		checkreturncode "cvsget" "getting '$1' to '$2'" $?
	)
}

makedir ()
	# $1: directory path
{
	if test -e "$1"; then
		fatal "makedir: directory '$1' already exists"
	fi

	mkdir -p "$1"
	checkreturncode "makedir" "creating '$1'" $?
}

move ()
	# $1: source path
	# $2: destination path
{
	if test ! -e "$1"; then
		fatal "move source '$1' does not exist"
	fi
	if test -e "$2"; then
		fatal "move destination '$2' already exists"
	fi

	mv "$1" "$2"
	checkreturncode "move" "moving '$1' to '$2'" $?
}

remove ()
	# $1: directory or file path
{
	if test ! -e "$1"; then
		fatal "remove '$1' does not exist"
	fi
	rm -r "$1"
	checkreturncode "remove" "removing '$1'" $?
}

duplicate ()
	# $1: source path
	# $2: destination path
{
	log "duplicating '$1' -> '$2'"

	if test ! -e "$1"; then
		fatal "duplicate: source '$1' does not exist"
	fi
	if test -e "$2"; then
		fatal "duplicate: destination '$2' already exists"
	fi

	cp -r "$1" "$2"
	checkreturncode "duplicate" "copying '$1' to '$2'" $?
}

vscc ()
	# $1: C .c file path
{
	vscc_file=`cygpath --absolute --windows "$1"`
	vscc_dir=`dirname "$1"`

	(cd "$vscc_dir"
	cat <<EOBATCH | "$COMMAND"
@		"$VSVARS"
@		cl /nologo /c /O "$vscc_file"
EOBATCH
	checkreturncode "vscc" "compiling '$1'" $?
	)
}

vsbuild ()
	# $1: project file path
	# $2: target name
{
	vsbuild_project=`cygpath --absolute --windows "$1"`

	log "vsbuild '$1' '$2'"
	"$VSDEVENV" "$vsbuild_project" /build "$2"

	checkreturncode "vsbuild" "building '$1' '$2'" $?
}

cwbuild ()
	# $1: project file path
	# $2: target name
{
	cwbuild_project=`cygpath --absolute --windows "$1"`

	log "cwbuild '$1' '$2'"
	"$CWIDE" /s /q /t "$2" /b "$cwbuild_project"

	checkreturncode "cwbuild" "building '$1' '$2'" $?
}

cleancocl ()
	# $1: clean system dir
	# $2: clean icl module path
	# $3: dynamic option
{
	TMP=/tmp # +++
	cleancocl_error=`cygpath --windows "$TMP/cocl.error"`
	cleancocl_out=`cygpath --windows "$TMP/cocl.out"`

	cleancocl_moduledir=`dirname "$2"`
#	cleancocl_moduledir=`cygpath --windows --absolute "$cleancocl_moduledir"`
	cleancocl_module=`basename "$2"`
	cleancocl_sytemdir=`cygpath --windows --absolute "$1"`

	if test "$3"x = "-dynamic"x; then
		cleancocl_paths="."
		cleancocl_paths="$cleancocl_paths"\;"$cleancocl_sytemdir"\\Libraries\\Dynamics\\extension
		cleancocl_paths="$cleancocl_paths"\;"$cleancocl_sytemdir"\\Libraries\\Dynamics\\implementation\\windows
		cleancocl_dynamics="-dynamics"
	else
		cleancocl_paths="."
		cleancocl_dynamics=
	fi
	

	(cd "$cleancocl_moduledir"
	# allow initial build with 2.1.0 release that has version numbers
	echo "$1/Tools/Clean System"*/CleanCompiler* \
		-P "$cleancocl_paths" \
		-RE "$cleancocl_error" -RO "$cleancocl_out" \
		-ou -pm -pt -wmt $cleancocl_dynamics \
		"$cleancocl_module" 
	"$1/Tools/Clean System"*/CleanCompiler* \
		-P "$cleancocl_paths" \
		-RE "$cleancocl_error" -RO "$cleancocl_out" \
		-ou -pm -pt -wmt $cleancocl_dynamics \
		"$cleancocl_module" 
		# -RO: redirect error/out
		# -ou: reuse unique nodes / -pm: memory profile / -pt: time profile
	)

	checkcleanreturncode "$1" "cleancocl" "compiling '$2'" $?
}

cleanbuild ()
	# $1: clean system dir
	# $2: clean project file path
{
	cleanbuild_project=`cygpath --windows --absolute "$2"`

	"$1/CleanIDE" --batch-build "$cleanbuild_project"

	checkcleanreturncode "$1" "cleanbuild" "building '$2'" $?
}

htoclean ()
	# $1: htoclean path
	# $2: C .h file path
{
	"$1" "$2"

	checkreturncode "htoclean" "converting '$2'" $?
}

buildallcleanprojectfiles ()
	# $1: clean system dir
	# $2: directory with projects to build
{
    for prj in "$2"/*.prj; do
        if test -f "$prj"; then
            cleanbuild "$1" "$prj"
        fi
    done

    # recurse in dirs
    for dir in "$2"/*; do
        if test -d "$dir"; then
			buildallcleanprojectfiles "$1" "$dir"
        fi
    done
}

CLEAN_LIBRARIES="ArgEnvWindows Directory ExtendedArith GEC Gast Hilde\
					MersenneTwister Parsers StdEnv StdLib WrapDebug ExceptionsWindows"

xmakedir ()
	# $1: directory path
{
	mkdir -p "$1"
	checkreturncode "makedir" "creating '$1'" $?
}

cvscleansystem ()
	# $1: destination directory
{
	xmakedir "$1"

	for cvscleansystem_lib in $CLEAN_LIBRARIES; do
		cvsget "$1" "libraries/$cvscleansystem_lib"	
	done
	cvsget "$1" CodeGenerator
	cvsget "$1" RuntimeSystem
	cvsget "$1" compiler
	cvsget "$1" dynamic
	cvsget "$1" tools/CleanIDE
	cvsget "$1" tools/Sparkle
	cvsget "$1" tools/htoclean
	cvsget "$1" libraries/GenLib
	cvsget "$1" CleanExamples/Generics
	cvsget "$1" libraries/ObjectIO
	cvsget "$1" CleanExamples/Small\ Examples
}

xduplicate ()
	# $1: source path
	# $2: destination path
{
	log "duplicating '$1' -> '$2'"

	if test ! -e "$1"; then
		fatal "xduplicate: source '$1' does not exist"
	fi
	if test ! -e "$2"; then
		cp -r "$1" "$2"
		checkreturncode "xduplicate" "copying '$1' to '$2'" $?
	fi
}

xduplicate2 ()
	# $1: source path
	# $2: destination dir
{
	log "duplicating '$1' -> '$2'"

	if test ! -e "$1"; then
		fatal "xduplicate: source '$1' does not exist"
	fi
	if test ! -e "$2"; then
		fatal "xduplicate: destination '$2' does not exist"
	fi

	xduplicate2_file=`basename "$1"`
	xduplicate "$1" "$2/$xduplicate2_file"
}


xduplicatefiles ()
	# $1: source path
	# $2: destination path
{
	log "duplicating files '$1' -> '$2'"

	if test ! -e "$1"; then
		fatal "xduplicate: source '$1' does not exist"
	fi
	if test ! -e "$2"; then
		fatal "xduplicate: destination '$2' does not exist"
	fi

	for xduplicatefiles_source in "$1"/*; do
		xduplicatefiles_file=`basename "$xduplicatefiles_source"`
		xduplicate "$xduplicatefiles_source" "$2/$xduplicatefiles_file"
	done
}

xmove ()
	# $1: source path
	# $2: destination path
{
	if test ! -e "$2"; then
		if test ! -e "$1"; then
			fatal "xmove source '$1' does not exist"
		fi
		mv "$1" "$2"
		checkreturncode "xmove" "moving '$1' to '$2'" $?
	fi
}


xremove ()
	# $1: directory or file path
{
	if test -e "$1"; then
		rm -r "$1"
		checkreturncode "xremove" "removing '$1'" $?
	fi
}



NONCLEAN_COMPONENTS="runtimesystem backend dynamicchannel dynamicgraphconversion 
						idersrc ioobjects codegen stdenvobj"

runtimesystem_build ()
	# $1: cvs dir
	# $2: build dir
{
	xduplicate "$1/RuntimeSystem" "$2/runtimesystem"
	chmod +x "$2/runtimesystem/build_windows_object_files.sh"

	(cd "$2/runtimesystem"
	./build_windows_object_files.sh
	)
}

runtimesystem_dist ()
	# $1: non-Clean build dir
	# $2: dist dir
{
	for objectfile in _startup1.o _startup1Profile.o _startup1Trace.o _startup2.o ; do
		xduplicate2 "$1/RuntimeSystem/$objectfile" "$2/Libraries/StdEnv/Clean System Files"
		xduplicate2 "$1/RuntimeSystem/$objectfile" "$2/Libraries/StdEnv Sparkle/Clean System Files"
	done
}

backend_build ()
	# $1: cvs dir
	# $2: build dir
{
	xduplicate "$1/compiler/backendC" "$2/backend"
	cwbuild "$2/backend/backend.mcp" backend.dll
}

backend_dist ()
	# $1: non-Clean build dir
	# $2: dist dir
{
	xduplicate "$1/backend/backend.dll" "$2/Tools/Clean System/backend.dll"
}

dynamicchannel_build ()
	# $1: cvs dir
	# $2: build dir
{
	xduplicate "$1/dynamic/dynamics/Channel" "$2/dynamicchannel"

	(cd "$2/dynamicchannel"
	cat <<EOBATCH | "$COMMAND"
@		"$VSVARS"
@		call build_dlls_and_exes.bat
EOBATCH
	)

#	vsbuild "$2/dynamicchannel/Dynamics.sln" debug # +++ release
#	vsbuild "$2/dynamicchannel/DynamicLinker Workspace 2.dsw"
}

dynamicchannel_dist ()
	# $1: non-Clean build dir
	# $2: dist dir
{
	xduplicate "$1/dynamicchannel/ClientChannel/ClientChannel.dll" \
					"$2/Tools/Dynamics/ClientChannel.dll"
	xduplicate "$1/dynamicchannel/ClientChannel/ClientChannel.dll" \
					"$2/Tools/Dynamics/utilities/ClientChannel.dll"
	xduplicate "$1/dynamicchannel/StaticClientChannel/StaticClientChannel.dll" \
					"$2/Tools/Dynamics/StaticClientChannel.dll"
	xduplicate "$1/dynamicchannel/StaticClientChannel/StaticClientChannel.dll" \
					"$2/Tools/Dynamics/utilities/StaticClientChannel.dll"
	xduplicate "$1/dynamicchannel/DynamicLink/DynamicLink.dll" \
					"$2/Tools/Dynamics/DynamicLink.dll"
	xduplicate "$1/dynamicchannel/ServerChannel/ServerChannel.dll" \
					"$2/Tools/Dynamics/ServerChannel.dll"
	xduplicate "$1/dynamicchannel/ConsoleClient/ConsoleClient.exe" \
					"$2/Tools/Dynamics/utilities/ConsoleClient.exe"
	xduplicate "$1/dynamicchannel/GuiClient/GuiClient.exe" \
					"$2/Tools/Dynamics/utilities/GuiClient.exe"
}

dynamicgraphconversion_build ()
	# $1: cvs dir
	# $2: build dir
{
	xduplicate "$1/dynamic/dynamics/Graph conversion" "$2/dynamicgraphconversion"

	xremove "$2/dynamicgraphconversion/as.exe"
	xremove "$2/dynamicgraphconversion/sed.exe"
	xremove "$2/dynamicgraphconversion/cygwin.dll"

	(cd "$2/dynamicgraphconversion"
	cat <<EOBATCH | "$COMMAND"
@		"$VSVARS"
@		call z.bat
EOBATCH
	)
}

dynamicgraphconversion_dist ()
	# $1: non-Clean build dir
	# $2: dist dir
{
	xduplicate "$1/dynamicgraphconversion/copy_graph_to_string_0x00010101.obj" \
				"$2/Tools/Dynamics/conversion/copy_graph_to_string_0x00010101.obj"
	xduplicate "$1/dynamicgraphconversion/copy_string_to_graph_0x00010101.obj" \
				"$2/Tools/Dynamics/conversion/copy_string_to_graph_0x00010101.obj"
}

idersrc_build ()
	# $1: cvs dir
	# $2: build dir
{
	xduplicate "$1/tools/CleanIDE/WinSupport" "$2/idersrc"

	(cd "$2/idersrc"
	cat <<EOBATCH | "$COMMAND"
@		"$VSVARS"
@		call makeresource.bat
EOBATCH
	)
}

idersrc_dist ()
	# $1: non-Clean build dir
	# $2: dist dir
{
}

ioobjects_build ()
	# $1: cvs dir
	# $2: build dir
{
	xduplicate "$1/libraries/ObjectIO/ObjectIO/OS Windows/Windows_C_12" "$2/ioobjects"

	for c in "$2"/ioobjects/*.c; do
		vscc "$c"
    done
}

ioobjects_dist ()
	# $1: non-Clean build dir
	# $2: dist dir
{
	for ioobjects_dist_ioobj in "$1"/ioobjects/*.obj; do \
		xduplicate2 "$ioobjects_dist_ioobj" "$2/Libraries/ObjectIO/OS Windows/Clean System Files/"
	done
}

codegen_build ()
	# $1: cvs dir
	# $2: build dir
{
	xduplicate "$1/CodeGenerator" "$2/codegen"

	(	cd "$2/codegen"
		make -f Makefile.windows
		checkreturncode "codegen_build" "making cg.exe" $?
	)
}

codegen_dist ()
	# $1: non-Clean build dir
	# $2: dist dir
{
	xduplicate "$1/codegen/cg.exe" "$2/Tools/Clean System/CodeGenerator.exe"
}

stdenvobj_build ()
	# $1: cvs dir
	# $2: build dir
{
	xduplicate "$1/libraries/StdEnv/Object Files Windows 32" "$2/stdenvobj"
}

stdenvobj_dist ()
	# $1: non-Clean build dir
	# $2: dist dir
{
	xduplicate2 "$1"/stdenvobj/_startup0.o "$2/Libraries/StdEnv/Clean System Files"
	for stdenvobj_dist_object in "$1"/stdenvobj/*_library; do
		xduplicate2 "$stdenvobj_dist_object" "$2/Libraries/StdEnv/Clean System Files"
	done
}

CLEAN_COMPONENTS="compiler stdenv ide dynamic sparkle htoclean"

cleanduplicate ()
	# $1: source path
	# $2: alternative source path
	# $3: destination path
{
	if test -e "$1"; then
		xduplicate "$1" "$3"
	else
		xduplicate "$2" "$3"
	fi
}

compiler_build ()
	# $1: clean system dir
	# $2: cvs dir
	# $3: build dir
{
	xduplicate "$2/compiler" "$3/compiler"

	xduplicate "$3/compiler/backendC/CleanCompilerSources/backend.h" \
				 "$3/compiler/backend/backend.h"

	compiler_build_htoclean="$1/Tools/htoclean/htoclean.exe"

	# allow initial build with 2.1.0 release that has version numbers
	"$1/Tools/htoclean"*/htoclean.exe `cygpath --windows --absolute "$3/compiler/backend/backend.h"`

	xmove "$3/compiler/coclmaindll/cocl.prj" "$3/compiler/cocl.prj"
	xmakedir "$3/compiler/Clean System Files"
	cleanbuild "$1" "$3/compiler/cocl.prj"
}

compiler_dist ()
	# $1: Clean build dir
	# $2: non-Clean build dir
	# $3: dist dir
{
	cleanduplicate "$1/compiler/cocl.exe" "$CLEANROOT/Tools/Clean System"*/CleanCompiler*.exe \
						"$3/Tools/Clean System/CleanCompiler.exe"
}

stdenv_build ()
	# $1: clean system dir
	# $2: cvs dir
	# $3: build dir
{
	xduplicate "$2/libraries/StdEnv" "$3/stdenv"

	# compile twice to inline abc code between system modules
	for stdenv_build_m in $STDENV_SYSTEM_MODULES; do
		cleancocl "$1" "$3/stdenv/$stdenv_build_m" -dynamic;
	done
	for stdenv_build_m in $STDENV_SYSTEM_MODULES; do
		cleancocl "$1" "$3/stdenv/$stdenv_build_m";
	done
}

stdenv_dist ()
	# $1: Clean build dir
	# $2: non-Clean build dir
	# $3: dist dir
{
	for stdenv_dist_m in $STDENV_SYSTEM_MODULES; do
		xduplicate "$1/stdenv/Clean System Files/$stdenv_dist_m.abc" \
			"$3/Libraries/StdEnv/Clean System Files/$stdenv_dist_m.abc"
		xduplicate "$1/stdenv/Clean System Files/$stdenv_dist_m.tcl" \
			"$3/Libraries/StdEnv/Clean System Files/$stdenv_dist_m.tcl"
	done	
}

ide_build ()
	# $1: clean system dir
	# $2: cvs dir
	# $3: build dir
{
	xduplicate "$2/tools/CleanIDE" "$3/ide"

	for ide_build_prj in WinIde WinHeapProfile WinTimeProfile; do
		cleanbuild "$1" "$3/ide/$ide_build_prj.prj"
	done
}

ide_dist ()
	# $1: Clean build dir
	# $2: non-Clean build dir
	# $3: dist dir
{
	cleanduplicate "$1/ide/CleanIDE.exe" "$CLEANROOT/CleanIDE.exe" \
						"$3/CleanIDE.exe"
	cleanduplicate "$1/ide/ShowHeapProfile.exe" "$CLEANROOT"/Tools/Heap\ Profiler*/ShowHeapProfile*.exe \
						"$3/Tools/Heap Profiler/ShowHeapProfile.exe"
	cleanduplicate "$1/ide/ShowTimeProfile.exe" "$CLEANROOT"/Tools/Time\ Profiler*/ShowTimeProfile*.exe \
						"$3/Tools/Time Profiler/ShowTimeProfile.exe"
}

sparkle_build ()
	# $1: clean system dir
	# $2: cvs dir
	# $3: build dir
{
	xduplicate "$2/tools/Sparkle" "$3/sparkle"
	xduplicate "$2/compiler/frontend" "$3/sparkle/Libraries/frontend"

	cleanbuild "$1" "$3/sparkle/Sparkle.prj"

	# compile twice to inline abc code between system modules
	for stdenv_build_m in $STDENV_SYSTEM_MODULES; do
		cleancocl "$1" "$3/sparkle/libraries/StdEnv Sparkle 0.0.4a/$stdenv_build_m" -dynamic;
	done
	for stdenv_build_m in $STDENV_SYSTEM_MODULES; do
		cleancocl "$1" "$3/sparkle/libraries/StdEnv Sparkle 0.0.4a/$stdenv_build_m";
	done
}

sparkle_dist ()
	# $1: Clean build dir
	# $2: non-Clean build dir
	# $3: dist dir
{
	cleanduplicate "$1/sparkle/Tools/Sparkle.exe" "$CLEANROOT"/Tools/Sparkle*/Sparkle.exe \
						"$3/Tools/Sparkle/Sparkle.exe"

	mkdir -p "$3/Libraries/StdEnv Sparkle/Clean System Files"

	for stdenv_dist_m in $STDENV_SYSTEM_MODULES; do
		xduplicate "$1/sparkle/libraries/StdEnv Sparkle 0.0.4a/Clean System Files/$stdenv_dist_m.abc" \
			"$3/Libraries/StdEnv Sparkle/Clean System Files/$stdenv_dist_m.abc"
		xduplicate "$1/sparkle/libraries/StdEnv Sparkle 0.0.4a/Clean System Files/$stdenv_dist_m.tcl" \
			"$3/Libraries/StdEnv Sparkle/Clean System Files/$stdenv_dist_m.tcl"
	done	

	xduplicate2 "$3/Libraries/StdEnv/Clean System Files/_system.abc" "$3/Libraries/StdEnv Sparkle/Clean System Files"

	xduplicate2 "$2"/stdenvobj/_startup0.o "$3/Libraries/StdEnv Sparkle/Clean System Files"
	for stdenvobj_dist_object in "$2"/stdenvobj/*_library; do
		xduplicate2 "$stdenvobj_dist_object" "$3/Libraries/StdEnv Sparkle/Clean System Files"
	done
}

dynamic_build ()
	# $1: clean system dir
	# $2: cvs dir
	# $3: build dir
{
	xduplicate "$2/dynamic" "$3/dynamic"

	for dynamic_build_prj in  checkdynamics dumpDynamic dynGarbCollector \
									StaticLinker DynamicLinker; do
		cleanbuild "$1" "$3/dynamic/$dynamic_build_prj.prj"
	done
}

dynamic_dist ()
	# $1: clean system dir
	# $2: cvs dir
	# $3: build dir
{
	cleanduplicate "$1/dynamic/checkdynamics.exe" "$CLEANROOT"/Tools/Dynamics*/utilities/checkdynamics*.exe \
						"$3"/Tools/Dynamics/utilities/checkdynamics.exe
	cleanduplicate "$1/dynamic/dumpDynamic.exe" "$CLEANROOT"/Tools/Dynamics*/utilities/dumpDynamic*.exe \
						"$3"/Tools/Dynamics/utilities/dumpDynamic.exe
	cleanduplicate "$1/dynamic/dynGarbCollector.exe" "$CLEANROOT"/Tools/Dynamics*/utilities/dynGarbCollector*.exe \
						"$3"/Tools/Dynamics/utilities/dynGarbCollector.exe
	cleanduplicate "$1/dynamic/StaticLinker.exe" "$CLEANROOT"/Tools/Clean\ System*/StaticLinker*.exe \
						"$3"/Tools/Clean\ System/StaticLinker.exe
	cleanduplicate "$1/dynamic/DynamicLinker.exe" "$CLEANROOT"/Tools/Dynamics*/DynamicLinker*.exe \
						"$3"/Tools/Dynamics/DynamicLinker.exe
}

htoclean_build ()
	# $1: clean system dir
	# $2: cvs dir
	# $3: build dir
{
	xduplicate "$2/tools/htoclean/htoclean source code" "$3/htoclean"

	cleanbuild "$1" "$3/htoclean/htoclean.prj"
}

htoclean_dist ()
	# $1: clean system dir
	# $2: cvs dir
	# $3: build dir
{
	cleanduplicate "$1/htoclean/htoclean.exe" "$CLEANROOT"/Tools/htoclean*/htoclean*.exe \
						"$3/Tools/htoclean/htoclean.exe"	
}

buildnonclean ()
	# $1: directory with sources from cvs
	# $2: directory to build components that are not written in Clean
{
	xmakedir "$2"

	for buildnonclean_component in $NONCLEAN_COMPONENTS; do
		${buildnonclean_component}_build "$1" "$2" $buildnonclean_component
	done
}

buildclean ()
	# $1: clean system dir
	# $2: directory with sources from cvs
	# $3: directory to build components that are written in Clean
{
	xmakedir "$3"

	for buildclean_component in $CLEAN_COMPONENTS; do
		${buildclean_component}_build "$1" "$2" "$3" $buildclean_component
	done
}

distcreatedirs ()
	# $1: directory to put distribution in
{
	xmakedir "$1"
	xmakedir "$1/Libraries"
	xmakedir "$1/Examples"
	xmakedir "$1/Temp"
	xmakedir "$1/Tools"
	xmakedir "$1/Tools/Clean System"
	xmakedir "$1/Tools/Dynamics"
	xmakedir "$1/Tools/Dynamics/conversion"
	xmakedir "$1/Tools/Dynamics/utilities"
	xmakedir "$1/Tools/Heap Profiler"
	xmakedir "$1/Tools/Time Profiler"
	xmakedir "$1/Tools/Sparkle"
}

distduplicate ()
	# $1: directory with sources from cvs
	# $2: directory to put distribution in
{
	# Root
	xduplicate "$1/tools/CleanIDE/CleanLicenseConditions.txt" "$2/CleanLicenseConditions.txt"

	# Config
	xduplicate "$1"/tools/CleanIDE/Config "$2"/Config
	xremove "$2"/Config/Macintosh
	xduplicate "$2"/Config/windows.km "$2"/Config/default.km

	# Tools
	xduplicate "$1/tools/htoclean" "$2/Tools/htoclean"
	xduplicate "$1/tools/CleanIDE/HeapProfile/ShowHeapProfileHelp" "$2/Tools/Heap Profiler/ShowHeapProfileHelp"
	xduplicate "$1/tools/CleanIDE/TimeProfile/ShowTimeProfileHelp" "$2/Tools/Time Profiler/ShowTimeProfileHelp"
	xduplicate "$1/tools/Sparkle/Tools/Changes.txt" "$2/Tools/Sparkle/Changes.txt"
	xduplicate "$1/tools/Sparkle/Tools/options" "$2/Tools/Sparkle/options"
	xduplicate "$1/tools/Sparkle/Tools/Images" "$2/Tools/Sparkle/Images"
	xduplicate "$1/tools/Sparkle/Tools/Sections" "$2/Tools/Sparkle/Sections"

	# Libraries
	for distduplicate_library in $CLEAN_LIBRARIES; do
		xduplicate "$1/libraries/$distduplicate_library" "$2/Libraries/$distduplicate_library"
	done
	xmove "$2/Libraries/Directory/Clean System Files Windows" \
			"$2/Libraries/Directory/Clean System Files"
	xmove "$2/Libraries/ExtendedArith/ExtendedArith/Clean System Files Windows" \
			"$2/Libraries/ExtendedArith/ExtendedArith/Clean System Files"
	xduplicate "$1/libraries/ObjectIO/ObjectIO" "$2/Libraries/ObjectIO"
	xduplicate "$1/libraries/ObjectIO/GameLib" "$2/Libraries/GameLib"
	xduplicate "$1/libraries/ObjectIO/Tcp" "$2/Libraries/Tcp"
	xremove "$2/Libraries/Tcp/Macintosh"
	xduplicate "$1"/libraries/GenLib "$2/Libraries/Generics"
	xduplicate "$1"/dynamic/dynamics/StdDynamicEnv "$2/Libraries/Dynamics"
	xduplicate "$1/tools/Sparkle/Libraries/StdEnv Sparkle 0.0.4a" "$2/Libraries/StdEnv Sparkle"
	xremove "$2/Libraries/Directory/Clean System Files Macintosh"
	xremove "$2/Libraries/ExtendedArith/ExtendedArith/Clean System Files Macintosh"
	xremove "$2/Libraries/StdEnv/Object Files Windows 32"
	xremove "$2/Libraries/StdEnv/StdFile_solaris.icl"
	xremove "$2/Libraries/StdEnv/StdFile_solaris.dcl"
	xremove "$2/Libraries/StdEnv/Library Files Macintosh"
	xremove "$2/Libraries/StdEnv/Makefile.linux"
	xremove "$2/Libraries/StdEnv/Makefile.solaris"
	xremove "$2/Libraries/ObjectIO/OS Linux"
	xremove "$2/Libraries/ObjectIO/OS Mac Carbon"

	xmakedir "$2/Libraries/Hilde/OS Windows/Clean System Files"
	xduplicate "$1/Libraries/Hilde/OS Windows/Foreign/windowsKERNEL32_library" "$2/Libraries/Hilde/OS Windows/Clean System Files/windowsKERNEL32_library"
	xduplicate "$1/Libraries/Hilde/OS Windows/Foreign/windowsWS2_32_library" "$2/Libraries/Hilde/OS Windows/Clean System Files/windowsWS2_32_library"

	xremove "$2/Libraries/Hilde/WrapDebugClosures"
	for distduplicate_ioobj in \
		"$2/LibrariesObjectIO/OS Windows/Clean System Files"/*.obj; do
		xremove "$distduplicate_ioobj"
	done

	# Examples
	xduplicate "$1"/CleanExamples/Generics "$2"/Examples/Generics
	xduplicate "$1"/CleanExamples/Small\ Examples "$2"/Examples/Small\ Examples
	xremove "$2"/Examples/Small\ Examples/Macintosh
	xduplicate "$1/libraries/ObjectIO/ObjectIO Examples" "$2/Examples/ObjectIO Examples"
	for a in "$2/Examples/ObjectIO Examples/"*; do
		xremove "$a/Macintosh"
	done
	xduplicate "$1/libraries/ObjectIO/Game Examples" "$2/Examples/Game Examples"
	xduplicate "$1/libraries/ObjectIO/Tcp Examples" "$2/Examples/Tcp Examples"
	for a in "$2/Examples/Tcp Examples/"*; do
		xremove "$a/Macintosh"
	done
	xmove "$2/Libraries/GEC/examples" "$2/Examples/GEC"
	xduplicate "$1/dynamic/dynamics/Examples/User examples" "$2/Examples/Dynamics"

	xmakedir "$2/Examples/Parsers"
	xmove "$2/Libraries/Parsers/ParsersTestware.icl" "$2/Examples/Parsers/ParsersTestware.icl"
	xmove "$2/Libraries/Parsers/ParsersTestware.prj" "$2/Examples/Parsers/ParsersTestware.prj"
	xmove "$2/Libraries/Parsers/MetarDemo" "$2/Examples/Parsers/MetarDemo"

	# Help
	xduplicate "$1"/tools/CleanIDE/Help "$2"/Help
	xmove "$2/Tools/htoclean/CallingCFromClean.html" "$2/Help/CallingCFromClean.html"
	xmove "$2/Libraries/Parsers/Parsers Manual.doc" "$2/Help/Library Documents/Parsers Manual.doc"
}

dist ()
	# $1: directory with sources from cvs
	# $2: directory with built nonclean components
	# $3: directory with built clean components
	# $4: directory to put distribution in
{
	distcreatedirs "$4"
	distduplicate "$1" "$4"

	for dist_component in $CLEAN_COMPONENTS; do
		${dist_component}_dist  "$3" "$2" "$4"
	done

	for dist_component in $NONCLEAN_COMPONENTS; do
		${dist_component}_dist "$2" "$4"
	done
}

# main

cvscleansystem "$ROOT/cvssource"

buildnonclean "$ROOT/cvssource" "$ROOT/nonclean"

buildclean "$CLEANROOT" "$ROOT/cvssource" "$ROOT/step0/clean"
dist "$ROOT/cvssource" "$ROOT/nonclean" "$ROOT/step0/clean" "$ROOT/step0/dist"

buildclean "$ROOT/step0/dist" "$ROOT/cvssource" "$ROOT/step1/clean"
dist "$ROOT/cvssource" "$ROOT/nonclean" "$ROOT/step1/clean" "$ROOT/step1/dist"

buildclean "$ROOT/step1/dist" "$ROOT/cvssource" "$ROOT/step2/clean"
dist "$ROOT/cvssource" "$ROOT/nonclean" "$ROOT/step2/clean" "$ROOT/step2/dist"

buildallcleanprojectfiles "$ROOT/step1/dist"  "$ROOT/step1/dist/Examples"

log "Build successful!!!"