4219 - add an even simpler build script

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