plomlompom.com Git - plomrogue/blob - 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 _add_dependency() {
  16   parent="$1"
  17   dependency="$2"
  18   # Do not record circular dependencies.
  19   [ "$parent" = "$dependency" ] && exit 1
  20   local base; _dirsplit "$parent"
  21   [ -d "$REDO_DIR/$dir" ] || mkdir -p "$REDO_DIR/$dir"
  22   # Naive implementation: Append dependency, then remove double dependencies.
  23   dependencies=$( (echo "$dependency"; cat "$REDO_DIR/$parent".dependencies 2>/dev/null ) | sort -u)
  24   echo "$dependencies" > "$REDO_DIR/$parent".dependencies
  25   # FIXME: Remove added dependency from non-existence dependencies.
  26 }
  27
  28 _add_dependency_ne() {
  29   parent="$1"
  30   dependency_ne="$2"
  31   # Do not record circular dependencies.
  32   [ "$parent" = "$dependency_ne" ] && exit 1
  33   # Do not record existing files as non-existence dependencies.
  34   [ -e "$dependency_ne" ] && return
  35   local base; _dirsplit "$parent"
  36   [ -d "$REDO_DIR/$dir" ] || mkdir -p "$REDO_DIR/$dir"
  37   # Naive implementation: Append dependency, then remove double dependencies.
  38   dependencies_ne=$( (echo "$dependency_ne"; cat "$REDO_DIR/$parent".dependencies_ne 2>/dev/null ) | sort -u)
  39   echo "$dependencies_ne" > "$REDO_DIR/$parent".dependencies_ne
  40   # FIXME: Remove added non-existence dependency from dependencies.
  41 }
  42
  43 _add_target() {
  44   local target="$1"
  45   # Exit if called without a target.
  46   [ -z "$target" ] && exit 1
  47   local base; _dirsplit "$target"
  48   [ -d "$REDO_DIR/$dir" ] || mkdir -p "$REDO_DIR/$dir"
  49   # If target file exists, record ctime and md5sum.
  50   if [ -e "$target" ]; then
  51     stat -c%Y "$target" > "$REDO_DIR/$target".ctime
  52     md5sum < "$target" > "$REDO_DIR/$target".md5sum
  53   fi
  54 }
  55
  56 _dependencies_uptodate() {
  57   target="$1"
  58   target_relpath=${target##$REDO_BASE/}
  59   # If no dependencies exist, they are by definition up to date.
  60   if [ ! -e "$REDO_DIR/$target".dependencies ]; then
  61     _echo_debug_message "$REDO_DEPTH$dir$target_relpath has no dependencies."
  62     return 0
  63   fi
  64   _echo_debug_message "$REDO_DEPTH$dir$target_relpath non-existant dependency check:"
  65   dependencies_ne=$(cat "$REDO_DIR/$target".dependencies_ne 2>/dev/null || :)
  66   for dependency_ne in $dependencies_ne; do
  67     dependency_ne_relpath=${dependency_ne##$REDO_BASE/}
  68     _echo_debug_message "$REDO_DEPTH$dir$target_relpath depends on non-existence of $dependency_ne_relpath"
  69     # If a non-existence dependency exists, it is out of date.
  70     # Dependencies, e.g. on default.do files may also be out of date.
  71     # Naive implementation: Delete dependency information and rebuild.
  72     if [ -e "$dependency_ne" ]; then
  73       rm "$REDO_DIR/$target".dependencies
  74       rm "$REDO_DIR/$target".dependencies_ne
  75       return 1
  76     # If a non-existence dependency does not exist, but is also a
  77     # dependency, it existed in the past. Naive implementation: Delete
  78     # dependency information and pretend the (actually up-to-date)
  79     # dependency is out of date to generate dependency information.
  80     # TODO: Only remove non-existence dependency from dependencies,
  81     # and do no return at this point; maybe escape filename properly.
  82     elif (grep -q '^'"$dependency_ne"'$' "$REDO_DIR/$target".dependencies \
  83       2>/dev/null); then
  84       rm "$REDO_DIR/$target".dependencies
  85       return 1
  86     fi
  87   done
  88   _echo_debug_message "$REDO_DEPTH$dir$target_relpath non-existence dependencies uptodate."
  89   _echo_debug_message "$REDO_DEPTH$dir$target_relpath dependency check:"
  90   if [ "$REDO_SHUFFLE" = "1" ]; then
  91     dependencies=$(shuf "$REDO_DIR/$target".dependencies 2>/dev/null || :)
  92   else
  93     dependencies=$(cat "$REDO_DIR/$target".dependencies 2>/dev/null || :)
  94   fi
  95   for dependency in $dependencies; do
  96     dependency_relpath=${dependency##$REDO_BASE/}
  97     dir=''
  98     _echo_debug_message "$REDO_DEPTH$dir$target_relpath depends on $dependency_relpath"
  99     if ( ! _is_uptodate "$dependency" ); then
 100       _echo_debug_message \
 101         "$REDO_DEPTH$dir$target_relpath dependency $dependency_relpath not uptodate."
 102       return 1
 103     fi
 104     if ( ! _dependencies_uptodate "$dependency"); then
 105       _echo_debug_message \
 106         "$REDO_DEPTH$dir$target_relpath dependency $dependency_relpath dependencies not uptodate."
 107       return 1
 108     fi
 109     # In the case that two targets depend on the same target and are
 110     # built after another, when the second target is built, redo finds
 111     # its dependencies to be up-to-date. This implies that the second
 112     # target would not be built. If a dependency build timestamp is
 113     # greater than or equal to a targets build timestamp, assume the
 114     # dependency has been rebuilt and the target should be rebuilt.
 115     target_ts="$(cat "$REDO_DIR/$target_abspath.buildtime" 2>/dev/null || echo 0)"
 116     dependency_ts="$(cat "$REDO_DIR/$dependency.buildtime" 2>/dev/null || echo 0)"
 117     if [ "$dependency_ts" -ge "$target_ts" ]; then
 118       _echo_debug_message \
 119         "$REDO_DEPTH$dir$target_relpath dependency $dependency_relpath uptodate, but built later than $target_relpath."
 120       return 1
 121     fi
 122   done
 123   _echo_debug_message "$REDO_DEPTH$dir$target_relpath dependencies uptodate."
 124   return 0
 125 }
 126
 127 _dirsplit() {
 128   base=${1##*/}
 129   dir=${1%"$base"}
 130 }
 131
 132 _dir_shovel() {
 133   local dir base
 134   xdir="$1" xbase="$2" xbasetmp="$2"
 135   while [ ! -d "$xdir" -a -n "$xdir" ]; do
 136     _dirsplit "${xdir%/}"
 137     xbasetmp=${base}__"$xbase"
 138     xdir="$dir" xbase="$base"/"$xbase"
 139     echo "xbasetmp='$xbasetmp'" >&2
 140   done
 141 }
 142
 143 _do() {
 144   local dir="$1" target="$2" tmp="$3"
 145   # Add target to parent targets dependencies.
 146   target_abspath="$PWD/$target"
 147   if [ -n "$REDO_TARGET" ]; then
 148     _add_dependency "$REDO_TARGET" "$target_abspath"
 149   fi
 150   target_relpath="${target_abspath##$REDO_BASE/}"
 151   if ( ! _is_uptodate "$target_abspath" || ! _dependencies_uptodate "$target_abspath" ); then
 152     dofile="$target".do
 153     base="$target"
 154     ext=
 155     [ -e "$target.do" ] || _find_dofile "$target"
 156     # Add non existing .do file to non-existence dependencies so target is built when
 157     # .do file in question is created.
 158     _add_dependency_ne "$(readlink -f "$target")" "$PWD/$target.do"
 159     if [ ! -e "$dofile" ]; then
 160       # If .do file does not exist and target exists, it is a source file.
 161       if [ -e "$target" ]; then
 162         _add_target "$(readlink -f $target)"
 163         # Portable timestamps for systems supporting GNU date format '%N'.
 164         date +%s%N | tr -d '%N' > "$REDO_DIR/$target_abspath".buildtime
 165         return 0
 166       # If .do file does not exist and target does not exist, stop.
 167       else
 168         echo "redo: $target: no .do file" >&2
 169         exit 1
 170       fi
 171     # Add .do file to dependencies so target is built when .do file changes.
 172     else
 173       _add_dependency "$(readlink -f "$target")" "$PWD/$dofile"
 174       _add_target "$PWD/$dofile"
 175     fi
 176     printf '%sredo %s%s%s%s%s\n' \
 177       "$green" "$REDO_DEPTH" "$bold" "$target_relpath" "$plain" >&2
 178     ( _run_dofile "$target" "$base" "$tmp.tmp" )
 179     rv="$?"
 180     if [ $rv != 0 ]; then
 181       rm -f "$tmp.tmp" "$tmp.tmp2"
 182       # Exit code 123 conveys that target was considered uptodate at runtime.
 183       if [ $rv != 123 ]; then
 184         printf "%sredo: %s%s: got exit code %s.%s\n" \
 185           "$red" "$REDO_DEPTH" "$target" "$rv" "$plain" >&2
 186         exit 1
 187       fi
 188     fi
 189     mv "$tmp.tmp" "$target" 2>/dev/null ||
 190     ! test -s "$tmp.tmp2" ||
 191     mv "$tmp.tmp2" "$target" 2>/dev/null
 192     rm -f "$tmp.tmp2"
 193     # Portable timestamps for systems supporting GNU date format '%N'.
 194     date +%s%N | tr -d '%N' > "$REDO_DIR/$target_abspath".buildtime
 195   else
 196     _echo_debug_message "$REDO_DEPTH$dir$target is up to date."
 197   fi
 198   _add_target "$(readlink -f $target)"
 199 }
 200
 201 _echo_debug_message() {
 202   [ "$REDO_DEBUG" = "1" ] && echo "$@" >&2
 203 }
 204
 205 _find_dofile() {
 206   local prefix=
 207   while :; do
 208     _find_dofile_pwd "$1"
 209     [ -e "$dofile" ] && break
 210     [ "$PWD" = "/" ] && break
 211     target=${PWD##*/}/"$target"
 212     tmp=${PWD##*/}/"$tmp"
 213     prefix=${PWD##*/}/"$prefix"
 214     cd ..
 215   done
 216   base="$prefix""$base"
 217 }
 218
 219 _find_dofile_pwd() {
 220   dofile=default."$1".do
 221   while :; do
 222     dofile=default.${dofile#default.*.}
 223     [ -e "$dofile" -o "$dofile" = default.do ] && break
 224   done
 225   ext=${dofile#default}
 226   ext=${ext%.do}
 227   base=${1%$ext}
 228 }
 229
 230 _is_uptodate() {
 231   target="$1"
 232   target_relpath=${target##$REDO_BASE/}
 233   # If a target does not exist, it is by definition out of date.
 234   if [ ! -e "$target" ]; then
 235     _echo_debug_message "$REDO_DEPTH$dir$target_relpath does not exist."
 236     return 1
 237   else
 238     # If a file exists, but has no build date, it is by a previously unseen
 239     # source file. A previously unseen source file is  by definition up to date.
 240     if [ ! -e "$REDO_DIR/$target".ctime ]; then
 241       _echo_debug_message "$REDO_DEPTH$dir$target_relpath.ctime does not exist."
 242       # Add source file to dependencies so target is built when source file changes.
 243       _add_target "$(readlink -f $target)"
 244       return 0
 245     else
 246       _echo_debug_message "$REDO_DEPTH$dir$target_relpath.ctime exists."
 247       # If a file exists and has an entry in the always database, it is never
 248       # up to date.
 249       if [ -e "$REDO_DIR/$target".always ]; then
 250         _echo_debug_message "$REDO_DEPTH$dir$target_relpath.always exists."
 251         return 1
 252       fi
 253       # If a file exists and has an entry in the stamp database, it might not
 254       # be up to date. redo-stamp decides if the file is up to date at runtime.
 255       if [ -e "$REDO_DIR/$target".stamp ]; then
 256         _echo_debug_message "$REDO_DEPTH$dir$target_relpath.stamp exists."
 257         return 1
 258       fi
 259       # If a file exists and has an entry in the dependency database and ctime
 260       # is the same as in the entry in the ctime database, it is up to date.
 261       if [ "$(cat "$REDO_DIR/$target".ctime 2>/dev/null || :)" = \
 262         "$(stat -c%Y "$target")" ]; then
 263         _echo_debug_message "$REDO_DEPTH$dir$target_relpath.ctime match."
 264         return 0
 265       else
 266         _echo_debug_message "$REDO_DEPTH$dir$target_relpath.ctime mismatch."
 267         # If a file exists and has an entry in the dependency database and
 268         # ctime is different from the entry in the ctime database, but md5sum
 269         # is the same as md5sum in the md5sum database, it is up to date.
 270         if [ "$(cat "$REDO_DIR/$target".md5sum 2>/dev/null || :)" = \
 271           "$(md5sum < "$target")" ]; then
 272           _echo_debug_message "$REDO_DEPTH$dir$target_relpath.md5sum match."
 273           return 0
 274         else
 275           _echo_debug_message "$REDO_DEPTH$dir$target_relpath.md5sum mismatch."
 276           return 1
 277         fi
 278       fi
 279     fi
 280   fi
 281   return 1
 282 }
 283
 284 _run_dofile() {
 285   export REDO_DEPTH="$REDO_DEPTH  "
 286   export REDO_TARGET="$PWD"/"$target"
 287   local line1
 288   set -e
 289   read line1 <"$PWD/$dofile" || true
 290   cmd=${line1#"#!"}
 291   # If the first line of a do file does not have a hashbang (#!), use /bin/sh.
 292   if [ "$cmd" = "$line1" ] || [ "$cmd" = "/bin/sh" ]; then
 293     if [ "$REDO_XTRACE" = "1" ]; then
 294       cmd="/bin/sh -ex"
 295     else
 296       cmd="/bin/sh -e"
 297     fi
 298   fi
 299   $cmd "$PWD/$dofile" "$@" >"$tmp.tmp2"
 300 }
 301
 302 set +e
 303 if [ -n "$1" ]; then
 304   for target; do
 305     _dirsplit "$target"
 306     _dir_shovel "$dir" "$base"
 307     dir="$xdir" base="$xbase" basetmp="$xbasetmp"
 308     ( cd "$dir" && _do "$dir" "$base" "$basetmp" )
 309     [ "$?" = 0 ] || exit 1
 310   done
 311 fi