diff options
| -rw-r--r-- | .travis.yml | 1 | ||||
| -rw-r--r--[-rwxr-xr-x] | build0 | 35 | ||||
| -rw-r--r--[-rwxr-xr-x] | build1 | 165 | ||||
| -rwxr-xr-x | build2 | 39 | ||||
| -rwxr-xr-x | build3 | 182 | ||||
| -rwxr-xr-x | build_and_test_until | 2 | ||||
| -rwxr-xr-x | mu | 2 | ||||
| -rwxr-xr-x | test_layers | 2 |
8 files changed, 230 insertions, 198 deletions
diff --git a/.travis.yml b/.travis.yml index 3093955c..17aeee0a 100644 --- a/.travis.yml +++ b/.travis.yml @@ -33,6 +33,7 @@ matrix: - env: COMMAND=./subx/test_layers - env: COMMAND=./test_layers BUILD=build0 START=one-off - env: COMMAND=./test_layers BUILD=build1 START=one-off + - env: COMMAND=./test_layers BUILD=build2 START=one-off script: - $COMMAND $START $END diff --git a/build0 b/build0 index 4eda5e8c..20344bdf 100755..100644 --- a/build0 +++ b/build0 @@ -4,25 +4,6 @@ set -v 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 -> mu_bin -# (layers) | | -# tangle $CXX - -# can also be called with a layer to only build until -# $ ./build0 --until 050 -UNTIL_LAYER=${2:-zzz} - -$CXX $CFLAGS enumerate/enumerate.cc -o enumerate/enumerate - cd tangle { grep -h "^struct .* {" [0-9]*.cc |sed 's/\(struct *[^ ]*\).*/\1;/' @@ -32,22 +13,18 @@ cd tangle ls [0-9]*.cc |grep -v "\.test\.cc$" |sed 's/.*/#include "&"/' > file_list ls [0-9]*.test.cc |sed 's/.*/#include "&"/' > test_file_list grep -h "^[[:space:]]*void test_" [0-9]*.cc |sed 's/^\s*void \(.*\)() {$/\1,/' > test_list - $CXX $CFLAGS boot.cc -o tangle + g++ -g -O3 boot.cc -o tangle cd .. cd termbox - $CC $CFLAGS -c termbox.c - $CC $CFLAGS -c utf8.c + gcc -g -O3 -c termbox.c + gcc -g -O3 -c utf8.c ar rcs libtermbox.a *.o cd .. -LAYERS=$(./enumerate/enumerate --until $UNTIL_LAYER |grep '\.cc$') -./tangle/tangle $LAYERS > mu.cc +./tangle/tangle [0-9]*.cc > mu.cc grep -h "^[^[:space:]#].*) {$" mu.cc |grep -v ":.*(" |sed 's/ {.*/;/' > function_list grep -h "^\s*void test_" mu.cc |sed 's/^\s*void \(.*\)() {.*/\1,/' > test_list -$CXX $CFLAGS mu.cc termbox/libtermbox.a -o mu_bin - -## [0-9]*.mu -> core.mu +g++ -g -O3 mu.cc termbox/libtermbox.a -o mu_bin -MU_LAYERS=$(./enumerate/enumerate --until $UNTIL_LAYER |grep '\.mu$') || exit 0 # ok if no .mu files -cat $MU_LAYERS > core.mu +cat [0-9]*.mu > core.mu diff --git a/build1 b/build1 index 2da95706..2419ce4a 100755..100644 --- a/build1 +++ b/build1 @@ -1,157 +1,54 @@ #!/bin/sh -# Alternative to build0 that tries to avoid redoing redundant work. -# Also splits compilation into multiple .cc files (see 'cleave' below). -# Faster than build0 for recompiling after small changes. -# -# For details on the basic form of this script, see https://notabug.org/akkartik/basic-build. +# Alternative to build0 that supports a --until flag to include only a subset +# of layers. +set -v set -e # stop immediately on error # Some environment variables that can be passed in. For example, to turn off # optimization: -# $ CFLAGS=-g ./build0 +# $ CFLAGS=-g ./build1 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 +# [0-9]*.cc -> mu.cc -> mu_bin +# (layers) | | +# tangle $CXX # can also be called with a layer to only build until # $ ./build1 --until 050 UNTIL_LAYER=${2:-zzz} -# 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 -older_than() { - local target=$1 - shift - 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 -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 -} - -update_cp() { - 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 -} +$CXX $CFLAGS enumerate/enumerate.cc -o enumerate/enumerate + +cd tangle + { + grep -h "^struct .* {" [0-9]*.cc |sed 's/\(struct *[^ ]*\).*/\1;/' + grep -h "^typedef " [0-9]*.cc + } > type_list + grep -h "^[^ #].*) {" [0-9]*.cc |sed 's/ {.*/;/' > function_list + ls [0-9]*.cc |grep -v "\.test\.cc$" |sed 's/.*/#include "&"/' > file_list + ls [0-9]*.test.cc |sed 's/.*/#include "&"/' > test_file_list + grep -h "^[[:space:]]*void test_" [0-9]*.cc |sed 's/^\s*void \(.*\)() {$/\1,/' > test_list + $CXX $CFLAGS boot.cc -o tangle +cd .. + +cd termbox + $CC $CFLAGS -c termbox.c + $CC $CFLAGS -c utf8.c + ar rcs libtermbox.a *.o +cd .. 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 . -} +./tangle/tangle $LAYERS > mu.cc +grep -h "^[^[:space:]#].*) {$" mu.cc |grep -v ":.*(" |sed 's/ {.*/;/' > function_list +grep -h "^\s*void test_" mu.cc |sed 's/^\s*void \(.*\)() {.*/\1,/' > test_list +$CXX $CFLAGS mu.cc termbox/libtermbox.a -o 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 +cat $MU_LAYERS > core.mu diff --git a/build2 b/build2 index 8cddd67f..881f2702 100755 --- a/build2 +++ b/build2 @@ -1,12 +1,15 @@ #!/bin/sh -# Alternative to build1 that can stop after any step. For example: -# $ ./build2 mu.cc +# Alternative to build1 that tries to avoid redoing redundant work. +# Also splits compilation into multiple .cc files (see 'cleave' below). +# Faster than build1 for recompiling after small changes. +# +# For details on the basic form of this script, see https://notabug.org/akkartik/basic-build. set -e # stop immediately on error # Some environment variables that can be passed in. For example, to turn off # optimization: -# $ CFLAGS=-g ./build0 +# $ CFLAGS=-g ./build2 test "$CXX" || export CXX=c++ test "$CC" || export CC=cc test "$CFLAGS" || export CFLAGS="-g -O3" @@ -17,29 +20,9 @@ export CFLAGS="$CFLAGS -Wall -Wextra -ftrapv -fno-strict-aliasing" # (layers) | | | | # tangle cleave $CXX $CXX -## arg parsing - -# can be called with a target to stop after a partial build -# $ ./build2 mu.cc # can also be called with a layer to only build until # $ ./build2 --until 050 -# scenarios: -# ./build2 => TARGET= UNTIL_LAYER=zzz -# ./build2 x => TARGET=x UNTIL_LAYER=zzz -# ./build2 --until => TARGET= UNTIL_LAYER=zzz -# ./build2 --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 - -## +UNTIL_LAYER=${2:-zzz} # 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 @@ -50,12 +33,9 @@ fi # 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" @@ -75,7 +55,6 @@ older_than() { } # 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 @@ -86,11 +65,7 @@ update() { 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 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 diff --git a/build_and_test_until b/build_and_test_until index a1cc7d51..93c17ef2 100755 --- a/build_and_test_until +++ b/build_and_test_until @@ -2,4 +2,4 @@ set -e ./clean top-level -./build1 --until $1 && ./mu_bin test +./build3 --until $1 && ./mu_bin test diff --git a/mu b/mu index 41c98ce8..fa09f53a 100755 --- a/mu +++ b/mu @@ -2,7 +2,7 @@ # Run interpreter, first compiling if necessary. set -e -./build1 && ./mu_bin "$@" +./build3 && ./mu_bin "$@" # Scenarios considered: # mu diff --git a/test_layers b/test_layers index d23776da..9cbc12e5 100755 --- a/test_layers +++ b/test_layers @@ -15,7 +15,7 @@ # test_layers app set -e -test "$BUILD" || export BUILD=build1 +test "$BUILD" || export BUILD=build3 if [[ $1 == one-off ]] then |