view vext @ 1741:287a1d388b8d

Update subrepos, add to ignore list

#!/bin/bash

# Disable shellcheck warnings for useless-use-of-cat. UUOC is good
# practice, not bad: clearer, safer, less error-prone.
# shellcheck disable=SC2002

sml="$VEXT_SML"

set -eu

mydir=$(dirname "$0")
program="$mydir/vext.sml"

hasher=
local_install=
if [ -w "$mydir" ]; then
    if echo | sha256sum >/dev/null 2>&1 ; then
	hasher=sha256sum
        local_install=true
    elif echo | shasum >/dev/null 2>&1 ; then
	hasher=shasum
	local_install=true
    else
        echo "WARNING: sha256sum or shasum program not found" 1>&2
    fi
fi

if [ -n "$local_install" ]; then
    hash=$(echo "$sml" | cat "$program" - | $hasher | cut -c1-16)
    gen_sml=$mydir/.vext-$hash.sml
    gen_out=$mydir/.vext-$hash.bin
    trap 'rm -f $gen_sml' 0
else
    gen_sml=$(mktemp /tmp/vext-XXXXXXXX.sml)
    gen_out=$(mktemp /tmp/vext-XXXXXXXX.bin)
    trap 'rm -f $gen_sml $gen_out' 0
fi

if [ -x "$gen_out" ]; then
    exec "$gen_out" "$@"
fi

# We need one of Poly/ML, SML/NJ, or MLton. Since we're running a
# single-file SML program as if it were a script, our order of
# preference is based on startup speed, except in the local_install
# case where we retain a persistent binary.

if [ -z "$sml" ]; then
    if [ -n "$local_install" ] && mlton 2>&1 | grep -q 'MLton'; then
	sml="mlton"
    elif sml -h 2>&1 | grep -q 'Standard ML of New Jersey'; then
	sml="smlnj"
    # We would prefer Poly/ML to SML/NJ, except that Poly v5.7 has a
    # nasty bug that occasionally causes it to deadlock on startup.
    # That appears to be fixed in their repo, so we could promote it
    # up the order again at some point in future
    elif echo | poly -v 2>/dev/null | grep -q 'Poly/ML'; then
	sml="poly"
    elif mlton 2>&1 | grep -q 'MLton'; then
	sml="mlton"
    else cat 1>&2 <<EOF

ERROR: No supported SML compiler or interpreter found       
EOF
	cat <<EOF

  The Vext external source code manager needs a Standard ML (SML)
  compiler or interpreter to run.

  Please ensure you have one of the following SML implementations
  installed and present in your PATH, and try again.

    1. Standard ML of New Jersey
       - often found in a distribution package called: smlnj
       - executable name: sml

    2. Poly/ML
       - often found in a distribution package called: polyml
       - executable name: poly

    3. MLton
       - often found in a distribution package called: mlton
       - executable name: mlton

EOF
	exit 2
    fi
fi

arglist=""
for arg in "$@"; do
    if [ -n "$arglist" ]; then arglist="$arglist,"; fi
    if echo "$arg" | grep -q '[^a-z]' ; then
	arglist="$arglist\"usage\""
    else
	arglist="$arglist\"$arg\""
    fi
done

case "$sml" in
    poly)
        if [ -n "$local_install" ] && polyc --help >/dev/null 2>&1 ; then
            if [ ! -x "$gen_out" ]; then
                polyc -o "$gen_out" "$program"
            fi
	    "$gen_out" "$@"
        else
            echo 'use "'"$program"'"; vext ['"$arglist"'];' |
                poly -q --error-exit
        fi ;;
    mlton)
        if [ ! -x "$gen_out" ]; then
	    echo "val _ = main ()" | cat "$program" - > "$gen_sml"
	    mlton -output "$gen_out" "$gen_sml"
        fi
	"$gen_out" "$@" ;;
    smlnj)
	cat "$program" | (
	    cat <<EOF
val smlrun__cp = 
    let val x = !Control.Print.out in
        Control.Print.out := { say = fn _ => (), flush = fn () => () };
        x
    end;
val smlrun__prev = ref "";
Control.Print.out := { 
    say = fn s => 
        (if String.isSubstring " Error" s
         then (Control.Print.out := smlrun__cp;
               (#say smlrun__cp) (!smlrun__prev);
               (#say smlrun__cp) s)
         else (smlrun__prev := s; ())),
    flush = fn s => ()
};
EOF
	    cat -
	    cat <<EOF
val _ = vext [$arglist];
val _ = OS.Process.exit (OS.Process.success);
EOF
            ) > "$gen_sml"
	CM_VERBOSE=false sml "$gen_sml" ;;
    *)
	echo "Unknown SML implementation name: $sml";
	exit 2 ;;
esac