compile

#!/bin/bash

# usage: see ./compile -h

set -euo pipefail

# find script directory
SCRIPT_DIR="$0"
if [ "${SCRIPT_DIR#/}" = "$SCRIPT_DIR" ]; then
  SCRIPT_DIR="$(pwd)/$SCRIPT_DIR"
fi
SCRIPT_DIR="${SCRIPT_DIR%/*}"
SCRIPT_DIR="${SCRIPT_DIR%/.}"

# Markers
EXECUTABLE_NAME_MARKER="***executable:"
SCHEME_COMPILE_TIME_MARKER="***scheme-compile-time:"
C_COMPILE_TIME_MARKER="***c-compile-time:"

WITH_SCHEME_COMPTIME=(/usr/bin/time -f "$SCHEME_COMPILE_TIME_MARKER %e")
WITH_C_COMPTIME=(/usr/bin/time -f "$C_COMPILE_TIME_MARKER %e")

if [ "$(uname)" = "Darwin" ]; then
  WITH_SCHEME_COMPTIME=()
  WITH_C_COMPTIME=()
fi

# Default parameters
INPUT_FILE=             # file to compile
OPTIM_LEVEL=0           # optimization level
SAFE_ARITHMETIC=1       # safe/unsafe arithmetic
PRIMITIVE_COUNT=0       # enables primitive (0 to disable)
AVOID_MERGE=0           # enables merge avoidance of jump cascade
DUMP_JSON_TRACE=0       # dump BBV trace in json
SHOW_EXPANSION=0        # show macro expansion
GENERATE_CFG=0          # enable cfg generation
VIEW_CFG=0              # open cfg in pdf viewer
USE_IGSC=0              # use gambit igsc instead of gsc
COMPILER_DIR=           # compiler directory
VERSION_LIMIT=          # version limit
GLOBAL_VERSION_LIMIT=   # global version limit used when custom limits provided
                        # the global version limit is used for lib.scm
SYSTEM=                 # system (gambit or bigloo)
CUSTOM_OUTPUT_FILE=     # user's output file

