bin/lib

   1 # The Evaluator -- Shell Function Library
   2 # (c) 2001 Martin Mares <mj@ucw.cz>
   3
   4 # General settings
   5 shopt -s dotglob
   6
   7 # Logging functions.
   8 # File handles used: fd1=log, fd2=progress
   9
  10 function log-init
  11 {
  12         exec >>$TDIR/log
  13         HAVE_LOG=1
  14 }
  15
  16 function pstart
  17 {
  18         echo >&2 -n "$@"
  19 }
  20
  21 function pcont
  22 {
  23         echo >&2 -n "$@"
  24 }
  25
  26 function pend
  27 {
  28         echo >&2 "$@"
  29 }
  30
  31 function die
  32 {
  33         echo >&2 "$@"
  34         [ -n "$HAVE_LOG" ] && echo "Fatal error: $@"
  35         exit 1
  36 }
  37
  38 # Sandbox subroutines
  39
  40 function box-init
  41 {
  42         pstart "Preparing sandbox... "
  43         [ -n "$TEST_USER" ] || die "TEST_USER not set. Please fix."
  44         if [ $TEST_USER == $EVAL_USER ] ; then
  45                 pcont "running locally (INSECURE), "
  46                 BOXDIR=box
  47                 BOXCMD=bin/box
  48                 mkdir -p box
  49         else
  50                 pcont "used account $TEST_USER, "
  51                 BOXDIR=$MO_ROOT/$TEST_USER
  52                 BOXCMD=bin/box-$TEST_USER
  53         fi
  54         [ -d $BOXDIR -a -f $BOXCMD ] || die "Sandbox set up incorrectly"
  55         BOXCMD="$BOXCMD -c$BOXDIR"
  56         echo "Sandbox directory: $BOXDIR"
  57         echo "Sandbox command: $BOXCMD"
  58         box-clean
  59         pend "OK"
  60 }
  61
  62 function box-clean
  63 {
  64         [ -n "$BOXCMD" ] || die "box-init not called"
  65         rm -rf $BOXDIR/*
  66 }
  67
  68 # Initialization of testing directories
  69
  70 function dir-init
  71 {
  72         pstart "Initializing... "
  73         PDIR=problems/$PROBLEM
  74         SDIR=solutions/$CONTESTANT/$PROBLEM
  75         TDIR=testing/$CONTESTANT/$PROBLEM
  76         [ -d $PDIR ] || die "Problem $PROBLEM not known"
  77         [ -d $SDIR ] || die "Solution of $PROBLEM not found"
  78         mkdir -p $TDIR
  79         rm -rf $TDIR
  80         cp -a $SDIR $TDIR
  81         cat >$TDIR/log <<EOF
  82 Testing solution of $PROBLEM by $CONTESTANT
  83 Test started at `date`
  84 Contestant's solution directory: $SDIR
  85 Problem directory: $PDIR
  86 Testing directory: $TDIR
  87 EOF
  88         >$TDIR/points
  89         pend "OK"
  90 }
  91
  92 # Locating source file in SDIR, pass name in SRCN (without path) and extension in SRCEXT
  93
  94 function locate-source
  95 {
  96         pstart "Finding source... "
  97         SBASE=${1:-$PROBLEM}
  98         for a in $EXTENSIONS ; do
  99                 if [ -f $SDIR/$SBASE.$a ] ; then
 100                         [ -z "$SRCN" ] || die "Multiple source files found: $SDIR/$PROBLEM.$a and $SDIR/$SRCN. Please fix."
 101                         SRCN=$SBASE.$a
 102                         SRCEXT=$a
 103                 fi
 104         done
 105         [ -n "$SRCN" ] || die "NOT FOUND"
 106         pend $SRCN
 107         echo "Found source file: $SDIR/$SRCN"
 108 }
 109
 110 # Compilation (compile SDIR/SRCN with PDIR/EXTRAS to EXE=TDIR/PROBLEM)
 111
 112 function compile
 113 {
 114         pstart "Compiling... "
 115         cp -a $SDIR/$SRCN $TDIR/$SRCN
 116         if [ -n "$EXTRAS" ] ; then
 117                 echo "Extras: $EXTRAS"
 118                 for a in $EXTRAS ; do cp $PDIR/$a $TDIR/ ; done
 119         fi
 120         box-clean
 121         for a in $SRCN $EXTRAS ; do cp $TDIR/$a $BOXDIR/ ; done
 122         SRC=$SRCN
 123         EXE=$PROBLEM
 124         CCMD=COMP_$SRCEXT
 125         CCMD="`eval echo ${!CCMD}`"
 126         COMP_SANDBOX_OPTS="`eval echo $COMP_SANDBOX_OPTS`"
 127         echo "Compiler command: $CCMD"
 128         echo "Compiler sandbox options: $COMP_SANDBOX_OPTS"
 129
 130         echo "Compiler input files:"
 131         ls -Al $BOXDIR
 132         echo "Compiler output:"
 133         if ! $BOXCMD $COMP_SANDBOX_OPTS -- $CCMD 2>$TDIR/compile.out ; then
 134                 COMPILE_MSG="`cat $TDIR/compile.out`"
 135                 pend "FAILED: $COMPILE_MSG"
 136                 echo "$COMPILE_MSG"
 137                 return 1
 138         fi
 139         cat $TDIR/compile.out
 140         rm $TDIR/compile.out
 141         echo "Compiler output files:"
 142         ls -Al $BOXDIR
 143         if [ ! -f $BOXDIR/$PROBLEM ] ; then
 144                 pend "FAILED: Missing executable file"
 145                 echo "Missing executable file"
 146                 return 1
 147         fi
 148         EXE=$TDIR/$PROBLEM
 149         cp -a $BOXDIR/$PROBLEM $EXE
 150         echo "Compiled OK, result copied to $EXE"
 151         pend "OK"
 152 }
 153
 154 # Running of test program with file input/output
 155
 156 function test-run
 157 {
 158         pcont "<init> "
 159         box-clean
 160         echo "Executable file: $TDIR/$PROBLEM"
 161         cp $TDIR/$PROBLEM $BOXDIR/
 162         echo "Input: $TDIR/$PROBLEM"
 163         ln $PDIR/$TEST.in $TDIR/$TEST.in
 164         cp $PDIR/$TEST.in $BOXDIR/$PROBLEM.in
 165         echo "Input files:"
 166         ls -Al $BOXDIR
 167
 168         pcont "<run> "
 169         echo "Timeout: $TIME_LIMIT s"
 170         echo "Memory: $MEM_LIMIT KB"
 171         BOXOPTS="`eval echo $TEST_SANDBOX_OPTS`"
 172         echo "Sandbox options: $BOXOPTS"
 173         if ! $BOXCMD $BOXOPTS -- ./$PROBLEM 2>$TDIR/exec.out ; then
 174                 TEST_MSG="`cat $TDIR/exec.out`"
 175                 pend "$TEST_MSG"
 176                 echo "$TEST_MSG"
 177                 echo >>$PTSFILE "0 $TEST_MSG"
 178                 return 1
 179         fi
 180         cat $TDIR/exec.out
 181         rm $TDIR/exec.out
 182         echo "Output files:"
 183         ls -Al $BOXDIR
 184         if [ ! -s $BOXDIR/$PROBLEM.out ] ; then
 185                 pend "No output file."
 186                 echo "No output file."
 187                 echo >>$PTSFILE "0 No output."
 188                 return 1
 189         fi
 190         cp $BOXDIR/$PROBLEM.out $TDIR/$TEST.out
 191 }
 192
 193 # Syntax checks
 194
 195 function syntax-check
 196 {
 197         [ -n "$SYNTAX_CHECK" ] || return 0
 198         pcont "<syntax> "
 199         SCHECK="`eval echo $SYNTAX_CHECK`"
 200         echo "Syntax check command: $SCHECK"
 201         $SCHECK && return 0
 202         pend "Wrong syntax."
 203         echo "Wrong syntax."
 204         echo >>$PTSFILE "0 Wrong syntax."
 205         return 1
 206 }
 207
 208 # Output checks
 209
 210 function output-check
 211 {
 212         pcont "<check> "
 213         ln $PDIR/$TEST.out $TDIR/$TEST.ok
 214         OCHECK="`eval echo $OUTPUT_CHECK`"
 215         echo "Output check command: $OCHECK"
 216         $OCHECK && return 0
 217         pend "Wrong answer."
 218         echo "Wrong answer."
 219         echo >>$PTSFILE "0 Wrong answer."
 220         return 1
 221 }
 222
 223 # Setup of public commands
 224
 225 function public-setup
 226 {
 227         PDIR=$MO_PUBLIC/problems/$PROBLEM
 228         SDIR=.
 229         TDIR=~/.test
 230         [ -d $PDIR ] || die "Unknown problem $PROBLEM"
 231
 232         pstart "Initializing... "
 233         mkdir -p $TDIR
 234         rm -rf $TDIR/*
 235         BOXDIR=~/.box
 236         mkdir -p $BOXDIR
 237         rm -rf $BOXDIR/*
 238         BOXCMD="$MO_PUBLIC/bin/box -c$BOXDIR"
 239         exec >log
 240         pend "OK  (see 'log' for details)"
 241 }