using SRC instead of *.c - suckless/dwm - Unnamed repository; edit this file 'description' to name the repository.

diff options

author	arg@10ksloc.org <unknown>	2006-08-03 11:27:29 +0200
committer	arg@10ksloc.org <unknown>	2006-08-03 11:27:29 +0200
commit	7315bb08ad45e163dbf110b92f8f9f5d392d96e2 (patch)
tree	f4c181e95f22527c4d0e6a499cf2a72c0e3cb77f /dwm.1
parent	f80688f1c79ae813965c7c9cac35931a07c4cc90 (diff)
download	dwm-7315bb08ad45e163dbf110b92f8f9f5d392d96e2.tar.gz

using SRC instead of *.c

Diffstat (limited to 'dwm.1')

0 files changed, 0 insertions, 0 deletions

15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108

#!/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" export CXXFLAGS="-std=c++98 $CFLAGS" # CI has an ancient version; don't expect recent dialects # 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 ../../tools/enumerate ../../tools/enumerate.cc && { $CXX $CXXFLAGS ../../tools/enumerate.cc -o ../../tools/enumerate } older_than ../../tools/tangle ../../tools/tangle.cc && { noisy_cd ../../tools # auto-generate various lists (ending in '_list' by convention) { # list of function declarations, so I can define them in any order grep -h "^[^ #].*) {" tangle.cc |sed 's/ {.*/;/' |update tangle.function_list # list of tests to run grep -h "^[[:space:]]*void test_" tangle.cc |sed 's/^\s*void $.*$() {$/\1,/' |update tangle.test_list grep -h "^\s*void test_" tangle.cc |sed 's/^\s*void $.*$() {.*/"\1",/' |update tangle.test_name_list # } $CXX $CFLAGS tangle.cc -o tangle ./tangle test noisy_cd ../archive/1.vm # no effect; just to show us returning to the parent directory } LAYERS=$(../../tools/enumerate --until $UNTIL_LAYER |grep '\.cc$') older_than mu.cc $LAYERS ../../tools/enumerate ../../tools/tangle && { # no update here; rely on 'update' calls downstream ../../tools/tangle $LAYERS > mu.cc } older_than cleave/cleave cleave/cleave.cc && { $CXX $CXXFLAGS cleave/cleave.cc -o cleave/cleave rm -rf .build } mkdir -p .build # auto-generate function declarations, so I can define them in any order # functions start out unindented, have all args on the same line, and end in ') {' # # \/ ignore struct/class methods grep -h "^[^[:space:]#].*) {$" mu.cc |grep -v ":.*(" |sed 's/ {.*/;/' |update .build/function_list # auto-generate list of tests to run grep -h "^\s*void test_" mu.cc |sed 's/^\s*void $.*$() {.*/\1,/' |update .build/test_list grep -h "^\s*void test_" mu.cc |sed 's/^\s*void $.*$() {.*/"\1",/' |update .build/test_name_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 # create the list of global variable declarations from the corresponding definitions 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 $CXXFLAGS -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 $CXXFLAGS .build/*.o termbox/libtermbox.a -o .build/mu_bin cp .build/mu_bin . } ## [0-9]*.mu -> core.mu MU_LAYERS=$(../../tools/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 # stop immediately after target provided at commandline


context:
space:
mode: