#!/bin/sh
# vim: filetype=zsh

set -e

# I use this in EVERY shell script ;)
LF="
"

d00=`pwd`
while ! [ -f ./all ]; do
	if [ x"`pwd`" = x"/" ]; then
		echo "Cannot find myself."
		echo "Please run this script with the working directory inside a Xonotic checkout."
		exit 1
	fi
	cd ..
done
export d0=`pwd`
SELF="$d0/all"

# If we are on WINDOWS:
case "$0" in
	all|*/all)
		case "`uname`" in
			MINGW*|Win*)
				# Windows hates users. So this script has to copy itself elsewhere first...
				cp "$SELF" ../all.xonotic.sh
				export WE_HATE_OUR_USERS=1
				exec ../all.xonotic.sh "$@"
				;;
		esac
		;;
esac

msg()
{
	echo >&2 "$*"
}

self=`git hash-object "$SELF"`
checkself()
{
	self_new=`git hash-object "$SELF"`
	if [ x"$self" != x"$self_new" ]; then
		msg "./all has changed."
		if [ -z "$XONOTIC_FORBID_RERUN_ALL" ]; then
			msg "Rerunning the requested operation to make sure."
			export XONOTIC_FORBID_RERUN_ALL=1
			exec "$SELF" "$@"
		else
			msg "Please try $SELF update, and then retry your requested operation."
			exit 1
		fi
	fi
	return 0
}

verbose()
{
	msg "+ $*"
	"$@"
}

visible_repo_name()
{
	case "$1" in
		.)
			echo "the root directory"
			;;
		*)
			echo "\"$1\""
			;;
	esac
}

check_mergeconflict()
{
	if git ls-files -u | grep ' 1	'; then
		echo
		echo "MERGE CONFLICT."
		echo "change into the \"$1\" project directory, and then:"
		echo "- edit the files mentioned above with your favorite editor,"
		echo "  and fix the conflicts (marked with <<<<<<< blocks)"
		echo "- for binary files, you can select the files using"
		echo "  git checkout --ours or git checkout --theirs"
		echo "- when done with a file, 'git add' the file"
		echo "- when done, 'git commit'"
		echo
		exit 1
	fi
}

yesno()
{
	yesno=
	while [ x"$yesno" != x"y" -a x"$yesno" != x"n" ]; do
		eval "$2"
		echo "$1"
		IFS= read -r yesno
	done
	[ x"$yesno" = x"y" ]
}

enter()
{
	$2 cd "$1" || exit 1
	check_mergeconflict "$1"
}

repos_urls="
.                             |                                                   | master      |
data/xonotic-data.pk3dir      |                                                   | master      |
data/xonotic-music.pk3dir     |                                                   | master      |
data/xonotic-nexcompat.pk3dir |                                                   | master      | no
darkplaces                    |                                                   | div0-stable | svn
netradiant                    |                                                   | master      |
div0-gittools                 |                                                   | master      | no
data/xonotic-maps.pk3dir      |                                                   | master      |
mediasource                   |                                                   | master      | no
fteqcc                        | http://github.com/Blub/qclib.git                  | master      |
"
# todo: in darkplaces, change repobranch to div0-stable

repos=`echo "$repos_urls" | grep . | cut -d '|' -f 1 | tr -d ' '`

base=`git config remote.origin.url`
case "$base" in
	*/xonotic.git)
		base=${base%xonotic.git}
		;;
	*)
		echo "The main repo is not xonotic.git, what have you done?"
		exit 1
		;;
esac
pushbase=`git config remote.origin.pushurl || true`
case "$pushbase" in
	*/xonotic.git)
		pushbase=${pushbase%xonotic.git}
		;;
	'')
		;;
	*)
		echo "The main repo is not xonotic.git, what have you done?"
		exit 1
		;;
esac

repourl()
{
	repo_t=`echo "$repos_urls" | grep "^$1 " | cut -d '|' -f 2 | tr -d ' '`
	if [ -n "$repo_t" ]; then
		case "$repo_t" in
			*://*)
				echo "$repo_t"
				;;
			*)
				echo "$base$repo_t"
				;;
		esac
	else
		if [ x"$1" = x"." ]; then
			echo "$base""xonotic.git"
		else
			echo "$base${1##*/}.git"
		fi
	fi
}

repopushurl()
{
	[ -n "$pushbase" ] || return 0
	repo_t=`echo "$repos_urls" | grep "^$1 " | cut -d '|' -f 2 | tr -d ' '`
	if [ -n "$repo_t" ]; then
		case "$repo_t" in
			*://*)
				;;
			*)
				echo "$pushbase$repo_t"
				;;
		esac
	else
		if [ x"$1" = x"." ]; then
			echo "$pushbase""xonotic.git"
		else
			echo "$pushbase${1##*/}.git"
		fi
	fi
}

repobranch()
{
	repo_t=`echo "$repos_urls" | grep "^$1 " | cut -d '|' -f 3 | tr -d ' '`
	if [ -n "$repo_t" ]; then
		echo "$repo_t"
	else
		echo "master"
	fi
}

repoflags()
{
	echo "$repos_urls" | grep "^$1 " | cut -d '|' -f 4 | tr -d ' '
}

listrepos()
{
	for d in $repos; do
		p="${d%dir}"
		f="`repoflags "$d"`"
		# if we have the dir, always keep it
		if [ -d "$d" ]; then
			msg "Repository $d enabled because it already exists"
			echo "$d"
			continue
		fi
		# if .yes file exists, always keep it
		if [ -f "$d.yes" ]; then
			msg "Repository $d enabled by a .yes file"
			echo "$d"
			continue
		fi
		# if we have .no file, skip
		if [ -f "$d.no" ]; then
			msg "Repository $d disabled by a .no file, delete $p.no to enable"
			continue
		fi
		# if we have matching pk3, skip
		if [ x"$p" != x"$d" ] && [ -f "$p" ]; then
			msg "Repository $d disabled by matching .pk3 file, delete $p or create $d.yes to enable"
			continue
		fi
		# if "no" flag is set, skip
		case ",$f," in
			*,no,*)
				msg "Repository $d disabled by default, create $d.yes to enable"
				continue
				;;
		esac
		# default: enable
		msg "Repository $d enabled by default"
		echo "$d"
	done
}

repos=`listrepos`

if [ "$#" = 0 ]; then
	set -- help
fi
cmd=$1
shift