# Parse parameters
while getopts "f:S:D:o:V:B:O:UPAJGWIEchv" opt; do
  case $opt in
    f)
      INPUT_FILE=$(readlink -f $OPTARG)
      ;;
    S)
      case $OPTARG in
        'gambit'|'bigloo'|'chez'|'racket'|'node')
          SYSTEM=$OPTARG
          ;;
        *)
          echo "Unknown system: $OPTARG" >&2
          exit 1
          ;;
      esac
      ;;
    D)
      COMPILER_DIR=$OPTARG
      ;;
    o)
      CUSTOM_OUTPUT_FILE=$OPTARG
      ;;
    V)
      VERSION_LIMIT=$OPTARG
      if [ "$VERSION_LIMIT" = "custom" ]; then
        :
      elif [ "$VERSION_LIMIT" -eq "$VERSION_LIMIT" ] 2> /dev/null; then
        :
      else
        echo "Version limit must be an integer or 'custom' not '$VERSION_LIMIT'"
        exit 1
      fi
      ;;
    B)
      GLOBAL_VERSION_LIMIT=$OPTARG
      if [ "$GLOBAL_VERSION_LIMIT" -eq "$GLOBAL_VERSION_LIMIT" ] 2> /dev/null; then
        :
      else
        echo "Global limit must be an integer not '$GLOBAL_VERSION_LIMIT'"
        exit 1
      fi
      ;;
    O)
      case $OPTARG in
        1|2|3)
          OPTIM_LEVEL=$OPTARG
          ;;
        *)
          echo "Invalid optimization level: -O$OPTARG" >&2
          exit 1
          ;;
      esac
      ;;
    U)
      SAFE_ARITHMETIC=0
      ;;
    P)
      PRIMITIVE_COUNT=1
      ;;
    A)
      AVOID_MERGE=1
      ;;
    J)
      DUMP_JSON_TRACE=1
      ;;
    G)
      GENERATE_CFG=1
      ;;
    W)
      GENERATE_CFG=1
      VIEW_CFG=1
      ;;
    I)
      USE_IGSC=1
      ;;
    E)
      SHOW_EXPANSION=1
      ;;
    c)
      rm -f tests/*/*.cfg tests/*/*.cfg.pdf tests/*/*.gvm tests/*/*.o* tests/*/*~ tests/*/*.bbv.dot tests/*/*.exe
      exit 0
      ;;
    v)
      set -x
      ;;
    h)
      echo "Usage: $0 [options]"
      echo "Options:"
      echo "  -f <filename>     File to compile"
      echo "  -S <system>       Specify the system ('gambit' or 'bigloo')"
      echo "  -D <dir>          Specify compiler directory"
      echo "  -V <limit>        Set the version limit"
      echo "  -O <level>        Set optimization level (1, 2, 3)"
      echo "  -A                Avoid merge of jump cascade"
      echo "  -U                Use unsafe arithmetic"
      echo "  -P                Count primitive usage"
      echo "  -J                Dump BBV algorithm trace in json"
      echo "  -G                Generate CFG"
      echo "  -W                View CFG in pdf viewer"
      echo "  -I                Use igsc (gambit only)"
      echo "  -c                Clean up tests"
      echo "  -h                Display this help and exit"
      echo "  -v                Execute this script in verbose mode"
      exit 0
      ;;
    \?)
      exit 1
      ;;
  esac
done

# Check valid arguments
if [ "$INPUT_FILE" = "" ]; then
  echo "*** no file provided: use -f <filename>" >&2
  exit 1
fi

if [ "$SYSTEM" = "" ]; then
  echo "*** no system provided: use -S <system>" >&2
  exit 1
fi

EXPECTED_EXTENSION="scm"
if [ "$SYSTEM" = "node" ]; then
  EXPECTED_EXTENSION="js"
fi
if [ "$SYSTEM" = "racket" ]; then
  EXPECTED_EXTENSION="rkt"
fi
if [[ "${INPUT_FILE##*.}" != "$EXPECTED_EXTENSION" ]]; then
    echo "** provided file must be a .$EXPECTED_EXTENSION file, not '$INPUT_FILE'"
    exit 1
fi

if [ "$VERSION_LIMIT" = "" ]; then
  echo "*** no version limit provided: use -V <limit>" >&2
  exit 1
fi

if [ "$USE_IGSC" = "1" ] && [ "$SYSTEM" != "gambit" ]; then
  echo "*** igsc only available with '-S gambit'" >&2
  exit 1
fi

# Set default value that depend on other options
if [ "$COMPILER_DIR" = "" ]; then
  if [ "$SYSTEM" = "bigloo" ]; then
    COMPILER_DIR="$SCRIPT_DIR/bigloo/local"
  elif [ "$SYSTEM" = "gambit" ]; then
    COMPILER_DIR="$SCRIPT_DIR/gambit/bbv-gambit"
  fi
fi
if [ "$COMPILER_DIR" != "" ]; then
  COMPILER_DIR=$(readlink -f $COMPILER_DIR)
fi

if [ "$SAFE_ARITHMETIC" = "0" ]; then
  ARITHMETIC=S
  SAFETY_MODE="unsafe"
else
  ARITHMETIC=G
  SAFETY_MODE="safe"
fi

INPUT_FILE_DIRNAME="$(dirname $INPUT_FILE)"
INPUT_FILE_NO_EXT="${INPUT_FILE%.scm}"
OUTPUT_FILE_BASE="$INPUT_FILE_NO_EXT.${SYSTEM}.V${VERSION_LIMIT}.O${OPTIM_LEVEL}.$SAFETY_MODE"
OUTPUT_FILE_C="$INPUT_FILE_NO_EXT.c"
OUTPUT_FILE_EXE="$OUTPUT_FILE_BASE.exe"
OUTPUT_FILE_CFG_DOT="$OUTPUT_FILE_BASE.cfg"
OUTPUT_FILE_JSON="$OUTPUT_FILE_BASE.json"

if [ "$CUSTOM_OUTPUT_FILE" = "" ]; then
  OUTPUT_FILE_EXE="$OUTPUT_FILE_BASE.exe"
else
  OUTPUT_FILE_EXE="$CUSTOM_OUTPUT_FILE"
fi

run_dot()
{
  if command -v dot > /dev/null 2>&1 ; then
    dot -O -Tpdf $1
  else
    echo "*** dot program not found" >&2
  fi
}

run_pdfviewer()
{
  if command -v okular > /dev/null 2>&1 ; then
    okular $1
  else
    if command -v open > /dev/null 2>&1 ; then
      open $1
    else
      echo "*** PDF viewer program not found" >&2
    fi
  fi
}

case "$SYSTEM" in
  gambit)
    # Set base compiler command
    if [ "$USE_IGSC" = "1" ]; then
      GAMBITCOMP="$COMPILER_DIR/gsi/gsi -:dar,=$COMPILER_DIR $COMPILER_DIR/gsc/igsc"
    else
      GAMBITCOMP="$COMPILER_DIR/gsc/gsc -:=$COMPILER_DIR"
    fi

    # Set optimization level
    if [ "$OPTIM_LEVEL" = "0" ]; then
      INLINING_LIMIT=0
      OPTIM_DECLARATIONS="(not constant-fold) (not inline) (not lambda-lift)"
      MACROS_CONSTANT_FOLDING="#f"
    else
      OPTIM_DECLARATIONS=""
      INLINING_LIMIT=370
      MACROS_CONSTANT_FOLDING="#t"
    fi

    if [ "$VERSION_LIMIT" = "custom" ]; then
      if [ "$GLOBAL_VERSION_LIMIT" != "" ]; then
        VERSION_LIMIT_DECL="(version-limit $GLOBAL_VERSION_LIMIT)"
      else
        VERSION_LIMIT_DECL=""
      fi
      VERSION_LIMIT_POSTFIX="(use-custom-version-limits!)"
    else
      VERSION_LIMIT_DECL="(version-limit $VERSION_LIMIT)"
      VERSION_LIMIT_POSTFIX=""
    fi

    if [ "$SAFETY_MODE" = "unsafe" ]; then
      UNSAFE_DECL="(not safe)"
    else
      UNSAFE_DECL=""
    fi

    PRELUDE="(declare
               $OPTIM_DECLARATIONS
               $VERSION_LIMIT_DECL
               $UNSAFE_DECL
               (inlining-limit $INLINING_LIMIT))
             (define-macro (%%%)
               (eval '(define arithmetic '$ARITHMETIC))
               (eval '(define macros-constant-folding '$MACROS_CONSTANT_FOLDING))
               #f)
             (%%%)
             (##include \"$SCRIPT_DIR/gambit/bbv.scm\")
             $VERSION_LIMIT_POSTFIX"

    FLAGS=""
    CC_FLAGS="" #"-cc-options \"-U___SINGLE_HOST\""
    if [ "$GENERATE_CFG" = "1" ]; then
      FLAGS="$FLAGS -keep-temp -gvm -cfg"
    fi

    EXPANSION_FLAG=""
    if [ "$SHOW_EXPANSION" = "1" ]; then
      EXPANSION_FLAG="-expansion"
    fi

    DUMP_JSON_FLAG=""
    if [ "$DUMP_JSON_TRACE" = "1" ]; then
      DUMP_JSON_FLAG="-bbv-json-trace"
      PRIMITIVE_COUNT=1
    fi

    if [ "$PRIMITIVE_COUNT" = "1" ]; then
      PRELUDE="(##include \"$SCRIPT_DIR/gambit/bbv-count.scm\") $PRELUDE"
    fi

    AVOID_MERGE_FLAG=""
    if [ "$AVOID_MERGE" = "1" ]; then
      AVOID_MERGE_FLAG="-avoid-merge-jump-cascade"
    fi

    # Compilation
    (cd $INPUT_FILE_DIRNAME && \
      "${WITH_SCHEME_COMPTIME[@]}" $GAMBITCOMP $EXPANSION_FLAG $AVOID_MERGE_FLAG -prelude "$PRELUDE" $FLAGS -c $INPUT_FILE)
    $GAMBITCOMP -prelude "$PRELUDE" -c $CC_FLAGS -o $SCRIPT_DIR/gambit/lib.c $SCRIPT_DIR/gambit/lib.scm
    $GAMBITCOMP -prelude "$PRELUDE" -c $CC_FLAGS -o $SCRIPT_DIR/gambit/main.c $SCRIPT_DIR/gambit/main.scm
    "${WITH_C_COMPTIME[@]}" $GAMBITCOMP -exe $CC_FLAGS -o $OUTPUT_FILE_EXE $SCRIPT_DIR/gambit/lib.c $OUTPUT_FILE_C $SCRIPT_DIR/gambit/main.c
    rm $OUTPUT_FILE_C

    if [ "$PRIMITIVE_COUNT" = "1" ]; then
      $OUTPUT_FILE_EXE
    fi

    if [ "$DUMP_JSON_TRACE" = "1" ]; then
      cp $INPUT_FILE_DIRNAME/visual-sbbv.json $OUTPUT_FILE_JSON
    fi

    if [ "$GENERATE_CFG" = "1" ]; then
      mv $INPUT_FILE_NO_EXT.cfg $OUTPUT_FILE_CFG_DOT
    fi
    ;;

  bigloo)
    C_COMPILER="gcc"
    BIGLOOCOMP="$COMPILER_DIR/bin/bigloo"
    BGLCFG="$COMPILER_DIR/bin/bglcfg"

    PATH="$COMPILER_DIR/bin:$PATH"

    if [ "$SAFETY_MODE" = "unsafe" ]; then
      UNSAFE_FLAG="-unsafe"
    else
      UNSAFE_FLAG=""
    fi



    BIGLOO_OPTIONS="-srfi arithmetic$ARITHMETIC -w $UNSAFE_FLAG -saw -cgen -o bbv.c"
    BIGLOO_C_OPTIONS="-Wno-unused-value -Wno-parentheses-equality -Wno-parentheses \
                      -Wno-invalid-source-encoding -Wno-return-type -Wno-trigraphs \
                      -fPIC -DBGL_NAN_TAGGING=0  -c   -I. -I. -I${COMPILER_DIR}/lib/bigloo/4.6a"
    BIGLOO_LD_OPTIONS="-o $OUTPUT_FILE_EXE -Wl,--enable-new-dtags,-rpath=${COMPILER_DIR}/lib/bigloo/4.6a \
                       -s -fPIC    -L. -L${COMPILER_DIR}/lib/bigloo/4.6a -lbigloo_u-4.6a -lbigloogc-4.6a \
                       -ldl -lc -lm -lgmp -lpcre2-8 -lunistring -lresolv -ldl"

    BIGLOOBBVVLENGTH=false
    BIGLOOBBVVERSIONLIMIT=
    BIGLOOBBVSTRATEGY=nearobj # ecoop 2024 strategy
    
    if [ "$OPTIM_LEVEL" = "0" ]; then
      BIGLOO_OPTIONS="$BIGLOO_OPTIONS -O0 -fno-user-inlining"
    else
      BIGLOO_OPTIONS="-srfi macros-constant-folding $BIGLOO_OPTIONS -Obench"
      BIGLOO_C_OPTIONS="-O3 $BIGLOO_C_OPTIONS"
      BIGLOO_LD_OPTIONS="-O3 $BIGLOO_LD_OPTIONS"
    fi
    if [ "$PRIMITIVE_COUNT" = "1" ]; then
      BIGLOO_C_OPTIONS="-DSAW_BBV_STATS=1 $BIGLOO_C_OPTIONS"
      BIGLOO_LD_OPTIONS="-DSAW_BBV_STATS=1 $BIGLOO_LD_OPTIONS"
    fi

    if [ "$VERSION_LIMIT" = "custom" ]; then
      echo "Bigloo does not support custom version limits"
      exit 1
    fi

    if [ "$VERSION_LIMIT" = "0" ]; then
      BIGLOO_OPTIONS="$BIGLOO_OPTIONS -fno-saw-bbv"
    else
      BIGLOO_OPTIONS="$BIGLOO_OPTIONS -fsaw-bbv"
      BIGLOOBBVVLENGTH=true
      BIGLOOBBVVERSIONLIMIT=$VERSION_LIMIT
    fi

    BIGLOOBBVCLEANUP=true
    BIGLOOSAWPROFILE=false
    BIGLOOBBVDUMPJSON=false
    if [ "$DUMP_JSON_TRACE" = "1" ]; then
      BIGLOOBBVCLEANUP=false
      BIGLOOSAWPROFILE=true
      BIGLOOBBVDUMPJSON=true
    fi

    # Compilation
    (cd $SCRIPT_DIR/bigloo && \
     BIGLOOBBVVLENGTH=$BIGLOOBBVVLENGTH \
     BIGLOOBBVSTRATEGY=$BIGLOOBBVSTRATEGY \
     BIGLOOBBVVERSIONLIMIT=$BIGLOOBBVVERSIONLIMIT \
     BIGLOOBBVCLEANUP=$BIGLOOBBVCLEANUP \
     BIGLOOSAWPROFILE=$BIGLOOSAWPROFILE \
     BIGLOOBBVDUMPJSON=$BIGLOOBBVDUMPJSON \
     "${WITH_SCHEME_COMPTIME[@]}" $BIGLOOCOMP $BIGLOO_OPTIONS bbv.bgl $INPUT_FILE && \
     "${WITH_C_COMPTIME[@]}" sh -c "($C_COMPILER $BIGLOO_C_OPTIONS bbv.c && \
                                                          $C_COMPILER bbv.o $BIGLOO_LD_OPTIONS)" && \
     rm bbv.c)

    if [ "$PRIMITIVE_COUNT" = "1" ]; then
      $OUTPUT_FILE_EXE
    fi

    if [ "$DUMP_JSON_TRACE" = "1" ]; then
      $OUTPUT_FILE_EXE > $OUTPUT_FILE_JSON
    fi

    if [ -f $OUTPUT_FILE_BASE-program.bbv.cfg ]; then
      (cd $SCRIPT_DIR/bigloo && $BGLCFG $OUTPUT_FILE_BASE-program.bbv.cfg > OUTPUT_FILE_CFG_DOT)
    fi
    ;;

  chez)
    CHEZ_OPTIONS="--quiet"

    if [ "$PRIMITIVE_COUNT" = "1" ]; then
      >&2 echo "WARNING: no support for Chez Scheme primitive count"
    fi
    if [ "$VERSION_LIMIT" != "0" ]; then
      >&2 echo "WARNING: no support for Chez Scheme BBV"
    fi

    if  [ "$COMPILER_DIR" = "" ]; then
      CHEZCOMP="scheme"
    else
      CHEZCOMP="$COMPILER_DIR/ta6le/bin/ta6le/scheme"
    fi

    if [ "$SAFE_ARITHMETIC" = "0" ]; then
      CHEZ_OPTIONS="$CHEZ_OPTIONS --optimize-level 3"
    else
      CHEZ_OPTIONS="$CHEZ_OPTIONS --optimize-level $(( OPTIM_LEVEL > 2 ? 2 : OPTIM_LEVEL ))"
    fi

    BBV_FILE="$SCRIPT_DIR/chez/bbv.scm"
    LIB_FILE="$SCRIPT_DIR/chez/lib.scm"
    MAIN_FILE="$SCRIPT_DIR/chez/main.scm"
    BUNDLE_FILE="$OUTPUT_FILE_BASE.scm"
    cat $BBV_FILE $LIB_FILE $INPUT_FILE $MAIN_FILE > $BUNDLE_FILE

    echo "#!/bin/bash" > $OUTPUT_FILE_EXE
    echo -n "(cd $INPUT_FILE_DIRNAME && " >> $OUTPUT_FILE_EXE
    echo "$CHEZCOMP $CHEZ_OPTIONS --script $BUNDLE_FILE \"\$@\")" >> $OUTPUT_FILE_EXE

    ;;
  racket)
    RACKET_OPTIONS="exe"

    if [ "$PRIMITIVE_COUNT" = "1" ]; then
      >&2 echo "WARNING: no support for Racket primitive count"
    fi
    if [ "$VERSION_LIMIT" != "0" ]; then
      >&2 echo "WARNING: no support for Racket BBV"
    fi

    if  [ "$COMPILER_DIR" = "" ]; then
      RACKETCOMP="raco"
    else
      RACKETCOMP="$COMPILER_DIR/racket/bin/raco"
    fi

    if [ "$SAFE_ARITHMETIC" = "0" ]; then
      >&2 echo "WARNING: no support for Racket usnafe arithmetic"
    fi

    BBV_FILE="$SCRIPT_DIR/racket/bbv.scm"
    LIB_FILE="$SCRIPT_DIR/racket/lib.scm"
    MAIN_FILE="$SCRIPT_DIR/racket/main.scm"
    RACKET_FILE="$OUTPUT_FILE_BASE.rkt"

    echo "#lang racket" > $RACKET_FILE
    cat $BBV_FILE $LIB_FILE $INPUT_FILE $MAIN_FILE >> $RACKET_FILE

    (cd $INPUT_FILE_DIRNAME && \
        $RACKETCOMP $RACKET_OPTIONS -o $OUTPUT_FILE_EXE $RACKET_FILE)
    ;;
  node)
    if [ "$PRIMITIVE_COUNT" = "1" ]; then
      >&2 echo "WARNING: no support for NodeJS primitive count"
    fi
    if [ "$VERSION_LIMIT" != "0" ]; then
      >&2 echo "WARNING: no support for NodeJS BBV"
    fi
    if [ "$SAFE_ARITHMETIC" = "0" ]; then
      >&2 echo "WARNING: no unsafe mode for NodeJS"
    fi
    if [ "$OPTIM_LEVEL" != "0" ]; then
      >&2 echo "WARNING: no optimisation level for NodeJS"
    fi

    if  [ "$COMPILER_DIR" = "" ]; then
      NODECOMP="node"
    else
      NODECOMP="$COMPILER_DIR/bin/node"
    fi

    echo "#!/bin/bash" > $OUTPUT_FILE_EXE
    echo "$NODECOMP --max-semi-space-size=100 $INPUT_FILE \"\$@\"" >> $OUTPUT_FILE_EXE
    ;;
esac

if [ "$PRIMITIVE_COUNT" != "1" ]; then
  chmod u+x $OUTPUT_FILE_EXE
  echo "$EXECUTABLE_NAME_MARKER $OUTPUT_FILE_EXE"
fi

if [ "$GENERATE_CFG" = "1" ]; then
  run_dot $OUTPUT_FILE_CFG_DOT
fi

if [ "$VIEW_CFG" = "1" ] ; then
  run_pdfviewer $OUTPUT_FILE_CFG_DOT.pdf
fi