diff options
Diffstat (limited to 'build3')
| -rwxr-xr-x | build3 | 182 |
1 files changed, 182 insertions, 0 deletions
diff --git a/build3 b/build3 new file mode 100755 index 00000000..9c125c57 --- /dev/null +++ b/build3 @@ -0,0 +1,182 @@ +#!/bin/sh +# Alternative to build2 that can stop after any step. For example: +# $ ./build3 mu.cc + +set -e # stop immediately on error + +# Some environment variables that can be passed in. For example, to turn off +# optimization: +# $ CFLAGS=-g ./build0 +test "$CXX" || export CXX=c++ +test "$CC" || export CC=cc +test "$CFLAGS" || export CFLAGS="-g -O3" +export CFLAGS="$CFLAGS -Wall -Wextra -ftrapv -fno-strict-aliasing" + +# Outline: +# [0-9]*.cc -> mu.cc -> .build/*.cc -> .build/*.o -> .build/mu_bin +# (layers) | | | | +# tangle cleave $CXX $CXX + +## arg parsing + +# can be called with a target to stop after a partial build +# $ ./build3 mu.cc +# can also be called with a layer to only build until +# $ ./build3 --until 050 +# scenarios: +# ./build3 => TARGET= UNTIL_LAYER=zzz +# ./build3 x => TARGET=x UNTIL_LAYER=zzz +# ./build3 --until => TARGET= UNTIL_LAYER=zzz +# ./build3 --until 050 => TARGET= UNTIL_LAYER=050 +TARGET= +UNTIL_LAYER=zzz +if [ $# -ge 1 ] && [ $1 != "--until" ] +then + TARGET=$1 +fi +if [ $# -ge 2 ] && [ $1 = "--until" ] +then + UNTIL_LAYER=$2 +fi + +## + +# there's two mechanisms for fast builds here: +# - if a command is quick to run, always run it but update the result only on any change +# - otherwise run it only if the output is 'older_than' the inputs +# +# avoid combining both mechanisms for a single file +# otherwise you'll see spurious messages about files being updated +# risk: a file may unnecessarily update without changes, causing unnecessary work downstream + +# return 1 if $1 is older than _any_ of the remaining args +# also exit the entire script if previous invocation was to update $TARGET +older_than() { + test $TARGET && test "$last_target" = "$TARGET" && exit 0 + local target=$1 + shift + last_target=$target + if [ ! -e $target ] + then +#? echo "$target doesn't exist" + echo "updating $target" >&2 + return 0 # success + fi + local f + for f in $* + do + if [ $f -nt $target ] + then + echo "updating $target" >&2 + return 0 # success + fi + done + return 1 # failure +} + +# redirect to $1, unless it's already identical +# no point checking for an early exit, because this usually runs in a pipeline/subshell +update() { + if [ ! -e $1 ] + then + cat > $1 + else + cat > $1.tmp + diff -q $1 $1.tmp >/dev/null && rm $1.tmp || mv $1.tmp $1 + fi +} + +# cp file $1 to directory $2, unless it's already identical +# also exit the entire script if previous invocation was to update $TARGET +update_cp() { + test $TARGET && test "$last_target" = "$TARGET" && exit 0 + last_target=$2/$1 + if [ ! -e $2/$1 ] + then + cp $1 $2 + elif [ $1 -nt $2/$1 ] + then + cp $1 $2 + fi +} + +noisy_cd() { + cd $1 + echo "-- `pwd`" >&2 +} + +older_than enumerate/enumerate enumerate/enumerate.cc && { + $CXX $CFLAGS enumerate/enumerate.cc -o enumerate/enumerate +} + +older_than tangle/tangle tangle/*.cc && { + noisy_cd tangle + { + grep -h "^struct .* {" [0-9]*.cc |sed 's/\(struct *[^ ]*\).*/\1;/' + grep -h "^typedef " [0-9]*.cc + } |update type_list + grep -h "^[^ #].*) {" [0-9]*.cc |sed 's/ {.*/;/' |update function_list + ls [0-9]*.cc |grep -v "\.test\.cc$" |sed 's/.*/#include "&"/' |update file_list + ls [0-9]*.test.cc |sed 's/.*/#include "&"/' |update test_file_list + grep -h "^[[:space:]]*void test_" [0-9]*.cc |sed 's/^\s*void \(.*\)() {$/\1,/' |update test_list + $CXX $CFLAGS boot.cc -o tangle + noisy_cd .. # no effect; just to show us returning to the parent directory +} + +LAYERS=$(./enumerate/enumerate --until $UNTIL_LAYER |grep '\.cc$') +older_than mu.cc $LAYERS enumerate/enumerate tangle/tangle && { + # no update here; rely on 'update' calls downstream + ./tangle/tangle $LAYERS > mu.cc +} + +older_than cleave/cleave cleave/cleave.cc && { + $CXX -O3 -Wall -Wextra -fno-strict-aliasing cleave/cleave.cc -o cleave/cleave + rm -rf .build +} + +mkdir -p .build +grep -h "^[^[:space:]#].*) {$" mu.cc |grep -v ":.*(" |sed 's/ {.*/;/' |update .build/function_list +grep -h "^\s*void test_" mu.cc |sed 's/^\s*void \(.*\)() {.*/\1,/' |update .build/test_list +mkdir -p .build/termbox +update_cp termbox/termbox.h .build/termbox + +older_than mu_bin mu.cc *_list cleave/cleave termbox/* && { + ./cleave/cleave mu.cc .build + noisy_cd .build + grep ';' global_definitions_list |sed 's/[=(].*/;/' |sed 's/^[^\/# ]/extern &/' |sed 's/^extern extern /extern /' |update global_declarations_list + for f in mu_*.cc + do + older_than `echo $f |sed 's/\.cc$/.o/'` $f header global_declarations_list function_list test_list && { + $CXX $CFLAGS -c $f + } + done + noisy_cd ../termbox + older_than utf8.o utf8.c && { + $CC $CFLAGS -c utf8.c + } + older_than termbox.o termbox.c termbox.h input.inl output.inl bytebuffer.inl && { + $CC $CFLAGS -c termbox.c + } + older_than libtermbox.a *.o && { + ar rcs libtermbox.a *.o + } + noisy_cd .. + $CXX $CFLAGS .build/*.o termbox/libtermbox.a -o .build/mu_bin + cp .build/mu_bin . +} + +## [0-9]*.mu -> core.mu + +MU_LAYERS=$(./enumerate/enumerate --until $UNTIL_LAYER |grep '\.mu$') || exit 0 # ok if no .mu files +cat $MU_LAYERS |update core.mu + +exit 0 + +# scenarios considered: +# 0 status when nothing needs updating +# no output when nothing needs updating +# no output for mu.cc when .mu files modified +# touch mu.cc but don't modify it; no output on second build +# touch a .cc layer but don't modify it; no output on second build +# only a single layer is recompiled when changing a C++ function +# stop immediately after failure in tangle |