fix_upstream_rebase()
{
	if [ -z "$r_me" ] || [ -z "$r_other" ]; then
		return
	fi
	r_base=`git merge-base "$r_me" "$r_other"`

	# no merge-base? upstream did filter-branch
	if [ -n "$r_base" ]; then
		# otherwise, check if the two histories are "similar"
		r_l_me=`git log --pretty="format:%s" "$r_other".."$r_me" | grep -v "^Merge" | sort -u`
		r_l_other=`git log --pretty="format:%s" "$r_me".."$r_other" | grep -v "^Merge" | sort -u`

		# heuristics: upstream rebase/filter-branch if more than 50% of the commits of one of the sides are in the other too
		r_lc_me=`echo "$r_l_me" | wc -l`
		r_lc_other=`echo "$r_l_other" | wc -l`
		r_lc_together=`{ echo "$r_l_me"; echo "$r_l_other"; } | sort -u | wc -l`
		r_lc_same=$(($r_lc_me + $r_lc_other - $r_lc_together))

		if [ $(( $r_lc_same * 2 )) -gt $(( $r_lc_me )) ] || [ $(( $r_lc_same * 2 )) -gt $(( $r_lc_other )) ]; then
			if yesno "Probable upstream rebase detected, automatically fix?" 'git log --oneline --graph --date-order --left-right "$r_other"..."$r_me"'; then
				git reset --hard "$r_me"
				git pull --rebase
				return 1
			fi
		fi
	fi

	return 0
}

fix_upstream_rebase_mergeok()
{
	r_me=`git rev-parse --revs-only HEAD^1 2>/dev/null || true`
	r_other=`git rev-parse --revs-only HEAD^2 2>/dev/null || true`
	fix_upstream_rebase
}

fix_upstream_rebase_mergefail()
{
	r_me=`git rev-parse --revs-only HEAD 2>/dev/null || true`
	r_other=`git rev-parse --revs-only MERGE_HEAD 2>/dev/null || true`
	fix_upstream_rebase
}

fix_git_config()
{
	verbose git config remote.origin.url "$1"
	if [ -n "$2" ]; then
		verbose git config remote.origin.pushurl "$2"
	else
		verbose git config --unset remote.origin.pushurl || true
	fi
	verbose git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"
	verbose git config core.autocrlf input
	if [ -z "`git config push.default`" ]; then
		verbose git config push.default current # or is tracking better?
	fi
}

mkzip()
{
	archive=$1
	shift
	ziplist=`mktemp`
	find "$@" -xtype f \( -executable -or -type l \) -print > "$ziplist"
	7za a -tzip -mx=9 -x@"$ziplist" "$archive" "$@" || true
	zip         -9y   -@<"$ziplist" "$archive"      || true
	rm -f "$ziplist"
}

mkzip0()
{
	zip -0y "$@"
}

