#!/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 ./build3 test "$CXX" || export CXX=c++ test "$CC" || export CC=cc test "$CFLAGS" || export CFLAGS="-g -O2" 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 # auto-generate various lists (ending in '_list' by convention) { # list of types { grep -h "^struct .* {" [0-9]*.cc |sed 's/\(struct *[^ ]*\).*/\1;/' grep -h "^typedef " [0-9]*.cc } |update type_list # list of function declarations, so I can define them in any order grep -h "^[^ #].*) {" [0-9]*.cc |sed 's/ {.*/;/' |update function_list # list of code files to compile ls [0-9]*.cc |grep -v "\.test\.cc$" |sed 's/.*/#include "&"/' |update file_list # list of test files to compile ls [0-9]*.test.cc |sed 's/.*/#include "&"/' |update test_file_list # list of tests to run grep -h "^[[:space:]]*void test_" [0-9]*.cc |sed 's/^\s*void \(.*\)() {$/\1,/' |update test_list grep -h "^\s*void test_" [0-9]*.cc |sed 's/^\s*void \(.*\)() {.*/"\1",/' |update test_name_list # } # Now that we have all the _lists, compile 'tangle' $CXX $CFLAGS boot.cc -o tangle ./tangle test 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 && { #