shake

shake

(7880B)

 #!/usr/bin/env sh
 set -eu
 
 SHAKE_BIN="$0"
 TARGET=
 TARGET_ROUTE=
 SHAKEDIR=./.shake
 SHAKEFILE=$SHAKEDIR/local
 DIR=.
 OUTDIR=.
 NINJA_FILES=$SHAKEDIR/local.ninja
 GEN_FILES="./Shakefile $SHAKE_BIN"
 SHAKE_FORMAT=
 
 usage() {
 	printf "usage: shake [options] [directory]
   -C dir     change to dir before doing anything
   -o dir     set the output directory
   -h         show this help
 " >&2
 	exit 1
 }
 
 while [ $# -gt 0 ]; do
 	case "$1" in
 	-o)
 		[ $# -lt 2 ] && usage
 		OUTDIR="${2%/}"
 		shift 2
 		;;
 	-C)
 		[ $# -lt 2 ] && usage
 		cd "$2" 2>/dev/null || {
 			printf "shake: cannot change to directory: %s\n" "$2" >&2
 			exit 1
 		}
 		shift 2
 		;;
 	-h|--help)
 		usage
 		;;
 	-*)
 		printf "shake: unknown option: %s\n" "$1" >&2
 		usage
 		;;
 	*)
 		[ $# -gt 1 ] && usage
 		TARGET="$1"
 		shift
 		;;
 	esac
 done
 
 import() {
 	if [ ! -f "$DIR/$1" ]; then
 		error "import file does not exist: $DIR/$1"
 	fi
 	GEN_FILES="$GEN_FILES $DIR/$1"
 	. $DIR/$1
 }
 
 set_target_route() {
 	TARGET_ROUTE="$TARGET_ROUTE $1"
 	if [ $1 = . ]; then return; fi
 	set_target_route $(dirname $1)
 }
 
 in_target_route() {
 	[ ! "$TARGET" ] || has $DIR/$1 $TARGET_ROUTE
 }
 
 _shake_open() {
 	_f=$SHAKEFILE
 
 	if [ ! "$TARGET" ] || [ $TARGET = "$DIR" ]; then
 		mkdir -p $SHAKEDIR
 		exec 3> $_f.ninja.tmp
 		exec 4> $_f.ins.tmp
 		exec 5> $_f.out.tmp
 	else
 		exec 3> /dev/null
 		exec 4> /dev/null
 		exec 5> /dev/null
 	fi
 }
 
 _shake_close() {
 	_f=$SHAKEFILE
 
 	exec 4>&-
 	exec 5>&-
 	wait
 
 	if [ ! "$TARGET" ] || [ $TARGET = "$DIR" ]; then
 		sort -u $_f.ins.tmp -o $_f.ins
 		sort -u $_f.out.tmp -o $_f.out
 		rm -f $_f.ins.tmp
 		rm -f $_f.out.tmp
 
 		if [ "${SHAKE_GROUPIN-}" ]; then
 			set -- $SHAKE_GROUPIN
 			while [ "${1-}" ] && [ "${2-}" ]; do
 				if grep -E "$2" $_f.ins 2>/dev/null >$SHAKEDIR/$1.ins; then
 					printf 'build ' >&3
 					cat $SHAKEDIR/$1.ins | tr '\n' ' ' >&3
 					printf ': phony $dir/%s\n' "$1" >&3
 				fi
 				shift 2
 			done
 			unset -v SHAKE_GROUPIN
 		fi
 
 		if [ "${SHAKE_GROUPOUT-}" ]; then
 			set -- $SHAKE_GROUPOUT
 			while [ "${1-}" ] && [ "${2-}" ]; do
 				if grep -E "$2" $_f.out 2>/dev/null >$SHAKEDIR/$1.out; then
 					printf 'build $dir/%s: phony ' "$1" >&3
 					cat $SHAKEDIR/$1.out | tr '\n' ' ' >&3
 					printf '\n' >&3
 				fi
 				shift 2
 			done
 			unset -v SHAKE_GROUPOUT
 		fi
 
 		printf 'build %s: gen | %s\n' "$shakedir/local.ninja $shakedir/local.ins $shakedir/local.out" "$GEN_FILES" >&3
 		bind description SHAKE $dir
 		printf 'build $dir/ninja: phony %s\n' "$NINJA_FILES" >&3
 	fi
 
 	exec 3>&-
 	wait
 
 	if [ ! "$TARGET" ] || [ $TARGET = "$DIR" ]; then
 		if cmp -s $_f.ninja.tmp $_f.ninja; then
 			rm -f $_f.ninja.tmp
 		else
 			mv $_f.ninja.tmp $_f.ninja
 		fi
 	fi
 }
 
 sub() {
 	printf 'subninja %s/%s.ninja\n' "$SHAKEDIR" "$1" >&3
 	SHAKEFILE=$SHAKEDIR/local
 	_shake_open
 	[ "${2-}" ] && eval "$2 $1"
 	$1
 	[ "${3-}" ] && eval "$3 $1"
 	_shake_close
 }
 
 shake() {
 	printf 'subninja %s/%s/local.ninja\n' "$SHAKEDIR" "$1" >&3
 	NINJA_FILES="$NINJA_FILES $dir/$1/ninja"
 
 	if in_target_route $1; then
 		{
 			DIR=$DIR/$1
 			OUTDIR=$OUTDIR/$1
 			SHAKEDIR=$SHAKEDIR/$1
 			SHAKEFILE=$SHAKEDIR/local
 			GEN_FILES="$GEN_FILES $DIR/Shakefile"
 			NINJA_FILES=$shakedir/local.ninja
 
 			_shake_open
 			let dir	$dir/$1
 			let outdir $outdir/$1
 			let shakedir $shakedir/$1
 
 			[ "${2-}" ] && eval "$2 $1"
 			. $DIR/Shakefile
 			[ "${2-}" ] && eval "$3 $1"
 			_shake_close
 		} &
 	fi
 }
 
 let() {
 	printf '%s =' "$1" >&3
 	for _v in ${*:2}; do
 		printf ' %s' "$_v" >&3
 	done
 	printf '\n' >&3
 	eval "$1='\$$1'"
 }
 
 bind() {
 	printf '    %s =' "$1" >&3
 	if [ "$1" == description ] && [ -n "$SHAKE_FORMAT" ]; then
 		printf "$SHAKE_FORMAT\n" "$2" "${*:3}" | sed 's| |$ |g' >&3
 	else
 		for _v in ${*:2}; do
 			printf ' %s' "$_v" >&3
 		done
 		printf '\n' >&3
 	fi
 }
 
 _shake_prefix() {
 	case "$2" in
 	'$'*|'./'*|'../'*|'/'*)
 		printf ' %s' "$2" >&3
 		case "$1" in
 		$dir)    printf '%s\n' "$2" >&4;;
 		$outdir) printf '%s\n' "$2" >&5;;
 		esac
 		;;
 	*)
 		printf ' %s/%s' "$1" "$2" >&3
 		case "$1" in
 		$dir)    printf '$dir/%s\n' "$2" >&4;;
 		$outdir) printf '$outdir/%s\n' "$2" >&5;;
 		esac
 		;;
 	esac
 }
 
 _shake_build() {
 	_mode=bout
 	printf 'build' >&3
 	for _v in $*; do
 		case "$_v" in
 		'-')
 			case "$_mode" in
 			bout) printf ': %s |' $_brule >&3;;
 			bin)  printf ' |' >&3;;
 			bord) error 'invalid rule';;
 			esac
 			_mode=bdep
 			;;
 		'--')
 			case "$_mode" in
 			bout) printf ': %s ||' $_brule >&3;;
 			bin|bdep)  printf ' ||' >&3;;
 			esac
 			_mode=bord
 			;;
 		*:*)
 			if [ "$_mode" != bout ]; then
 				error 'invalid rule'
 			fi
 			if [ "${_v%%:*}" ]; then
 				_shake_prefix $_pre "${_v%%:*}"
 			fi
 
 			printf ': %s' $_brule >&3
 			_mode=bin
 			[ "$_pre" == $dir ] && _pre=$outdir || _pre=$dir
 
 			if [ "${_v##*:}" ]; then
 				_shake_prefix $_pre "${_v##*:}"
 			fi
 			;;
 		*)
 			_shake_prefix $_pre "$_v"
 			;;
 		esac
 	done
 	printf '\n' >&3
 
 }
 
 build() {
 	_brule=$1
 	_pre=$outdir
 	_shake_build ${*:2}
 }
 
 phony() {
 	_brule=phony
 	_pre=$dir
 	_shake_build $*
 }
 
 _shake_requires_arg() {
 	case "$2" in
 	*"$1:"*) return 0;;
 	*) return 1;;
 	esac
 }
 
 _shake_parse_args() {
 	_optstring="$1"
 	shift
 
 	_opts=
 	_deps=
 	_optshift=0
 	_optcnt=$#
 
 	while [ $# -gt 0 ]; do
 		case "$1" in
 		-*)
 			_optflag="${1#-}"
 			if _shake_requires_arg "$_optflag" "$_optstring"; then
 				_optval="$2"
 				case "$_optval" in
 				\$*dir/*)
 					if [ -z "$_deps" ]; then
 						_deps='-'
 					fi
 					_deps="$_deps $_optval"
 					;;
 				esac
 				shift 2
 			else
 				_optval=
 				shift 1
 			fi
 			[ -n "$_optval" ] && _opts="$_opts -$_optflag $_optval" || _opts="$_opts -$_optflag"
 			;;
 		*)
 			break
 			;;
 		esac
 	done
 
 	_optrem=$#
 	_optshift=$(( _optcnt - _optrem ))
 }
 
 rule() {
 	_r=$1
 	shift
 	printf 'rule %s\n' "$_r" >&3
 
 	_optstring=
 	if [ "$1" == '-o' ]; then
 		_optstring="$2"
 		shift 2
 	fi
 
 	bind command "$*"
 
 	_d=
 	for _v in $*; do
 		case "$_v" in
 		\$*dir/*|/*|./*|../*) _d="${_d:-'-'} $_v";;
 		esac
 	done
 
 	if [ -z "$_optstring" ]; then
 		eval "$_r() { build $_r \$* $_d; }"
 	else
 		eval "$_r() { _shake_parse_args '$_optstring' \$*; shift \$_optshift; build $_r \$* \$_deps $_d; bind opts \"\$_opts\"; }"
 	fi
 }
 
 default() {
 	printf 'default' >&3
 	for _v in $*; do
 		_shake_prefix $dir "$_v"
 	done
 	printf '\n' >&3
 }
 
 groupin() {
 	SHAKE_GROUPIN="${SHAKE_GROUPIN-} $1 $2"
 }
 
 groupout() {
 	SHAKE_GROUPOUT="${SHAKE_GROUPOUT-} $1 $2"
 }
 
 error() {
 	printf "shake: %s: %s\n" "$DIR" "$*" >&2
 	exit 1
 }
 
 has() {
 	_val=$1
 	shift
 	for _v in $*; do
 		if [ $_v = $_val ]; then
 			return 0
 		fi
 	done
 	return 1
 }
 
 genfile() {
 	_f="$1"
 	case "$_f" in
 	$dir/*)    _f="$DIR/${_f#*/}";;
 	$outdir/*) _f="$OUTDIR/${_f#*/}";;
 	esac
 	GEN_FILES="$GEN_FILES $_f"
 }
 
 foreach() {
 	while read -r line; do
 		$2 $line
 	done <$DIR/$1
 	genfile "$DIR/$1"
 }
 
 if [ "$TARGET" ] && [ ! -f "$TARGET/Shakefile" ]; then
 	printf "shake: target is missing Shakefile: %s\n" "$TARGET" >&2
 	exit 1
 fi
 
 # recursively check if there's a build directory
 PWD="$(pwd)"
 ROOTDIR="$PWD"
 while [ ! -d "$ROOTDIR/$SHAKEDIR" ]; do
 	if [ ! "$ROOTDIR" ]; then
 		ROOTDIR="$(pwd)"
 		break
 	fi
 
 	ROOTDIR="${ROOTDIR%/*}"
 done
 
 if [ "$ROOTDIR" != "$PWD" ]; then
 	if [ "$TARGET" ]; then
 		TARGET="${PWD#$ROOTDIR}/$TARGET"
 	fi
 	cd "$ROOTDIR" 2>/dev/null || {
 		printf "shake: cannot change to root directory: %s\n" "$ROOTDIR" >&2
 		exit 1
 	}
 	PWD="$(pwd)"
 fi
 
 if [ ! -f Shakefile ]; then
 	printf "shake: cannot find %s/Shakefile\n" "$PWD" >&2
 	exit 1
 fi
 
 if [ "$TARGET" ]; then
 	TARGET="$(cd "${TARGET#/}" && pwd)"
 	case "$TARGET" in
 	$PWD)	TARGET=.;;
 	$PWD/*) TARGET="./${TARGET#$PWD/}";;
 	esac
 	set_target_route $TARGET
 fi
 
 in='$in'
 out='$out'
 opts='$opts'
 
 _shake_open
 let ninja_required_version 1.8
 let builddir $SHAKEDIR
 let dir	$DIR
 let outdir $OUTDIR
 let shakedir $SHAKEDIR
 
 rule gen "$SHAKE_BIN $dir"
 bind generator 1
 bind restat 1
 
 . $DIR/Shakefile
 
 phony build.ninja: $dir/ninja
 bind generator 1
 _shake_close
 
 if [ ! -L build.ninja ]; then
 	rm -f build.ninja
 	ln -s $SHAKEDIR/local.ninja build.ninja
 fi