case "$cmd" in
	fix_upstream_rebase)
		for d in $repos; do
			enter "$d0/$d" verbose
			verbose fix_upstream_rebase_mergefail && verbose fix_upstream_rebase_mergeok
		done
		;;
	fix_config)
		for d in $repos; do
			url=`repourl "$d"`
			pushurl=`repopushurl "$d"`
			branch=`repobranch "$d"`
			if [ -d "$d0/$d" ]; then
				verbose cd "$d0/$d"
				fix_git_config "$url" "$pushurl"
				cd "$d0"
			fi
		done
		;;
	update|pull)
		allow_pull=true
		if [ x"$1" = x"-N" ]; then
			allow_pull=false
		fi
		if $allow_pull; then
			"$SELF" fix_config
		fi
		for d in $repos; do
			url=`repourl "$d"`
			pushurl=`repopushurl "$d"`
			branch=`repobranch "$d"`
			if [ -d "$d0/$d" ]; then
				if $allow_pull; then
					enter "$d0/$d" verbose
					r=`git symbolic-ref HEAD`
					r=${r#refs/heads/}
					if git config branch.$r.remote >/dev/null 2>&1; then
						if ! verbose git pull; then
							fix_upstream_rebase_mergefail || true
							check_mergeconflict "$d"
							echo "Pulling failed. Press ENTER to continue, or Ctrl-C to abort."
							read -r DUMMY
						else
							fix_upstream_rebase_mergeok || true
						fi
					fi

					cd "$d00"
					checkself "$cmd" "$@"
					cd "$d0/$d"
					verbose git remote prune origin
					cd "$d0"
				fi
			else
				verbose git clone "$url" "$d0/$d"
				enter "$d0/$d" verbose
				fix_git_config "$url" "$pushurl"
				if [ "$branch" != "master" ]; then
					verbose git checkout --track -b "$branch" origin/"$branch"
				fi
				cd "$d0"
			fi
		done
		;;
	update-maps)
		misc/tools/xonotic-map-compiler-autobuild download
		;;
	checkout|switch)
		checkoutflags=
		if [ x"$1" = x"-f" ]; then
			checkoutflags=-f
			shift
		fi
		remote=$1
		branch=$2
		if [ -z "$branch" ]; then
			case "$remote" in
				origin/*)
					branch=${remote#origin/}
					remote=origin
					;;
				*)
					branch=$remote
					remote=origin
					;;
			esac
		fi
		exists=false
		for d in $repos; do
			enter "$d0/$d" verbose
			b=$branch
			if [ -n "$b" ] && git rev-parse "refs/heads/$b" >/dev/null 2>&1; then
				exists=true
				verbose git checkout $checkoutflags "$b"
			elif [ -n "$b" ] && git rev-parse "refs/remotes/$remote/$b" >/dev/null 2>&1; then
				exists=true
				verbose git checkout $checkoutflags --track -b "$b" "$remote/$b"
			else
				b=`repobranch "$d"`
				if git rev-parse "refs/heads/$b" >/dev/null 2>&1; then
					exists=true
					verbose git checkout $checkoutflags "$b"
				elif git rev-parse "refs/remotes/$remote/$b" >/dev/null 2>&1; then
					exists=true
					verbose git checkout $checkoutflags --track -b "$b" "$remote/$b"
				else
					echo "WTF? Not even branch $b doesn't exist in $d"
					exit 1
				fi
			fi
			cd "$d00"
			checkself "$cmd" "$@"
			cd "$d0"
		done
		if ! $exists; then
			echo "The requested branch was not found in any repository."
		fi
		exec "$SELF" branch
		;;
	branch)
		remote=$1
		branch=$2
		srcbranch=$3
		if [ -z "$branch" ]; then
			branch=$remote
			remote=origin
		fi
		if [ -z "$branch" ]; then
			for d in $repos; do
				enter "$d0/$d"
				r=`git symbolic-ref HEAD`
				r=${r#refs/heads/}
				echo "$d is at $r"
				cd "$d0"
			done
		else
			for d in $repos; do
				dv=`visible_repo_name "$d"`
				enter "$d0/$d" verbose
				if git rev-parse "refs/heads/$branch" >/dev/null 2>&1; then
					echo "Already having this branch in $dv."
				else
					if yesno "Branch in $dv?"; then
						if [ -n "$srcbranch" ]; then
							b=$srcbranch
						else
							b=origin/"`repobranch "$d"`"
							verbose git fetch origin || true
						fi
						# TODO do this without pushing
						verbose git checkout -b "$branch" "$b"
						verbose git config "branch.$branch.remote" "$remote"
						verbose git config "branch.$branch.merge" "refs/heads/$branch"
					fi
				fi
				cd "$d0"
			done
			"$SELF" branch
		fi
		;;
	branches)
		for d in $repos; do
			cd "$d0/$d" # am in a pipe, shouldn't use enter
			git branch -r -v -v | cut -c 3- | sed "s/^(no branch)/(no_branch)/" | sed "s,^,$d ,"
			cd "$d0"
		done | {
			branches_list=
			# branches_repos_*=
			while read -r d BRANCH REV TEXT; do
				if [ x"$BRANCH" = x"`repobranch "$d"`" ]; then
					continue
				fi
				if [ x"$REV" = x"->" ]; then
					continue
				fi
				BRANCH=${BRANCH#remotes/}
				ID=`echo "$BRANCH" | tr -c "A-Za-z0-9." "_"`
				branches_list="$branches_list $BRANCH" # TEH SORT MAKEZ IT UNIEQ
				eval "r=\$branches_repos_$ID"
				r="$r $d"
				eval "branches_repos_$ID=\$r"
			done
			echo -n "$branches_list" | xargs -n 1 echo | sort -u | while IFS= read -r BRANCH; do
				ID=`echo "$BRANCH" | tr -c "A-Za-z0-9." "_"`
				eval "r=\$branches_repos_$ID"
				printf "%-60s %s\n" "$BRANCH" "$r"
				#echo "$BRANCH: $r"
			done
		}
		;;
	merge)
		for d in $repos; do
			dv=`visible_repo_name "$d"`
			enter "$d0/$d" verbose
			r=`git symbolic-ref HEAD`
			r=${r#refs/heads/}
			if git log HEAD..origin/"`repobranch "$d"`" | grep .; then
				# we have uncommitted changes
				if yesno "Could merge from \"`repobranch "$d"`\" into \"$r\" in $dv. Do it?"; then
					if ! verbose git merge origin/"`repobranch "$d"`"; then
						check_mergeconflict "$d"
						exit 1 # this should ALWAYS be fatal
					fi
				fi
			fi
			cd "$d0"
		done
		;;
	push|commit)
		submit=$1
		for d in $repos; do
			dv=`visible_repo_name "$d"`
			enter "$d0/$d" verbose
			r=`git symbolic-ref HEAD`
			r=${r#refs/heads/}
			diffdata=`git diff --color HEAD`
			if [ -n "$diffdata" ]; then
				# we have uncommitted changes
				if yesno "Uncommitted changes in \"$r\" in $dv. Commit?" 'echo "$diffdata" | less -r'; then
					verbose git commit -a
				fi
			fi
			rem=`git config "branch.$r.remote" || echo origin`
			bra=`git config "branch.$r.merge" || echo "$r"`
			upstream="$rem/${bra#refs/heads/}"
			if ! git rev-parse "$upstream" >/dev/null 2>&1; then
				upstream="origin/`repobranch "$d"`"
			fi
			logdata=`git log --color "$upstream".."$r"`
			if [ -n "$logdata" ]; then
				if yesno "Push \"$r\" in $dv?" 'echo "$logdata" | less -r'; then
					verbose git push "$rem" HEAD
				fi
			fi
			if [ x"$submit" = x"-s" ]; then
				case "$r" in
					*/*)
						verbose git push "$rem" HEAD:"${bra%%/*}/finished/${bra#*/}"
						;;
				esac
			fi
			cd "$d0"
		done
		;;
	compile)
		if [ -z "$CC" ]; then
			export CC="gcc -DSUPPORTIPV6"
		fi
		if [ -n "$WE_HATE_OUR_USERS" ]; then
			TARGETS="sv-debug cl-debug"
		elif [ x"`uname`" = x"Darwin" ]; then
			case "`uname -r`" in
				?.*)
					TARGETS="sv-debug cl-debug sdl-debug"
					;;
				*)
					# AGL cannot be compiled on systems with a kernel > 10.x (Snow Leopard)
					TARGETS="sv-debug sdl-debug"
					;;
			esac
			export CC="$CC -I$PWD/misc/buildfiles/osx/Xonotic-SDL.app/Contents/Frameworks/SDL.framework/Headers -F$PWD/misc/buildfiles/osx/Xonotic-SDL.app/Contents/Frameworks"
		else
			TARGETS="sv-debug cl-debug sdl-debug"
		fi
		case "$1" in
			-c)
				cleandp=true
				cleanqcc=true
				cleanqc=true
				shift
				;;
			*)
				cleandp=false
				cleanqcc=false
				cleanqc=false
				;;
		esac
		if [ $# -gt 0 ] && [ x"$1" = x"" ]; then
			# if we give the command make the arg "", it will surely fail (invalid filename),
			# so better handle it as an empty client option
			BAD_TARGETS=" "
			shift
		elif [ -n "$1" ]; then
			BAD_TARGETS=
			TARGETS_SAVE=$TARGETS
			TARGETS=
			for X in $1; do
				case "$X" in
					sdl)
						TARGETS="$TARGETS sdl-debug"
						;;
					glx|agl|wgl)
						TARGETS="$TARGETS cl-debug"
						;;
					dedicated)
						TARGETS="$TARGETS sv-debug"
						;;
					*)
						BAD_TARGETS="$BAD_TARGETS $X"
						;;
				esac
			done
			if [ -n "$TARGETS" ]; then # at least a valid client
				shift
			else # no valid client, let's assume this option is not meant to be a client then
				TARGETS=$TARGETS_SAVE
				BAD_TARGETS=
			fi
		fi
		if [ -z "$MAKEFLAGS" ]; then
			if [ -f /proc/cpuinfo ]; then
				ncpus=$((`grep -c '^processor	:' /proc/cpuinfo`+0))
				if [ $ncpus -gt 1 ]; then
					MAKEFLAGS=-j$ncpus
				fi
			fi
			if [ -n "$WE_HATE_OUR_USERS" ]; then
				MAKEFLAGS="$MAKEFLAGS DP_MAKE_TARGET=mingw LIB_JPEG= CFLAGS_LIBJPEG="
			fi
		fi

		enter "$d0/fteqcc" verbose
		if $cleanqcc; then
			verbose make $MAKEFLAGS clean
		fi
		verbose make $MAKEFLAGS

		enter "$d0/data/xonotic-data.pk3dir" verbose
		if $cleanqc; then
			verbose make FTEQCC="$d0/fteqcc/fteqcc.bin" "$@" $MAKEFLAGS clean
		fi
		verbose make FTEQCC="$d0/fteqcc/fteqcc.bin" "$@" $MAKEFLAGS

		enter "$d0/darkplaces" verbose
		if [ x"$BAD_TARGETS" = x" " ]; then
			echo "Warning: invalid empty client, default clients will be used."
		fi
		if $cleandp; then
			verbose make $MAKEFLAGS clean
		fi
		for T in $TARGETS; do
			verbose make $MAKEFLAGS "$@" "$T"
		done
		for T in $BAD_TARGETS; do
			echo "Warning: discarded invalid client $T."
		done

		verbose "$SELF" update-maps
		;;
	run)
		if [ -n "$WE_HATE_OUR_USERS" ]; then
			client=
			export PATH="$d0/misc/buildfiles/win32:$PATH"
		elif [ x"`uname`" = x"Darwin" ]; then
			export DYLD_LIBRARY_PATH="$d0/misc/buildfiles/osx/Xonotic-SDL.app/Contents/MacOS"
			export DYLD_FRAMEWORK_PATH="$d0/misc/buildfiles/osx/Xonotic-SDL.app/Contents/Frameworks"
			client=-sdl
		else
			client=-sdl
		fi
		case "$1" in
			sdl|glx|agl|dedicated)
				client=-$1
				shift
				;;
			wgl)
				client=
				shift
				;;
		esac
		if ! [ -x "darkplaces/darkplaces$client" ]; then
			if [ -x "darkplaces/darkplaces$client.exe" ]; then
				client=$client.exe
			else
				echo "Client darkplaces/darkplaces$client not found, aborting"
				exit 1
			fi
		fi
		set -- "darkplaces/darkplaces$client" -xonotic -mygames "$@"

		# if pulseaudio is running: USE IT
		if [ -z "$SDL_AUDIODRIVER" ] && ! [ -n "$WE_HATE_OUR_USERS" ] && ! [ x"`uname`" = x"Darwin" ]; then
			if ps -C pulseaudio >/dev/null; then
				if ldd /usr/lib/libSDL.so 2>/dev/null | grep pulse >/dev/null; then
					export SDL_AUDIODRIVER=pulse
				fi
			fi
		fi

		binary=$1

		if [ -n "$USE_GDB" ]; then
			set -- gdb --args "$@"
		elif which gdb >/dev/null 2>&1; then
			set -- gdb --batch -x savecore.gdb --args "$@"
		elif which catchsegv >/dev/null 2>&1; then
			set -- catchsegv "$@"
		fi
		rm -f xonotic.core
		"$@" || true
		if [ -f xonotic.core ]; then
			if yesno "The program has CRASHED. Do you want to examine the core dump?"; then
				gdb "$binary" xonotic.core
			#elif yesno "You did not want to examine the core dump. Do you want to provide it - including your DarkPlaces checkout - to the Xonotic developers?"; then
			#	tar cvzf xonotic.core.tar.gz xonotic.core darkplaces/*.c darkplaces/*.h
			#	# somehow send it
			#	rm -f xonotic.core.tar.gz
			else
				echo "The core dump can be examined later by"
				echo "  gdb $binary xonotic.core"
			fi
		fi
		;;
	each|foreach)
		keep_going=false
		if [ x"$1" = x"-k" ]; then
			keep_going=true
			shift
		fi
		for d in $repos; do
			if verbose cd "$d0/$d"; then
				if $keep_going; then
					verbose "$@" || true
				else
					verbose "$@"
				fi
				cd "$d0"
			fi
		done
		;;
	save-patches)
		outfile=$1
		patchdir=`mktemp -d -t save-patches.XXXXXX`
		for d in $repos; do
			enter "$d0/$d" verbose
			git branch -v -v | cut -c 3- | {
				i=0
				while read -r BRANCH REV UPSTREAM TEXT; do
					case "$UPSTREAM" in
						\[*)
							UPSTREAM=${UPSTREAM#\[}
							UPSTREAM=${UPSTREAM%\]}
							UPSTREAM=${UPSTREAM%:*}
							TRACK=true
							;;
						*)
							UPSTREAM=origin/"`repobranch "$d"`"
							TRACK=false
							;;
					esac
					if [ x"$REV" = x"->" ]; then
						continue
					fi
					if git format-patch -o "$patchdir/$i" "$UPSTREAM".."$BRANCH"; then
						echo "$d" > "$patchdir/$i/info.txt"
						echo "$BRANCH" >> "$patchdir/$i/info.txt"
						echo "$UPSTREAM" >> "$patchdir/$i/info.txt"
						echo "$TRACK" >> "$patchdir/$i/info.txt"
						i=$(($i+1))
					else
						rm -rf "$patchdir/$i"
					fi
				done
			}
		done
		( cd "$patchdir" && tar cvzf - . ) > "$outfile"
		rm -rf "$patchdir"
		;;
	restore-patches)
		infile=$1
		patchdir=`mktemp -d -t restore-patches.XXXXXX`
		( cd "$patchdir" && tar xvzf - ) < "$infile"
		# detach the head
		for P in "$patchdir"/*/info.txt; do
			D=${P%/info.txt}
			exec 3<"$P"
			read -r d <&3
			read -r BRANCH <&3
			read -r UPSTREAM <&3
			read -r TRACK <&3
			verbose git checkout HEAD^0
			verbose git branch -D "$BRANCH"
			if [ x"$TRACK" = x"true" ]; then
				verbose git checkout --track -b "$BRANCH" "$UPSTREAM"
			else
				verbose git branch -b "$BRANCH" "$UPSTREAM"
			fi
			verbose git am "$D"
		done
		rm -rf "$patchdir"
		;;
	admin-merge)
		branch=$1
		t=`mktemp`
		report=""
		reportecho()
		{
			report=$report"$*$LF"
			echo "$*"
		}
		reportecho4()
		{
			report=$report"    $*$LF"
			echo "    $*"
		}
		reportdo4()
		{
			o=`"$@" | sed 's/^/    /' || true`
			reportecho "$o"
		}
		for d in $repos; do
			enter "$d0/$d" verbose
			base="`repobranch "$d"`"
			reportecho "In $d:"
			for ref in `git for-each-ref --format='%(refname)' refs/remotes/origin/`; do
				case "${ref#refs/remotes/origin/}" in
					"$base")
						continue
						;;
					HEAD|master)
						continue
						;;
					*/*)
						;;
					*)
						continue
						;;
				esac
				if [ -n "$branch" ]; then
					if [ x"$branch" != x"${ref#refs/remotes/origin/}" ]; then
						continue
					fi
				fi
				case "$base" in
					master)
						realbase=$base
						;;
					*)
						l0=`git rev-list "$base".."$ref" | wc -l`
						l1=`git rev-list master.."$ref" | wc -l`
						if [ $l0 -gt $l1 ]; then
							realbase=master
						else
							realbase=$base
						fi
						;;
				esac
				reportecho "  Branch $ref:"
				note=`GIT_NOTES_REF=refs/notes/admin-merge git notes show "$ref" 2>/dev/null || true`
				logdata=`git log --color "$realbase".."$ref"`
				if [ -z "$logdata" ]; then
					reportecho4 "--> not merging, no changes vs master"
					if yesno "Branch \"$ref\" probably should get deleted. Do it?" ''; then
						git push origin :"${ref#refs/remotes/origin/}"
						reportecho4 "--> branch deleted"
					fi
				else
					diffdata=`git diff --color --find-copies-harder --ignore-space-change "$realbase"..."$ref"`
					if [ -z "$diffdata" ]; then
						reportecho4 "--> not merging, no changes vs master, branch contains redundant history"
						if yesno "Branch \"$ref\" probably should get deleted. Do it?" '{ echo "$logdata"; } | less -r'; then
							git push origin :"${ref#refs/remotes/origin/}"
							reportecho4 "--> branch deleted"
						fi
					elif [ -z "$branch" ] && [ -n "$note" ]; then
						reportdo4 echo "$note"
						reportecho4 "--> not merging, already had this one rejected before"
					elif yesno "Branch \"$ref\" may want to get merged. Do it?" '{ echo "$logdata"; echo "$diffdata"; } | less -r'; then
						git checkout "$realbase"
						org=`git rev-parse HEAD`
						if ! git merge --no-ff "$ref" 2>&1 | tee "$t" && ! { git ls-files -u | grep ' 1	' >/dev/null; }; then
							git reset --hard "$org"
							GIT_NOTES_REF=refs/notes/admin-merge git notes edit -m "Merge failed:$LF`cat "$t"`" "$ref"
							reportdo4 cat "$t"
							reportecho4 "--> merge failed"
						elif ! "$SELF" compile 2>&1 | tee "$t"; then
							git reset --hard "$org"
							GIT_NOTES_REF=refs/notes/admin-merge git notes edit -m "Compile failed:$LF`cat "$t"`" "$ref"
							reportdo4 cat "$t"
							reportecho4 "--> compile failed"
						elif ! yesno "Still merge \"$ref\" into `git symbolic-ref HEAD` of $d? Maybe you want to test first."; then
							git reset --hard "$org"
							GIT_NOTES_REF=refs/notes/admin-merge git notes edit "$ref"
							note=`GIT_NOTES_REF=refs/notes/admin-merge git notes show "$ref" 2>/dev/null || true`
							if [ x"$note" = x"del" ]; then
								git push origin :"${ref#refs/remotes/origin/}"
								reportecho4 "--> test failed, branch deleted"
							elif [ -n "$note" ]; then
								reportdo4 echo "$note"
								reportecho4 "--> test failed"
							else
								reportecho4 "--> test failed, postponed"
							fi
						else
							echo "MERGING"
							case ",`repoflags "$d"`," in
								*,svn,*)
									# we do quite a mess here... luckily we know $org
									git fetch # svn needs to be current
									git rebase -i --onto origin/master "$org"
									git svn dcommit --add-author-from
									git reset --hard "$org"
									;;
								*)
									git push origin HEAD
									;;
							esac
							reportecho4 "--> MERGED"
							if yesno "Delete original branch \"$ref\"?"; then
								git push origin :"${ref#refs/remotes/origin/}"
								reportecho4 "--> branch deleted"
							fi
						fi
					else
						GIT_NOTES_REF=refs/notes/admin-merge git notes edit "$ref"
						note=`GIT_NOTES_REF=refs/notes/admin-merge git notes show "$ref" 2>/dev/null || true`
						if [ x"$note" = x"del" ]; then
							git push origin :"${ref#refs/remotes/origin/}"
							reportecho4 "--> branch deleted"
						elif [ -n "$note" ]; then
							reportdo4 echo "$note"
							reportecho4 "--> rejected"
						else
							reportecho4 "--> postponed"
						fi
					fi
				fi
				reportecho ""
			done
			reportecho ""
		done
		rm -f "$t"
		echo "$report" | ssh nexuiz@rm.endoftheinternet.org cat '>>' public_html/xonotic-merge-notes.txt
		;;
	clean)
		"$SELF" fix_config
		"$SELF" update -N
		force=false
		gotoupstream=false
		fetchupstream=false
		gotomaster=false
		rmuntracked=false
		killbranches=false
		# usage:
		#   ./all clean [-m] [-f | -fu | -fU] [-r] [-D]
		#   ./all clean --reclone
		found=false
		while :; do
			if [ x"$1" = x"--reclone" ]; then
				force=true
				fetchupstream=true
				gotoupstream=true
				gotomaster=true
				rmuntracked=true
				killbranches=true
			elif [ x"$1" = x"-f" ]; then
				force=true
			elif [ x"$1" = x"-u" ]; then
				gotoupstream=true
			elif [ x"$1" = x"-U" ]; then
				gotoupstream=true
				fetchupstream=true
			elif [ x"$1" = x"-fu" ]; then
				force=true
				gotoupstream=true
			elif [ x"$1" = x"-fU" ]; then
				force=true
				gotoupstream=true
				fetchupstream=true
			elif [ x"$1" = x"-m" ]; then
				gotomaster=true
			elif [ x"$1" = x"-r" ]; then
				rmuntracked=true
			elif [ x"$1" = x"-D" ]; then
				killbranches=true
			else
				break
			fi
			found=true
			shift
		done
		if ! $found; then
			rmuntracked=true
		fi
		for d in $repos; do
			verbose cd "$d0/$d"
			if $gotoupstream; then
				if ! $force; then
					msg "Must also use -f (delete local changes) when using -u"
					exit 1
				fi
				if $gotomaster; then
					if $fetchupstream; then
						verbose git fetch origin
						verbose git remote prune origin
					fi
					verbose git checkout -f "`repobranch "$d"`"
					verbose git reset --hard origin/"`repobranch "$d"`"
				else
					r=`git symbolic-ref HEAD`
					r=${r#refs/heads/}
					rem=`git config "branch.$r.remote" || echo origin`
					bra=`git config "branch.$r.merge" || echo "$r"`
					upstream="$rem/${bra#refs/heads/}"
					if $fetchupstream; then
						verbose git fetch "$rem"
						verbose git remote prune "$rem"
					fi
					if ! git rev-parse "$upstream" >/dev/null 2>&1; then
						upstream="origin/`repobranch "$d"`"
					fi
					verbose git reset --hard "$upstream"
				fi
			elif $gotomaster; then
				if $force; then
					verbose git checkout -f "`repobranch "$d"`"
					verbose git reset --hard
				else
					verbose git checkout "`repobranch "$d"`"
				fi
			elif $force; then
				verbose git reset --hard
			fi
			if $rmuntracked; then
				case "$d" in
					.)
						verbose git clean -df
						;;
					*)
						verbose git clean -xdf
						;;
				esac
			fi
			if $killbranches; then
				git for-each-ref --format='%(refname)' refs/heads/ | while IFS= read -r B; do
					if [ x"$B" != x"`git symbolic-ref HEAD`" ]; then
						verbose git branch -D "${B#refs/heads/}"
					fi
				done
			fi
		done
		;;

	# release building goes here
	release-prepare)
		#"$SELF" each git clean -fxd
		case "$RELEASETYPE" in
			beta)
				msg "Building a BETA"
				;;
			release)
				msg "Building a RELEASE"
				;;
			*)
				msg "Must either set RELEASETYPE=beta or RELEASETYPE=release"
				exit 1
				;;
		esac
		verbose rm -rf Xonotic Xonotic*.zip
		verbose mkdir -p Xonotic
		if [ -n "$RELEASEDATE" ]; then
			verbose echo "$RELEASEDATE" > Xonotic/stamp.txt
		else
			verbose date +%Y%m%d > Xonotic/stamp.txt
		fi
		verbose git archive --format=tar HEAD -- Docs misc server xonotic-linux-glx.sh xonotic-linux-sdl.sh misc/buildfiles | {
			verbose cd Xonotic
			verbose mkdir data fteqcc source source/darkplaces source/fteqcc
			verbose tar xvf -
			verbose rm -rf misc/builddeps
			verbose mv misc/buildfiles/win32/* . || true
			verbose mv misc/buildfiles/win64 bin64 || true
			verbose mv misc/buildfiles/osx/* . || true
			verbose rm -rf misc/buildfiles
		}
		{
			verbose cd darkplaces
			verbose git archive --format=tar HEAD
		} | {
			verbose cd Xonotic/source/darkplaces
			verbose tar xvf -
		}
		{
			verbose cd fteqcc
			verbose git archive --format=tar HEAD
		} | {
			verbose cd Xonotic/source/fteqcc
			verbose tar xvf -
		}
		{
			verbose cd data/xonotic-data.pk3dir
			verbose git archive --format=tar HEAD -- qcsrc Makefile
		} | {
			verbose cd Xonotic/source
			verbose tar xvf -
		}
		;;
	release-compile-run)
		host=$1
		buildpath=$2
		maketargets=$3
		makeflags=$4
		srcdir=$5
		depsdir=$6
		targetfiles=$7
		set -x
		if [ -n "$targetfiles" ]; then
			case " $HOSTS_THAT_ARE_DISABLED " in
				*\ $host\ *)
					exit
					;;
			esac
			case " $HOSTS_THAT_ARE_MYSELF " in
				*\ $host\ *)
					verbose rsync --delete -zLvaSHP "$srcdir"/ "$buildpath/"
					verbose rsync --delete -zLvaSHP "$depsdir"/ "$buildpath.deps/"
					verbose ln -snf "$buildpath.deps" "$buildpath/.deps"
					verbose eval make -C "$buildpath" clean $maketargets $makeflags
					for f in $targetfiles; do
						verbose mv "$buildpath/${f%:*}" "${f##*:}" || true
					done
					;;
				*)
					verbose rsync --delete -zLvaSHP "$srcdir"/ "$host:$buildpath/"
					verbose rsync --delete -zLvaSHP "$depsdir"/ "$host:$buildpath.deps/"
					verbose ssh "$host" "ln -snf $buildpath.deps $buildpath/.deps && cd $buildpath && nice -`nice` make clean $maketargets $makeflags"
					for f in $targetfiles; do
						verbose rsync -zvaSHP "$host:$buildpath/${f%:*}" "${f##*:}" || true
					done
					;;
			esac
			# now rebrand the binaries...
			for f in $targetfiles; do
				#verbose "$d0/misc/tools/rebrand-darkplaces-engine.sh" "${XONOTIC_BRAND:-$d0/misc/tools/xonotic.brand}" "${f##*:}" || true
				case "$f" in
					xonotic*.exe)
						verbose "$d0/misc/tools/change-icon-of-exe.sh" "$d0/misc/logos/icons_ico/xonotic.ico" "$f"
						(
							d=`mktemp -d -t rebrand.XXXXXX`
							cd "$d"
							echo "-mygames" > darkplaces.opt
							zip -9r darkplaces.zip darkplaces.opt
							cat darkplaces.zip
							cd "$d0"
							rm -rf "$d"
						) >> "$f"
						;;
				esac
			done
		fi
		;;
	release-compile)
		suffix=$1
		makeflags=$2
		fteqcc_maketargets=$3
		fteqcc_files=$4
		darkplaces_maketargets=$5
		darkplaces_files=$6
		host=xonotic-build-$suffix
		verbose "$SELF" release-compile-run "$host" /tmp/fteqcc.build."$suffix" "$fteqcc_maketargets" "$makeflags" "Xonotic/source/fteqcc" "$d0/misc/builddeps/dp.$suffix" "$fteqcc_files"
		verbose "$SELF" release-compile-run "$host" /tmp/Darkplaces.build."$suffix" "$darkplaces_maketargets" "$makeflags" "Xonotic/source/darkplaces" "$d0/misc/builddeps/dp.$suffix" "$darkplaces_files"
		;;
	release-engine-win32)
		verbose "$SELF" release-compile win32 \
			'STRIP=: DP_MAKE_TARGET=mingw CC="i586-mingw32msvc-gcc -g -Wl,--dynamicbase -Wl,--nxcompat -I.deps/include -L.deps/lib -DUSE_WSPIAPI_H -DSUPPORTIPV6" WINDRES="i586-mingw32msvc-windres" SDL_CONFIG=".deps/bin/sdl-config" LIB_JPEG= CFLAGS_LIBJPEG= WIN32RELEASE=1 D3D=0' \
			win 'fteqcc.exe:Xonotic/fteqcc/fteqcc.exe' \
			'' ''
		verbose "$SELF" release-compile win32 \
			'STRIP=: DP_MAKE_TARGET=mingw CC="i586-mingw32msvc-gcc -g -Wl,--dynamicbase -Wl,--nxcompat -I.deps/include -L.deps/lib -DUSE_WSPIAPI_H -DSUPPORTIPV6" WINDRES="i586-mingw32msvc-windres" SDL_CONFIG=".deps/bin/sdl-config" LIB_JPEG= CFLAGS_LIBJPEG= WIN32RELEASE=1 D3D=0' \
			'' '' \
			release 'darkplaces.exe:Xonotic/xonotic.exe darkplaces-sdl.exe:Xonotic/xonotic-sdl.exe darkplaces-dedicated.exe:Xonotic/xonotic-dedicated.exe'
		;;
	release-engine-win64)
		verbose "$SELF" release-compile win64 \
			'STRIP=: DP_MAKE_TARGET=mingw CC="amd64-mingw32msvc-gcc -g -Wl,--dynamicbase -Wl,--nxcompat -I.deps/include -L.deps/lib -DSUPPORTIPV6" WINDRES="amd64-mingw32msvc-windres" SDL_CONFIG=".deps/bin/sdl-config" LIB_JPEG= CFLAGS_LIBJPEG= WIN64RELEASE=1 D3D=0' \
			win 'fteqcc.exe:Xonotic/fteqcc/fteqcc-x64.exe' \
			'sv-release sdl-release' 'darkplaces-sdl.exe:Xonotic/xonotic-x64-sdl.exe darkplaces-dedicated.exe:Xonotic/xonotic-x64-dedicated.exe'
		verbose "$SELF" release-compile win64 \
			'STRIP=: DP_MAKE_TARGET=mingw CC="x86_64-w64-mingw32-gcc -g -Wl,--dynamicbase -Wl,--nxcompat -I.deps/include -L.deps/lib -DSUPPORTIPV6" WINDRES="x86_64-w64-mingw32-windres" SDL_CONFIG=".deps/bin/sdl-config" LIB_JPEG= CFLAGS_LIBJPEG= WIN64RELEASE=1 D3D=0' \
			'' '' \
			cl-release 'darkplaces.exe:Xonotic/xonotic-x64.exe'
		;;
	release-engine-osx)
		# gcc on OSX is buggy, needs -fno-reorder-blocks for a release build to succeed
		verbose "$SELF" release-compile osx \
			'STRIP=: CC="gcc -g -arch i386 -arch ppc -arch x86_64 -isysroot /Developer/SDKs/MacOSX10.5.sdk -mmacosx-version-min=10.4 -I.deps/include -L.deps/lib -fno-reorder-blocks -DSUPPORTIPV6"' \
			all 'fteqcc.bin:Xonotic/fteqcc/fteqcc.osx' \
			'sv-release sdl-release' 'darkplaces-sdl:Xonotic/Xonotic-SDL.app/Contents/MacOS/xonotic-osx-sdl-bin darkplaces-dedicated:Xonotic/xonotic-osx-dedicated'
		verbose "$SELF" release-compile osx \
			'STRIP=: CC="gcc -g -arch i386 -arch ppc -isysroot /Developer/SDKs/MacOSX10.5.sdk -mmacosx-version-min=10.4 -I.deps/include -L.deps/lib -fno-reorder-blocks -DSUPPORTIPV6"' \
			'' '' \
			'cl-release' 'darkplaces-agl:Xonotic/Xonotic.app/Contents/MacOS/xonotic-osx-agl-bin'
		;;
	release-engine-linux32)
		verbose "$SELF" release-compile linux32 \
			'STRIP=: CC="gcc -m32 -g -I.deps/include -L.deps/lib -DSUPPORTIPV6" DP_MODPLUG_STATIC_LIBDIR=.deps/lib LIB_JPEG=.deps/lib/libjpeg.a' \
			all 'fteqcc.bin:Xonotic/fteqcc/fteqcc.linux32' \
			release 'darkplaces-glx:Xonotic/xonotic-linux32-glx darkplaces-sdl:Xonotic/xonotic-linux32-sdl darkplaces-dedicated:Xonotic/xonotic-linux32-dedicated'
		;;
	release-engine-linux64)
		verbose "$SELF" release-compile linux64 \
			'STRIP=: CC="gcc -m64 -g -I.deps/include -L.deps/lib -DSUPPORTIPV6" DP_MODPLUG_STATIC_LIBDIR=.deps/lib LIB_JPEG=.deps/lib/libjpeg.a' \
			all 'fteqcc.bin:Xonotic/fteqcc/fteqcc.linux64' \
			release 'darkplaces-glx:Xonotic/xonotic-linux64-glx darkplaces-sdl:Xonotic/xonotic-linux64-sdl darkplaces-dedicated:Xonotic/xonotic-linux64-dedicated'
		;;
	release-engine)
		verbose "$SELF" release-engine-linux32 &
		verbose "$SELF" release-engine-linux64 &
		verbose "$SELF" release-engine-win32 &
		verbose "$SELF" release-engine-win64 &
		verbose "$SELF" release-engine-osx &
		wait %1
		wait %2
		wait %3
		wait %4
		wait %5
		wait
		;;
	release-maps)
		verbose "$SELF" update-maps
		;;
	release-qc)
		case "$RELEASETYPE" in
			beta)
				verbose make -C Xonotic/source FTEQCC="$d0/Xonotic/fteqcc/fteqcc.linux32" XON_BUILDSYSTEM=1 clean all
				;;
			release)
				verbose make -C Xonotic/source FTEQCC="$d0/Xonotic/fteqcc/fteqcc.linux32" XON_BUILDSYSTEM=1 FTEQCCFLAGS_WATERMARK= clean all
				;;
		esac
		verbose rm -f Xonotic/source/*/fteqcc.log
		;;
	release-buildpk3-transform-raw)
		dir=$1
		;;
	release-buildpk3-transform-normal)
		dir=$1
		verbose cd "$dir"
		# texture: convert to jpeg and dds
		verbose export do_jpeg=true
		verbose export jpeg_qual_rgb=95
		verbose export jpeg_qual_a=99
		verbose export do_dds=true
		verbose export dds_flags=
		verbose export do_ogg=false
		verbose export del_src=true
		find . -type f -print0 | verbose xargs -0 "$d0"/misc/tools/cached-converter.sh
		;;
	release-buildpk3-transform-low)
		dir=$1
		verbose cd "$dir"
		# texture: convert to jpeg and dds
		# music: reduce bitrate
		verbose export do_jpeg=true
		verbose export jpeg_qual_rgb=80
		verbose export jpeg_qual_a=95
		verbose export do_dds=false
		verbose export do_ogg=true
		verbose export ogg_qual=1
		verbose export del_src=true
		find . -type f -print0 | verbose xargs -0 "$d0"/misc/tools/cached-converter.sh
		;;
	release-buildpk3-transform-lowdds)
		dir=$1
		verbose cd "$dir"
		# texture: convert to jpeg and dds
		# music: reduce bitrate
		verbose export do_jpeg=false
		verbose export do_jpeg_if_not_dds=true
		verbose export jpeg_qual_rgb=80
		verbose export jpeg_qual_a=95
		verbose export do_dds=true
		verbose export dds_flags=
		verbose export do_ogg=true
		verbose export ogg_qual=1
		verbose export del_src=true
		find . -type f -print0 | verbose xargs -0 "$d0"/misc/tools/cached-converter.sh
		;;
	release-buildpk3)
		src=$1
		dst=$2
		transform=$3
		case "$dst" in
			/*)
				;;
			*/)
				dst="$PWD/$dst"
				;;
		esac
		verbose rm -rf Xonotic/temp
		verbose mkdir -p Xonotic/temp
		{
			verbose cd "$src"
			verbose git archive --format=tar HEAD
		} | {
			verbose cd Xonotic/temp
			verbose tar xvf -
		}
		verbose cd Xonotic/temp
		if [ x"$src" = x"data/xonotic-data.pk3dir" ]; then
			verbose cp ../source/progs.dat .
			verbose cp ../source/csprogs.dat .
			verbose cp ../source/menu.dat .
			verbose rm -rf qcsrc
			gv=`grep "^gameversion " "defaultXonotic.cfg" | awk '{ print $2 }'`
			major=$(($gv / 10000))
			minor=$(($gv / 100 - $major * 100))
			patch=$(($gv - $major * 10000 - $minor * 100))
			versionstr="$major.$minor.$patch"
			case "$RELEASETYPE" in
				beta)
					versionstr="$versionstr""beta"
					;;
			esac
			verbose sed -i "
				s/^set g_xonoticversion [^ ]* /set g_xonoticversion $versionstr /;
				s/^gameversion_min [0-9]*/gameversion_min $(( ($gv / 100) * 100 - 100 ))/;
				s/^gameversion_max [0-9]*/gameversion_max $(( ($gv / 100) * 100 + 199 ))/;
			" defaultXonotic.cfg
			(
				verbose cd gfx/menu/luminos
				verbose cp "$d0"/mediasource/gfx/menu/luminos_versionbuilder/background_l2.svg .
				verbose "$d0"/mediasource/gfx/menu/luminos_versionbuilder/versionbuilder "$versionstr"
				verbose rm background_l2.svg
			)
		fi
		if [ x"$src" = x"data/xonotic-maps.pk3dir" ]; then
			for X in ../../data/*-????????????????????????????????????????-????????????????????????????????????????.pk3; do
				if [ -f "$X" ]; then
					verbose unzip "$X"
					verbose rm -f maps/*.log maps/*.irc maps/*.lin
				fi
			done
		fi
		verbose export git_src_repo="$d0/$src" # skip hash-object
		verbose "$SELF" release-buildpk3-transform-$transform "Xonotic/temp"
		verbose mkzip "../../$dst" *
		verbose cd ../..
		verbose rm -rf Xonotic/temp
		;;
	release-buildpk3s)
		stamp=`cat Xonotic/stamp.txt`
		src=$1
		shift
		dst=${src%.pk3dir}
		case "$dst" in
			data/xonotic-*)
				dst="data/xonotic-$stamp-${dst#data/xonotic-}"
				;;
			*)
				dst="$dst-$stamp"
				;;
		esac
		while [ "$#" -gt 1 ]; do
			verbose "$SELF" release-buildpk3 "$src" "Xonotic/$dst$2.pk3" "$1"
			shift
			shift
		done
		;;
	release-pack)
		verbose "$SELF" release-buildpk3s data/font-nimbussansl.pk3dir             raw ''
		verbose "$SELF" release-buildpk3s data/xonotic-data.pk3dir       normal '' raw '-raw' low '-low' lowdds '-lowdds'
		verbose "$SELF" release-buildpk3s data/xonotic-maps.pk3dir       normal '' raw '-raw' low '-low' lowdds '-lowdds'
		verbose "$SELF" release-buildpk3s data/xonotic-music.pk3dir                raw ''     low '-low'
		verbose "$SELF" release-buildpk3s data/xonotic-nexcompat.pk3dir                       low ''
		;;
	release-pack-needsx11)
		case "$DISPLAY" in
			'')
				verbose startx "$SELF" release-pack -- /usr/bin/Xvfb :7
				;;
			*)
				verbose "$SELF" release-pack
				;;
		esac
		;;
	release-zip)
		stamp=`cat Xonotic/stamp.txt`
		# exe and dll files do not need +x, so this makes them eligible for 7zip compression too
		chmod a-x Xonotic/*.exe Xonotic/*.dll || true
		# need to use infozip for these (+x bits)
		verbose mkzip Xonotic-$stamp-engine.zip \
			Xonotic/*.dll \
			Xonotic/bin64/*.dll \
			Xonotic/*.app \
			Xonotic/xonotic-* \
			Xonotic/xonotic.exe \
			Xonotic/source/darkplaces/
		verbose cp Xonotic-$stamp-engine.zip Xonotic-$stamp-common.zip
		verbose mkzip Xonotic-$stamp-common.zip \
			Xonotic/source/fteqcc/ \
			Xonotic/source/qcsrc/ \
			Xonotic/Docs \
			Xonotic/misc \
			Xonotic/fteqcc \
			Xonotic/server \
			Xonotic/data/font-nimbussansl-$stamp.pk3
		verbose cp Xonotic-$stamp-common.zip Xonotic-$stamp.zip
		verbose mkzip0 Xonotic-$stamp.zip \
			Xonotic/data/xonotic-$stamp-data.pk3 \
			Xonotic/data/xonotic-$stamp-maps.pk3 \
			Xonotic/data/xonotic-$stamp-music.pk3 \
			Xonotic/data/xonotic-$stamp-nexcompat.pk3
		verbose cp Xonotic-$stamp-common.zip Xonotic-$stamp-low.zip
		verbose mkzip0 Xonotic-$stamp-low.zip \
			Xonotic/data/xonotic-$stamp-data-low.pk3 \
			Xonotic/data/xonotic-$stamp-maps-low.pk3 \
			Xonotic/data/xonotic-$stamp-music-low.pk3
		verbose cp Xonotic-$stamp-common.zip Xonotic-$stamp-lowdds.zip
		verbose mkzip0 Xonotic-$stamp-lowdds.zip \
			Xonotic/data/xonotic-$stamp-data-lowdds.pk3 \
			Xonotic/data/xonotic-$stamp-maps-lowdds.pk3 \
			Xonotic/data/xonotic-$stamp-music-low.pk3
		verbose mv Xonotic-$stamp-common.zip Xonotic-$stamp-high.zip
		verbose mkzip0 Xonotic-$stamp-high.zip \
			Xonotic/data/xonotic-$stamp-data-raw.pk3 \
			Xonotic/data/xonotic-$stamp-maps-raw.pk3 \
			Xonotic/data/xonotic-$stamp-music.pk3 \
			Xonotic/data/xonotic-$stamp-nexcompat.pk3
		;;
	release)
		verbose "$SELF" release-prepare
		verbose "$SELF" release-maps
		verbose "$SELF" release-engine
		verbose "$SELF" release-qc
		verbose "$SELF" release-pack-needsx11
		verbose "$SELF" release-zip
		;;

	*)
		echo "Usage:"
		echo "  $SELF admin-merge [<branch>]"
		echo "  $SELF branch <branch>"
		echo "  $SELF branch <remote> <branch> [<srcbranch>]"
		echo "  $SELF branches"
		echo "  $SELF checkout|switch <branch>"
		echo "  $SELF checkout|switch <remote>/<branch>"
		echo "  $SELF clean [-m] [-f | -fu | -fU] [-r] [-D]"
		echo "  $SELF clean --reclone"
		echo "  $SELF compile [-c]"
		echo "  $SELF each|foreach [-k] command..."
		echo "  $SELF fix_upstream_rebase"
		echo "  $SELF merge"
		echo "  $SELF push|commit [-s]"
		echo "  $SELF release"
		echo "  $SELF restore-patches"
		echo "  $SELF run [sdl|glx|wgl|agl|dedicated] options..."
		echo "  $SELF save-patches"
		echo "  $SELF update-maps"
		echo "  $SELF update|pull [-N]"
		;;
esac