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         for a in $EXTENSIONS ; do
  98                 if [ -f $SDIR/$PROBLEM.$a ] ; then
  99                         [ -z "$SRCN" ] || die "Multiple source files found: $SDIR/$PROBLEM.$a and $SDIR/$SRCN. Please fix."
 100                         SRCN=$PROBLEM.$a
 101                         SRCEXT=$a
 102                 fi
 103         done
 104         [ -n "$SRCN" ] || die "NOT FOUND"
 105         pend $SRCN
 106         echo "Found source file: $SDIR/$SRCN"
 107 }
 108
 109 # Compilation (compile SDIR/SRCN with PDIR/EXTRAS to EXE=TDIR/PROBLEM)
 110
 111 function compile
 112 {
 113         pstart "Compiling... "
 114         cp -a $SDIR/$SRCN $TDIR/$SRCN
 115         if [ -n "$EXTRAS" ] ; then
 116                 echo "Extras: $EXTRAS"
 117                 for a in $EXTRAS ; do cp $PDIR/$a $TDIR/ ; done
 118         fi
 119         box-clean
 120         for a in $SRCN $EXTRAS ; do cp $TDIR/$a $BOXDIR/ ; done
 121         SRC=$SRCN
 122         EXE=$PROBLEM
 123         CCMD=COMP_$SRCEXT
 124         CCMD="`eval echo ${!CCMD}`"
 125         COMP_SANDBOX_OPTS="`eval echo $COMP_SANDBOX_OPTS`"
 126         echo "Compiler command: $CCMD"
 127         echo "Compiler sandbox options: $COMP_SANDBOX_OPTS"
 128
 129         echo "Compiler input files:"
 130         ls -Al $BOXDIR
 131         echo "Compiler output:"
 132         if ! $BOXCMD $COMP_SANDBOX_OPTS -- $CCMD 2>$TDIR/compile.out ; then
 133                 COMPILE_MSG="`cat $TDIR/compile.out`"
 134                 pend "FAILED: $COMPILE_MSG"
 135                 echo "$COMPILE_MSG"
 136                 return 1
 137         fi
 138         cat $TDIR/compile.out
 139         rm $TDIR/compile.out
 140         echo "Compiler output files:"
 141         ls -Al $BOXDIR
 142         if [ ! -f $BOXDIR/$PROBLEM ] ; then
 143                 pend "FAILED: Missing executable file"
 144                 echo "Missing executable file"
 145                 return 1
 146         fi
 147         EXE=$TDIR/$PROBLEM
 148         cp -a $BOXDIR/$PROBLEM $EXE
 149         echo "Compiled OK, result copied to $EXE"
 150         pend "OK"
 151 }
 152
 153 # Running of test program with file input/output
 154
 155 function test-run
 156 {
 157         pcont "<init> "
 158         box-clean
 159         echo "Executable file: $TDIR/$PROBLEM"
 160         cp $TDIR/$PROBLEM $BOXDIR/
 161         echo "Input: $TDIR/$PROBLEM"
 162         ln $PDIR/$TEST.in $TDIR/$TEST.in
 163         cp $PDIR/$TEST.in $BOXDIR/$PROBLEM.in
 164         echo "Input files:"
 165         ls -Al $BOXDIR
 166
 167         pcont "<run> "
 168         echo "Timeout: $TIME_LIMIT s"
 169         echo "Memory: $MEM_LIMIT KB"
 170         BOXOPTS="`eval echo $TEST_SANDBOX_OPTS`"
 171         echo "Sandbox options: $BOXOPTS"
 172         if ! $BOXCMD $BOXOPTS -- ./$PROBLEM 2>$TDIR/exec.out ; then
 173                 TEST_MSG="`cat $TDIR/exec.out`"
 174                 pend "$TEST_MSG"
 175                 echo "$TEST_MSG"
 176                 echo >>$PTSFILE "0 $TEST_MSG"
 177                 return 1
 178         fi
 179         cat $TDIR/exec.out
 180         rm $TDIR/exec.out
 181         echo "Output files:"
 182         ls -Al $BOXDIR
 183         if [ ! -s $BOXDIR/$PROBLEM.out ] ; then
 184                 pend "No output file."
 185                 echo "No output file."
 186                 echo >>$PTSFILE "0 No output."
 187                 return 1
 188         fi
 189         cp $BOXDIR/$PROBLEM.out $TDIR/$TEST.out
 190 }
 191
 192 # Syntax checks
 193
 194 function syntax-check
 195 {
 196         [ -n "$SYNTAX_CHECK" ] || return 0
 197         pcont "<syntax> "
 198         SCHECK="`eval echo $SYNTAX_CHECK`"
 199         echo "Syntax check command: $SCHECK"
 200         $SCHECK && return 0
 201         pend "Wrong syntax."
 202         echo "Wrong syntax."
 203         echo >>$PTSFILE "0 Wrong syntax."
 204         return 1
 205 }
 206
 207 # Output checks
 208
 209 function output-check
 210 {
 211         pcont "<check> "
 212         ln $PDIR/$TEST.out $TDIR/$TEST.ok
 213         OCHECK="`eval echo $OUTPUT_CHECK`"
 214         echo "Output check command: $OCHECK"
 215         $OCHECK && return 0
 216         pend "Wrong answer."
 217         echo "Wrong answer."
 218         echo >>$PTSFILE "0 Wrong answer."
 219         return 1
 220 }
 221
 222 # Setup of public commands
 223
 224 function public-setup
 225 {
 226         PDIR=$MO_PUBLIC/problems/$PROBLEM
 227         SDIR=.
 228         TDIR=~/.test
 229         [ -d $PDIR ] || die "Unknown problem $PROBLEM"
 230
 231         pstart "Initializing... "
 232         mkdir -p $TDIR
 233         rm -rf $TDIR/*
 234         BOXDIR=~/.box
 235         mkdir -p $BOXDIR
 236         rm -rf $BOXDIR/*
 237         BOXCMD="$MO_PUBLIC/bin/box -c$BOXDIR"
 238         exec >log
 239         pend "OK  (see 'log' for details)"
 240 }