#!/usr/bin/sh

 # install demo build dependencies

 set -u

 PKG_URL_ROOT="${PKG_URL_ROOT:-https://rwest.io/otom8/packy/bundle}"

 PKG_NAME="demo_build_deps"

 check_proc() {

     # Check for /proc by looking for the /proc/self/exe link

     # This only run on Linux

     if ! test -L /proc/self/exe ; then

         err "fatal: Unable to find /proc/self/exe.  Is /proc mounted?"

     fi

 }

 get_bitness() {

     need_cmd head

     # Architecture detection without dependencies beyond coreutils.

     # ELF files start out "\x7fELF", and the following byte is

     #   0x01 for 32-bit and

     #   0x02 for 64-bit.

     # The printf builtin on some shells like dash only supports octal

     # escape sequences, so we use those.

     local _current_exe_head

     _current_exe_head=$(head -c 5 /proc/self/exe )

     if [ "$_current_exe_head" = "$(printf '\177ELF\001')" ]; then

         echo 32

     elif [ "$_current_exe_head" = "$(printf '\177ELF\002')" ]; then

         echo 64

     else

         err "unknown platform bitness"

     fi

 }

 is_host_amd64_elf() {

     need_cmd head

     need_cmd tail

     # ELF e_machine detection without dependencies beyond coreutils.

     # Two-byte field at offset 0x12 indicates the CPU,

     # but we're interested in it being 0x3E to indicate amd64, or not that.

     local _current_exe_machine

     _current_exe_machine=$(head -c 19 /proc/self/exe | tail -c 1)

     [ "$_current_exe_machine" = "$(printf '\076')" ]

 }

 get_endianness() {

     local cputype=$1

     local suffix_eb=$2

     local suffix_el=$3

     # detect endianness without od/hexdump, like get_bitness() does.

     need_cmd head

     need_cmd tail

     local _current_exe_endianness

     _current_exe_endianness="$(head -c 6 /proc/self/exe | tail -c 1)"

     if [ "$_current_exe_endianness" = "$(printf '\001')" ]; then

         echo "${cputype}${suffix_el}"

     elif [ "$_current_exe_endianness" = "$(printf '\002')" ]; then

         echo "${cputype}${suffix_eb}"

     else

         err "unknown platform endianness"

     fi

 }

 get_architecture() {

     local _ostype _cputype _bitness _arch _clibtype

     _ostype="$(uname -s)"

     _cputype="$(uname -m)"

     _clibtype="gnu"

     if [ "$_ostype" = Linux ]; then

         if [ "$(uname -o)" = Android ]; then

             _ostype=Android

         fi

         if ldd --version 2>&1 | grep -q 'musl'; then

             _clibtype="musl"

         fi

     fi

     if [ "$_ostype" = Darwin ] && [ "$_cputype" = i386 ]; then

         # Darwin `uname -m` lies

         if sysctl hw.optional.x86_64 | grep -q ': 1'; then

             _cputype=x86_64

         fi

     fi

     if [ "$_ostype" = SunOS ]; then

         # Both Solaris and illumos presently announce as "SunOS" in "uname -s"

         # so use "uname -o" to disambiguate.  We use the full path to the

         # system uname in case the user has coreutils uname first in PATH,

         # which has historically sometimes printed the wrong value here.

         if [ "$(/usr/bin/uname -o)" = illumos ]; then

             _ostype=illumos

         fi

         # illumos systems have multi-arch userlands, and "uname -m" reports the

         # machine hardware name; e.g., "i86pc" on both 32- and 64-bit x86

         # systems.  Check for the native (widest) instruction set on the

         # running kernel:

         if [ "$_cputype" = i86pc ]; then

             _cputype="$(isainfo -n)"

         fi

     fi

     case "$_ostype" in

         Android)

             _ostype=linux-android

             ;;

         Linux)

             check_proc

             _ostype=unknown-linux-$_clibtype

             _bitness=$(get_bitness)

             ;;

         FreeBSD)

             _ostype=unknown-freebsd

             ;;

         NetBSD)

             _ostype=unknown-netbsd

             ;;

         DragonFly)

             _ostype=unknown-dragonfly

             ;;

         Darwin)

             _ostype=apple-darwin

             ;;

         illumos)

             _ostype=unknown-illumos

             ;;

         MINGW* | MSYS* | CYGWIN*)

             _ostype=pc-windows-gnu

             ;;

         *)

             err "unrecognized OS type: $_ostype"

             ;;

     esac

     case "$_cputype" in

         i386 | i486 | i686 | i786 | x86)

             _cputype=i686

             ;;

         xscale | arm)

             _cputype=arm

             if [ "$_ostype" = "linux-android" ]; then

                 _ostype=linux-androideabi

             fi

             ;;

         armv6l)

             _cputype=arm

             if [ "$_ostype" = "linux-android" ]; then

                 _ostype=linux-androideabi

             else

                 _ostype="${_ostype}eabihf"

             fi

             ;;

         armv7l | armv8l)

             _cputype=armv7

             if [ "$_ostype" = "linux-android" ]; then

                 _ostype=linux-androideabi

             else

                 _ostype="${_ostype}eabihf"

             fi

             ;;

         aarch64 | arm64)

             _cputype=aarch64

             ;;

         x86_64 | x86-64 | x64 | amd64)

             _cputype=x86_64

             ;;

         mips)

             _cputype=$(get_endianness mips '' el)

             ;;

         mips64)

             if [ "$_bitness" -eq 64 ]; then

                 # only n64 ABI is supported for now

                 _ostype="${_ostype}abi64"

                 _cputype=$(get_endianness mips64 '' el)

             fi

             ;;

         ppc)

             _cputype=powerpc

             ;;

         ppc64)

             _cputype=powerpc64

             ;;

         ppc64le)

             _cputype=powerpc64le

             ;;

         s390x)

             _cputype=s390x

             ;;

         riscv64)

             _cputype=riscv64gc

             ;;

         *)

             err "unknown CPU type: $_cputype"

     esac

     # Detect 64-bit linux with 32-bit userland

     if [ "${_ostype}" = unknown-linux-gnu ] && [ "${_bitness}" -eq 32 ]; then

         case $_cputype in

             x86_64)

                 if [ -n "${BABEL_CPUTYPE:-}" ]; then

                     _cputype="$BABEL_CPUTYPE"

                 else {

                     # 32-bit executable for amd64 = x32

                     if is_host_amd64_elf; then {

                          echo "This host is running an x32 userland; as it stands, x32 support is poor," 1>&2

                          echo "and there isn't a native toolchain -- you will have to install" 1>&2

                          echo "multiarch compatibility with i686 and/or amd64, then select one" 1>&2

                          echo "by re-running this script with the BABEL_CPUTYPE environment variable" 1>&2

                          echo "set to i686 or x86_64, respectively." 1>&2

                          echo 1>&2

                          exit 1

                     }; else

                         _cputype=i686

                     fi

                 }; fi

                 ;;

             mips64)

                 _cputype=$(get_endianness mips '' el)

                 ;;

             powerpc64)

                 _cputype=powerpc

                 ;;

             aarch64)

                 _cputype=armv7

                 if [ "$_ostype" = "linux-android" ]; then

                     _ostype=linux-androideabi

                 else

                     _ostype="${_ostype}eabihf"

                 fi

                 ;;

             riscv64gc)

                 err "riscv64 with 32-bit userland unsupported"

                 ;;

         esac

     fi

     # Detect armv7 but without the CPU features Rust needs in that build,

     # and fall back to arm.

     # See https://github.com/rust-lang/rustup.rs/issues/587.

     if [ "$_ostype" = "unknown-linux-gnueabihf" ] && [ "$_cputype" = armv7 ]; then

         if ensure grep '^Features' /proc/cpuinfo | grep -q -v neon; then

             # At least one processor does not have NEON.

             _cputype=arm

         fi

     fi

     _arch="${_cputype}-${_ostype}"

     RETVAL="$_arch"

 }

 say() {

     printf 'dep.sh: %s\n' "$1"

 }

 err() {

     say "$1" >&2; exit 1

 }

 need_cmd() {

     if ! check_cmd "$1"; then

         err "need '$1' (command not found)"

     fi

 }

 check_cmd() {

     command -v "$1" > /dev/null 2>&1

 }

 assert_nz() {

     if [ -z "$1" ]; then err "assert_nz $2"; fi

 }

 ensure() {

     if ! "$@"; then err "command failed: $*"; fi

 }

 ignore() {

     "$@"

 }

 main () {

     need_cmd chmod

     need_cmd mkdir

     need_cmd rm

     get_architecture || return 1

     local _arch="$RETVAL"

     assert_nz "$_arch" "arch"

     # no extension unless on windows

     local _ext=""

     case "$_arch" in

         *windows*)

             _ext=".exe"

             ;;

     esac

   local _url="${PKG_URL_ROOT}/bin/dist/${_arch}/${PKG_NAME}${_ext}"

     local _dir

     _dir="$(ensure mktemp -d)"

     local _file="${_dir}/${PKG_NAME}${_ext}"

     local _ansi_escapes_are_valid=false

     if [ -t 2 ]; then

         if [ "${TERM+set}" = 'set' ]; then

             case "$TERM" in

                 xterm*|rxvt*|urxvt*|linux*|vt*)

                     _ansi_escapes_are_valid=true

                 ;;

             esac

         fi

     fi

     # check if we have to use /dev/tty to prompt the user

     local need_tty=yes

     for arg in "$@"; do

         case "$arg" in

             q)

                 # user wants to skip the prompt --

                 # we don't need /dev/tty

                 need_tty=no

                 ;;

             *)

                 ;;

         esac

     done

     if $_ansi_escapes_are_valid; then

     else

     fi

     ensure mkdir -p "$_dir"

     ensure dl "$_url" "$_file" "$_arch"

     ensure chmod u+x "$_file"

     if [ ! -x "$_file" ]; then

         printf '%s\n' "Cannot execute $_file (likely because of mounting /tmp as noexec)." 1>&2

         printf '%s\n' "Please copy the file to a location where you can execute binaries and run ./${PKG_NAME}${_ext}." 1>&2

         exit 1

     fi

     if [ "$need_tty" = "yes" ]; then

         # The installer is going to want to ask for confirmation by

         # reading stdin.  This script was piped into `sh` though and

         # doesn't have stdin to pass to its children. Instead we're going

         # to explicitly connect /dev/tty to the installer's stdin.

         if [ ! -t 1 ]; then

             err "Unable to run interactively. Run with -y to accept defaults"

         fi

         ignore "$_file" "$@" < /dev/tty

     else

         ignore "$_file" "$@"

     fi

     local _retval=$?

     ignore rm "$_file"

     ignore rmdir "$_dir"

     return "$_retval"

 }

 dl() { # curl || wget

     local _dld

     local _ciphersuites

     local _err

     local _status

     if check_cmd curl; then

         _dld=curl

     elif check_cmd wget; then

         _dld=wget

     else

         _dld='curl or wget' # to be used in error message of need_cmd

     fi

     if [ "$1" = --check ]; then

         need_cmd "$_dld"

     elif [ "$_dld" = curl ]; then

         get_ciphersuites_for_curl

         _ciphersuites="$RETVAL"

         if [ -n "$_ciphersuites" ]; then

             _err=$(curl --proto '=https' --tlsv1.2 --ciphers "$_ciphersuites" --silent --show-error --fail --location "$1" --output "$2" 2>&1)

             _status=$?

         else

             echo "Warning: Not enforcing strong cipher suites for TLS, this is potentially less secure"

             if ! check_help_for "$3" curl --proto --tlsv1.2; then

                 echo "Warning: Not enforcing TLS v1.2, this is potentially less secure"

                 _err=$(curl --silent --show-error --fail --location "$1" --output "$2" 2>&1)

                 _status=$?

             else

                 _err=$(curl --proto '=https' --tlsv1.2 --silent --show-error --fail --location "$1" --output "$2" 2>&1)

                 _status=$?

             fi

         fi

         if [ -n "$_err" ]; then

             echo "$_err" >&2

             if echo "$_err" | grep -q 404$; then

                 err "installer for platform '$3' not found 8^C - ask ellis to support your platform"

             fi

         fi

         return $_status

     elif [ "$_dld" = wget ]; then