home · contact · privacy
New client: Add colors to map window.
[plomrogue] / build / redo_scripts / redo-ifchange
1 #!/bin/sh
2 # redo-ifchange – bourne shell implementation of DJB redo
3 # Copyright © 2014  Nils Dagsson Moskopp (erlehmann)
4
5 # This program is free software: you can redistribute it and/or modify
6 # it under the terms of the GNU Affero General Public License as
7 # published by the Free Software Foundation, either version 3 of the
8 # License, or (at your option) any later version.
9
10 # Dieses Programm hat das Ziel, die Medienkompetenz der Leser zu
11 # steigern. Gelegentlich packe ich sogar einen handfesten Buffer
12 # Overflow oder eine Format String Vulnerability zwischen die anderen
13 # Codezeilen und schreibe das auch nicht dran.
14
15 # GNU vs BSD.
16 test=`command -v md5sum | wc -l`
17 if [ 1 -gt $test ]
18 then
19     alias md5sum='md5 -r'
20 fi
21 alias stat_cY='stat -c%Y'
22 test=`stat --version 2>&1 | grep GNU | wc -l`
23 if [ 1 -gt $test ]
24 then
25     alias stat_cY='stat -f%Y'
26 fi
27
28 _add_ctime_md5sum() {
29   target=$1
30   local base; _dirsplit "$target"
31   [ -d "$REDO_DIR/$dir" ] || LANG=C mkdir -p "$REDO_DIR/$dir"
32   LANG=C stat_cY "$target" >"$REDO_DIR/$target".ctime
33   LANG=C md5sum <"$target" >"$REDO_DIR/$target".md5sum
34 }
35
36 _add_dependency() {
37   parent=$1
38   dependency=$2
39   # Do not record circular dependencies.
40   [ "$parent" = "$dependency" ] && exit 1
41   local base; _dirsplit "$parent"
42   [ -d "$REDO_DIR/$dir" ] || LANG=C mkdir -p "$REDO_DIR/$dir"
43   ctime="$(LANG=C stat_cY "$dependency")"
44   md5sum="$(LANG=C md5sum < "$dependency")"
45   printf '%s\t%s\t%s\n' "$dependency" "$ctime" "$md5sum" >> \
46     "$REDO_DIR"/"$parent".dependencies.tmp
47 }
48
49 _add_dependency_ne() {
50   parent="$1"
51   dependency_ne="$2"
52   # Do not record circular dependencies.
53   [ "$parent" = "$dependency_ne" ] && exit 1
54   # Do not record existing files as non-existence dependencies.
55   [ -e "$dependency_ne" ] && return
56   local base; _dirsplit "$parent"
57   [ -d "$REDO_DIR/$dir" ] || mkdir -p "$REDO_DIR/$dir"
58   printf '%s\n' "$dependency_ne" >> "$REDO_DIR/$parent".dependencies_ne.tmp
59 }
60
61 _dependencies_ne_uptodate() {
62   target=$1
63   # If no non-existence dependencies exist, they are by definition up to date.
64   if [ ! -s "$REDO_DIR/$target".dependencies_ne ]; then
65     _echo_debug_message "$target has no non-existence dependencies."
66     return 0
67   fi
68   _echo_debug_message "$target non-existence dependency check:"
69   while read dependency_ne; do
70     _echo_debug_message "\t$dependency_ne should not exist."
71     # If a non-existence dependency exists, it is out of date.
72     # Dependencies, e.g. on default.do files may also be out of date.
73     # Naive implementation: Pretend target is not up to date and rebuild.
74     if [ -e "$dependency_ne" ]; then
75       _echo_debug_message "\t$dependency_ne does exist."
76       return 1
77     fi
78     _echo_debug_message "\t$dependency_ne does not exist."
79   done < "$REDO_DIR/$target".dependencies_ne
80   _echo_debug_message "$target non-existence dependencies uptodate."
81   return 0
82 }
83
84 _target_uptodate() {
85   target=$1
86   # If a target is a top-level target, it is not up to date.
87   if [ -z "$REDO_TARGET" ]; then
88     return 1
89   fi
90   # If a target does not exist, it is not up to date.
91   if [ ! -e "$target" ]; then
92     _echo_debug_message "$target does not exist."
93     return 1
94   fi
95   # If an .always file exists, the target is out of date.
96   if [ -e "$REDO_DIR/$target".always ]; then
97     _echo_debug_message "$target is always out of date."
98     return 1
99   fi
100   # If .stamp file exists, the target is out of date.
101   if [ -e "$REDO_DIR/$target".stamp ]; then
102     _echo_debug_message "$target is out of date due to redo-stamp."
103     return 1
104   fi
105   if [ -e "$REDO_DIR/$target".ctime ]; then
106     read ctime_stored <"$REDO_DIR/$target".ctime
107     ctime_actual="$(LANG=C stat_cY "$target")"
108     _echo_debug_message "$target stored ctime $ctime_stored"
109     _echo_debug_message "$target actual ctime $ctime_actual"
110     if [ "$ctime_stored" = "$ctime_actual" ]; then
111       _echo_debug_message "$target up to date."
112       return 0
113     elif [ -e "$REDO_DIR/$target".md5sum ]; then
114       read md5sum_stored <"$REDO_DIR/$target".md5sum
115       md5sum_actual="$(LANG=C md5sum < "$target")"
116       _echo_debug_message "$target stored md5sum $md5sum_stored"
117       _echo_debug_message "$target actual md5sum $md5sum_actual"
118       if [ "$md5sum_stored" = "$md5sum_actual" ]; then
119         # If stored md5sum of target matches actual md5sum, but stored
120         # ctime does not, redo needs to update stored ctime of target.
121         LANG=C stat_cY "$target" >"$REDO_DIR/$target".md5sum
122         return 0
123       fi
124       _echo_debug_message "$target out of date."
125       return 1
126     fi
127   fi
128 }
129
130 _dependencies_uptodate() {
131   target=$1
132   # If no dependencies exist, they are by definition up to date.
133   if [ ! -e "$REDO_DIR/$target".dependencies ]; then
134     _echo_debug_message "$target has no dependencies."
135     return 0
136   fi
137   if [ "$REDO_SHUFFLE" = "1" ]; then
138     shuf "$REDO_DIR/$target".dependencies -o "$REDO_DIR/$target".dependencies \
139       2>&-
140   fi
141   _echo_debug_message "$target dependency check:"
142   # If any dependency does not exist, the target is out of date.
143   LANG=C stat_cY $(LANG=C cut -f1 "$REDO_DIR/$target".dependencies) > \
144     "$REDO_DIR/$target".dependencies.ctimes 2>&- || return 1
145   exec 3< "$REDO_DIR/$target".dependencies.ctimes
146   exec 4< "$REDO_DIR/$target".dependencies
147   while read ctime_actual <&3 && read dependency ctime_stored md5sum_stored <&4; do
148     # If a .always file exists, the dependency is out of date.
149     if [ -e "$REDO_DIR/$dependency".always ]; then
150       _echo_debug_message "\t$dependency is always out of date."
151       return 1
152     fi
153     # If a .stamp file exists, the dependency is out of date.
154     if [ -e "$REDO_DIR/$dependency".stamp ]; then
155       _echo_debug_message "\t$dependency is always out of date."
156       return 1
157     fi
158     # If a dependency of a dependency is out of date, the dependency is out of date.
159     if ( ! _dependencies_uptodate "$dependency" ); then
160       return 1
161     fi
162     # If the ctime of a dependency did not change, the dependency is up to date.
163     _echo_debug_message "\t$dependency stored ctime $ctime_stored"
164     _echo_debug_message "\t$dependency actual ctime $ctime_actual"
165     if [ "$ctime_stored" = "$ctime_actual" ]; then
166       _echo_debug_message "\t$dependency up to date."
167       continue
168     fi
169     # If the md5sum of a dependency did not change, the dependency is up to date.
170     md5sum_actual="$(LANG=C md5sum < "$dependency")"
171     _echo_debug_message "\t$dependency stored md5sum $md5sum_stored"
172     _echo_debug_message "\t$dependency actual md5sum $md5sum_actual"
173     if [ "$md5sum_stored" = "$md5sum_actual" ]; then
174       _echo_debug_message "\t$dependency up to date."
175       continue
176     else
177       # if both ctime and md5sum did change, the dependency is out of date.
178       _echo_debug_message "\t$dependency out of date."
179       return 1
180     fi
181   done
182   exec 4>&-
183   exec 3>&-
184   _echo_debug_message "$target dependencies up to date."
185   # If a non-existence dependency is out of date, the target is out of date.
186   if ( ! _dependencies_ne_uptodate "$target" ); then
187     return 1
188   fi
189   return 0
190 }
191
192 _dirsplit() {
193   base=${1##*/}
194   dir=${1%"$base"}
195 }
196
197 _do() {
198   local dir="$1" target="$2" tmp="$3"
199   target_abspath="$PWD/$target"
200   target_relpath="${target_abspath##$REDO_BASE/}"
201   # If target is not up to date or its dependencies are not up to date, build it.
202   if (
203     ! _target_uptodate "$target_abspath" || \
204     ! _dependencies_uptodate "$target_abspath"
205   ); then
206     dofile="$target".do
207     base="$target"
208     ext=
209     [ -e "$target.do" ] || _find_dofile "$target"
210     if [ ! -e "$dofile" ]; then
211       # If .do file does not exist and target exists, it is a source file.
212       if [ -e "$target_abspath" ]; then
213         _add_dependency "$REDO_TARGET" "$target_abspath"
214         _add_ctime_md5sum "$target_abspath"
215         return 0
216       # If .do file does not exist and target does not exist, stop.
217       else
218         echo "redo: $target: no .do file" >&2
219         exit 1
220       fi
221     fi
222     printf '%sredo %s%s%s%s%s\n' \
223       "$green" "$REDO_DEPTH" "$bold" "$target_relpath" "$plain" >&2
224     ( _run_dofile "$target" "${base##*/}" "$tmp.tmp" )
225     rv="$?"
226     # Add non existing .do file to non-existence dependencies so
227     # target is built when .do file in question is created.
228     [ -e "$target.do" ] || _add_dependency_ne "$target_abspath" "$PWD/$target.do"
229     # Add .do file to dependencies so target is built when .do file changes.
230     _add_dependency "$target_abspath" "$PWD/$dofile"
231     if [ $rv != 0 ]; then
232       rm -f "$tmp.tmp" "$tmp.tmp2"
233       # Exit code 123 conveys that target was considered uptodate at runtime.
234       if [ $rv != 123 ]; then
235         printf "%sredo: %s%s: got exit code %s.%s\n" \
236           "$red" "$REDO_DEPTH" "$target" "$rv" "$plain" >&2
237         exit 1
238       fi
239     fi
240     mv "$tmp.tmp" "$target" 2>&- ||
241     ! test -s "$tmp.tmp2" ||
242     mv "$tmp.tmp2" "$target" 2>&-
243     rm -f "$tmp.tmp2"
244     # After build is finished, update dependencies.
245     touch "$REDO_DIR/$target_abspath".dependencies.tmp
246     touch "$REDO_DIR/$target_abspath".dependencies_ne.tmp
247     mv "$REDO_DIR/$target_abspath".dependencies.tmp \
248       "$REDO_DIR/$target_abspath".dependencies >&2
249     mv "$REDO_DIR/$target_abspath".dependencies_ne.tmp \
250       "$REDO_DIR/$target_abspath".dependencies_ne >&2
251   fi
252   # Some do files (like all.do) do not usually generate output.
253   if [ -e "$target_abspath" ]; then
254     # Record dependency on parent target.
255     _add_dependency "$REDO_TARGET" "$target_abspath"
256     _add_ctime_md5sum "$target_abspath"
257   fi
258 }
259
260 _echo_debug_message() {
261   [ "$REDO_DEBUG" = "1" ] && echo "$@" >&2
262 }
263
264 _find_dofile() {
265   local prefix=
266   while :; do
267     _find_dofile_pwd "$1"
268     [ -e "$dofile" ] && break
269     [ "$PWD" = "/" ] && break
270     target=${PWD##*/}/"$target"
271     tmp=${PWD##*/}/"$tmp"
272     prefix=${PWD##*/}/"$prefix"
273     cd ..
274   done
275   base="$prefix""$base"
276 }
277
278 _find_dofile_pwd() {
279   dofile=default."$1".do
280   while :; do
281     dofile=default.${dofile#default.*.}
282     [ -e "$dofile" -o "$dofile" = default.do ] && break
283   done
284   ext=${dofile#default}
285   ext=${ext%.do}
286   base=${1%$ext}
287 }
288
289 _run_dofile() {
290   export REDO_DEPTH="$REDO_DEPTH  "
291   export REDO_TARGET="$PWD"/"$target"
292   local line1
293   set -e
294   read line1 <"$PWD/$dofile" || true
295   cmd=${line1#"#!"}
296   # If the first line of a do file does not have a hashbang (#!), use /bin/sh.
297   if [ "$cmd" = "$line1" ] || [ "$cmd" = "/bin/sh" ]; then
298     if [ "$REDO_XTRACE" = "1" ]; then
299       cmd="/bin/sh -ex"
300     else
301       cmd="/bin/sh -e"
302     fi
303   fi
304   $cmd "$PWD/$dofile" "$@" >"$tmp.tmp2"
305 }
306
307 set +e
308 if [ -n "$1" ]; then
309   targets="$@"
310   [ "$REDO_SHUFFLE" = "1" ] && targets=$(LANG=C shuf -e "$@")
311   for target in $targets; do
312     # If relative path to target is given, convert to absolute absolute path.
313     case "$target" in
314       /*) ;;
315       *)  target="$PWD"/"$target" >&2;;
316     esac
317     _dirsplit "$target"
318     ( cd "$dir" && _do "$dir" "$base" "$base" )
319     [ "$?" = 0 ] || exit 1
320   done
321 fi