#!/usr/bin/env bash
#
# Usage: go-build [-kpv] <definition> <prefix>
#        go-build --definitions
#        go-build --version
#
#   -k/--keep        Do not remove source tree after installation
#   -v/--verbose     Verbose mode: print compilation status to stdout
#   -4/--ipv4        Resolve names to IPv4 addresses only
#   -6/--ipv6        Resolve names to IPv6 addresses only
#   --definitions    List all built-in definitions
#   --version        Show version of go-build
#   -g/--debug       Build a debug version
#

GO_BUILD_VERSION="20160417"

OLDIFS="$IFS"

set -E
exec 3<&2 # preserve original stderr at fd 3

# Verbose output in debug mode
[ -n "$GOENV_DEBUG" ] && {
    set -x
}

lib() {
  parse_options() {
    OPTIONS=()
    ARGUMENTS=()
    local arg option index

    for arg in "$@"; do
      if [ "${arg:0:1}" = "-" ]; then
        if [ "${arg:1:1}" = "-" ]; then
          OPTIONS[${#OPTIONS[*]}]="${arg:2}"
        else
          index=1
          while option="${arg:$index:1}"; do
            [ -n "$option" ] || break
            OPTIONS[${#OPTIONS[*]}]="$option"
            index=$(($index+1))
          done
        fi
      else
        ARGUMENTS[${#ARGUMENTS[*]}]="$arg"
      fi
    done
  }

  if [ "$1" == "--$FUNCNAME" ]; then
    declare -f "$FUNCNAME"
    echo "$FUNCNAME \"\$1\";"
    exit
  fi
}
lib "$1"


resolve_link() {
  $(type -p greadlink readlink | head -1) "$1"
}

abs_dirname() {
  local cwd="$(pwd)"
  local path="$1"

  while [ -n "$path" ]; do
    cd "${path%/*}"
    local name="${path##*/}"
    path="$(resolve_link "$name" || true)"
  done

  pwd
  cd "$cwd"
}

capitalize() {
  printf "%s" "$1" | tr a-z A-Z
}

sanitize() {
  printf "%s" "$1" | sed "s/[^A-Za-z0-9.-]/_/g; s/__*/_/g"
}

colorize() {
  if [ -t 1 ]; then printf "\e[%sm%s\e[m" "$1" "$2"
  else echo -n "$2"
  fi
}

os_information() {
  if type -p lsb_release >/dev/null; then
    lsb_release -sir | xargs echo
  elif type -p sw_vers >/dev/null; then
    echo "OS X $(sw_vers -productVersion)"
  elif [ -r /etc/os-release ]; then
    source /etc/os-release
    echo "$NAME" $VERSION_ID
  else
    local os="$(cat /etc/{centos,redhat,fedora,system}-release /etc/debian_version 2>/dev/null | head -1)"
    echo "${os:-$(uname -sr)}"
  fi
}

is_mac() {
  [ "$(uname -s)" = "Darwin" ] || return 1
  [ $# -eq 0 ] || [ "$(osx_version)" "$@" ]
}

# NOTE: Converts OSX version to compareable
# int
#  0.9.1  -> 901
# 0.10.9  -> 1009
# 0.10.10 -> 1010
osx_version() {
  local -a ver

  OLDIFS=$IFS
  IFS=.
  ver=( `sw_vers -productVersion` )
  IFS=$OLDIFS
  OSX_VER=$(( ${ver[1]} * 100 + ${ver[2]} ))
}

build_failed() {
  { echo
    colorize 1 "BUILD FAILED"
    echo " ($(os_information) using $(version))"
    echo

    if ! rmdir "${BUILD_PATH}" 2>/dev/null; then
      echo "Inspect or clean up the working tree at ${BUILD_PATH}"

      if file_is_not_empty "$LOG_PATH"; then
        colorize 33 "Results logged to ${LOG_PATH}"
        printf "\n\n"
        echo "Last 10 log lines:"
        tail -n 10 "$LOG_PATH"
      fi
    fi
  } >&3
  exit 1
}

file_is_not_empty() {
  local filename="$1"
  local line_count="$(wc -l "$filename" 2>/dev/null || true)"

  if [ -n "$line_count" ]; then
    words=( $line_count )
    [ "${words[0]}" -gt 0 ]
  else
    return 1
  fi
}

num_cpu_cores() {
  local num
  case "$(uname -s)" in
  Darwin | *BSD )
    num="$(sysctl -n hw.ncpu 2>/dev/null || true)"
    ;;
  * )
    num="$(grep ^processor /proc/cpuinfo 2>/dev/null | wc -l | xargs)"
    num="${num#0}"
    ;;
  esac
  echo "${num:-2}"
}

install_darwin_64bit() {
    if [ "$(uname -s)" = "Darwin" ]; then
        local arch="$(uname -m)"

        if [ $arch = "x86_64" ]; then
            install_package_using "tarball" 1 "$@"
        fi
    fi
}

install_darwin_106_64bit() {
    if [ "$(uname -s)" = "Darwin" ]; then
        local arch="$(uname -m)"

        if [ $arch = "x86_64" ]; then
            osx_version

            if [ $(echo $OSX_VER | bc) -ge 1060 ] && [ $(echo $OSX_VER | bc) -lt 1080 ]; then
                install_package_using "tarball" 1 "$@"
            fi
        fi
    fi
}

install_darwin_106_32bit() {
    if [ "$(uname -s)" = "Darwin" ]; then
        local arch="$(uname -m)"

        if [ $arch = "i386" ] || [ $arch = 'i686' ]; then
            osx_version

            if [ $(echo $OSX_VER | bc) -ge 1060 ] && [ $(echo $OSX_VER | bc) -lt 1080 ]; then
                install_package_using "tarball" 1 "$@"
            fi
        fi
    fi
}

install_darwin_108_64bit() {
    if [ "$(uname -s)" = "Darwin" ]; then
        local arch="$(uname -m)"

        if [ $arch = "x86_64" ]; then
            osx_version

            if [ $(echo $OSX_VER | bc) -ge 1080 ]; then
                install_package_using "tarball" 1 "$@"
            fi
        fi
    fi
}

install_darwin_108_32bit() {
    if [ "$(uname -s)" = "Darwin" ]; then
        local arch="$(uname -m)"

        if [ $arch = "i386" ] || [ $arch = 'i686' ]; then
            osx_version

            if [ $(echo $OSX_VER | bc) -ge 1080 ]; then
                install_package_using "tarball" 1 "$@"
            fi
        fi
    fi
}


install_linux_64bit() {
    if [ "$(uname -s)" = "Linux" ]; then
        local arch="$(uname -m)"

        if [ $arch = "x86_64" ]; then
            install_package_using "tarball" 1 "$@"
        fi
    fi
}

install_linux_32bit() {
    if [ "$(uname -s)" = "Linux" ]; then
        local arch="$(uname -m)"

        if [ $arch = "i386" ] || [ $arch = 'i686' ]; then
          install_package_using "tarball" 1 "$@"
        fi
    fi
}

install_linux_arm() {
    if [ "$(uname -s)" = "Linux" ]; then
        local arch="$(uname -m)"

        if [ $arch = "armv6l" ] || [ $arch = "armv7l" ]; then
            install_package_using "tarball" 1 "$@"
        fi
    fi
}

install_bsd_64bit() {
    if [ "$(uname -s)" = "FreeBSD" ]; then
        local arch="$(uname -m)"

        if [ $arch = "x86_64" ] || [ $arch = 'amd64' ]; then
            install_package_using "tarball" 1 "$@"
        fi
    fi
}

install_bsd_32bit() {
    if [ "$(uname -s)" = "FreeBSD" ]; then
        local arch="$(uname -m)"

        if [ $arch = "i386" ] || [ $arch = 'i686' ]; then
            install_package_using "tarball" 1 "$@"
        fi
    fi
}

install_package_using() {
  local package_type="$1"
  local package_type_nargs="$2"
  local package_name="$3"
  shift 3

  local fetch_args=( "$package_name" "${@:1:$package_type_nargs}" )
  local make_args=( "$package_name" )
  local arg last_arg

  pushd "$BUILD_PATH" >&4
  "fetch_${package_type}" "${fetch_args[@]}"
  make_package "$package_name"
  popd >&4

  { echo "Installed ${package_name} to ${PREFIX_PATH}"
    echo
  } >&2
}

make_package() {
  pushd "go" >&4
  local package_name="$1"
  shift
  echo "Installing ${package_name}..." >&2
  build_package_copy
  fix_directory_permissions
  popd >&4
}

compute_sha2() {
  local output
  if type shasum &>/dev/null; then
    output="$(shasum -a 256 -b)" || return 1
    echo "${output% *}"
  elif type openssl &>/dev/null; then
    local openssl="$(command -v "$(brew --prefix openssl 2>/dev/null || true)"/bin/openssl openssl | head -1)"
    output="$("$openssl" dgst -sha256 2>/dev/null)" || return 1
    echo "${output##* }"
  elif type sha256sum &>/dev/null; then
    output="$(sha256sum --quiet)" || return 1
    echo "${output% *}"
  else
    return 1
  fi
}

compute_sha1() {
    local output
    if type shasum &>/dev/null; then
        output="$(shasum -a 1 -b)" || return 1
        echo "${output% *}"
    elif type openssl &>/dev/null; then
        local openssl="$(command -v "$(brew --prefix openssl 2>/dev/null || true)"/bin/openssl openssl | head -1)"
        output="$("$openssl" dgst -sha1 2>/dev/null)" || return 1
        echo "${output##* }"
    elif type sha1sum &>/dev/null; then
        output="$(sha1sum --quiet)" || return 1
        echo "${output% *}"
    else
        return 1
    fi
}

compute_md5() {
  local output
  if type md5 &>/dev/null; then
    md5 -q
  elif type openssl &>/dev/null; then
    output="$(openssl md5)" || return 1
    echo "${output##* }"
  elif type md5sum &>/dev/null; then
    output="$(md5sum -b)" || return 1
    echo "${output% *}"
  else
    return 1
  fi
}

has_checksum_support() {
  local checksum_command="$1"
  local has_checksum_var="HAS_CHECKSUM_SUPPORT_${checksum_command}"

  if [ -z "${!has_checksum_var+defined}" ]; then
    printf -v "$has_checksum_var" "$(echo test | "$checksum_command" >/dev/null; echo $?)"
  fi
  return "${!has_checksum_var}"
}

verify_checksum() {
  local checksum_command
  local filename="$1"
  local expected_checksum="$(echo "$2" | tr [A-Z] [a-z])"

  # If the specified filename doesn't exist, return success
  [ -e "$filename" ] || return 0

  case "${#expected_checksum}" in
  0) return 0 ;; # empty checksum; return success
  32) checksum_command="compute_md5" ;;
  40) checksum_command="compute_sha1" ;;
  64) checksum_command="compute_sha2" ;;
  *)
    { echo
      echo "unexpected checksum length: ${#expected_checksum} (${expected_checksum})"
      echo "expected 0 (no checksum), 32 (MD5), 40 (SHA1) or 64 (SHA2-256)"
      echo
    } >&4
    return 1 ;;
  esac

  # If chosen provided checksum algorithm isn't supported, return success
  has_checksum_support "$checksum_command" || return 0

  # If the computed checksum is empty, return failure
  local computed_checksum=`echo "$($checksum_command < "$filename")" | tr [A-Z] [a-z]`
  [ -n "$computed_checksum" ] || return 1

  if [ "$expected_checksum" != "$computed_checksum" ]; then
    { echo
      echo "checksum mismatch: ${filename} (file is corrupt)"
      echo "expected $expected_checksum, got $computed_checksum"
      echo
    } >&4
    return 1
  fi
}

http() {
  local method="$1"
  local url="$2"
  local file="$3"
  [ -n "$url" ] || return 1

  if type curl &>/dev/null; then
    "http_${method}_curl" "$url" "$file"
  elif type wget &>/dev/null; then
    "http_${method}_wget" "$url" "$file"
  else
    echo "error: please install \`curl\` or \`wget\` and try again" >&2
    exit 1
  fi
}

http_head_curl() {
  options=""
  [ -n "${IPV4}" ] && options="--ipv4"
  [ -n "${IPV6}" ] && options="--ipv6"
  curl -qsILf ${options} "$1" >&4 2>&1
}

http_get_curl() {
  options=""
  [ -n "${IPV4}" ] && options="--ipv4"
  [ -n "${IPV6}" ] && options="--ipv6"
  curl -q -o "${2:--}" -sSLf ${options} "$1"
}

http_head_wget() {
  options=""
  [ -n "${IPV4}" ] && options="--inet4-only"
  [ -n "${IPV6}" ] && options="--inet6-only"
  wget -q --spider ${options} "$1" >&4 2>&1
}

http_get_wget() {
  options=""
  [ -n "${IPV4}" ] && options="--inet4-only"
  [ -n "${IPV6}" ] && options="--inet6-only"
  wget -nv ${options} -O "${2:--}" "$1"
}

fetch_tarball() {
  local package_name="$1"
  local package_url="$2"
  local mirror_url
  local checksum

  if [ "$package_url" != "${package_url/\#}" ]; then
    checksum="${package_url#*#}"
    package_url="${package_url%%#*}"

    if [ -n "$GO_BUILD_MIRROR_URL" ]; then
      if [[ -z "$GO_BUILD_DEFAULT_MIRROR" || $package_url != */www.golang.org/* ]]; then
        mirror_url="${GO_BUILD_MIRROR_URL}/$checksum"
      fi
    fi
  fi

  local tar_args="xzf"
  local package_filename="${package_name}.tar.gz"

  if [ "$package_url" != "${package_url%bz2}" ]; then
    if ! type -p bzip2 >/dev/null; then
      echo "warning: bzip2 not found; consider installing \`bzip2\` package" >&4
    fi
    package_filename="${package_filename%.gz}.bz2"
    tar_args="${tar_args/z/j}"
  fi

   if [ "$package_url" != "${package_url%xz}" ]; then
     if ! type -p xz >/dev/null; then
      echo "warning: xz not found; consider installing \`xz\` package" >&4
     fi
     package_filename="${package_filename%.gz}.xz"
     tar_args="${tar_args/z/J}"
   fi

  if ! reuse_existing_tarball "$package_filename" "$checksum"; then
    local tarball_filename=$(basename $package_url)
    echo "Downloading ${tarball_filename}..." >&2
    http head "$mirror_url" &&
    download_tarball "$mirror_url" "$package_filename" "$checksum" ||
    download_tarball "$package_url" "$package_filename" "$checksum"
  fi

  { if tar $tar_args "$package_filename"; then
      if [ -z "$KEEP_BUILD_PATH" ]; then
        rm -f "$package_filename"
      else
        true
      fi
    fi
  } >&4 2>&1
}

reuse_existing_tarball() {
  local package_filename="$1"
  local checksum="$2"

  # Reuse existing file in build location
  if [ -e "$package_filename" ] && verify_checksum "$package_filename" "$checksum"; then
    return 0
  fi

  # Reuse previously downloaded file in cache location
  [ -n "$GO_BUILD_CACHE_PATH" ] || return 1
  local cached_package_filename="${GO_BUILD_CACHE_PATH}/$package_filename"

  [ -e "$cached_package_filename" ] || return 1
  verify_checksum "$cached_package_filename" "$checksum" >&4 2>&1 || return 1
  ln -s "$cached_package_filename" "$package_filename" >&4 2>&1 || return 1
}

download_tarball() {
  local package_url="$1"
  [ -n "$package_url" ] || return 1

  local package_filename="$2"
  local checksum="$3"

  echo "-> $package_url" >&2

  if http get "$package_url" "$package_filename" >&4 2>&1; then
    verify_checksum "$package_filename" "$checksum" >&4 2>&1 || return 1
  else
    echo "error: failed to download $package_filename" >&2
    return 1
  fi

  if [ -n "$GO_BUILD_CACHE_PATH" ]; then
    local cached_package_filename="${GO_BUILD_CACHE_PATH}/$package_filename"
    { mv "$package_filename" "$cached_package_filename"
      ln -s "$cached_package_filename" "$package_filename"
    } >&4 2>&1 || return 1
  fi
}

fetch_git() {
  local package_name="$1"
  local git_url="$2"
  local git_ref="$3"

  echo "Cloning ${git_url}..." >&2

  if type git &>/dev/null; then
    if [ -n "$GO_BUILD_CACHE_PATH" ]; then
      pushd "$GO_BUILD_CACHE_PATH" >&4
      local clone_name="$(sanitize "$git_url")"
      if [ -e "${clone_name}" ]; then
        { cd "${clone_name}"
          git fetch --force "$git_url" "+${git_ref}:${git_ref}"
        } >&4 2>&1
      else
        git clone --bare --branch "$git_ref" "$git_url" "${clone_name}" >&4 2>&1
      fi
      git_url="$GO_BUILD_CACHE_PATH/${clone_name}"
      popd >&4
    fi

    if [ -e "${package_name}" ]; then
      ( cd "${package_name}"
        git fetch --depth 1 origin "+${git_ref}"
        git checkout -q -B "$git_ref" "origin/${git_ref}"
      ) >&4 2>&1
    else
      git clone --depth 1 --branch "$git_ref" "$git_url" "${package_name}" >&4 2>&1
    fi
  else
    echo "error: please install \`git\` and try again" >&2
    exit 1
  fi
}

fetch_zip() {
  local package_name="$1"
  local package_url="$2"
  local mirror_url
  local checksum

  if [ "$package_url" != "${package_url/\#}" ]; then
    checksum="${package_url#*#}"
    package_url="${package_url%%#*}"

    if [ -n "$GO_BUILD_MIRROR_URL" ]; then
      mirror_url="${GO_BUILD_MIRROR_URL}/$checksum"
    fi
  fi

  local package_filename="${package_name}.zip"

  if ! reuse_existing_tarball "$package_filename" "$checksum"; then
    echo "Downloading ${package_filename}..." >&2
    http head "$mirror_url" &&
    download_tarball "$mirror_url" "$package_filename" "$checksum" ||
    download_tarball "$package_url" "$package_filename" "$checksum"
  fi

  { if unzip "$package_filename"; then
      if [ -z "$KEEP_BUILD_PATH" ]; then
        rm -f "$package_filename"
      else
        true
      fi
    fi
  } >&4 2>&1
}

package_option() {
  local package_name="$1"
  local command_name="$2"
  local variable="$(capitalize "${package_name}_${command_name}")_OPTS_ARRAY"
  local array="$variable[@]"
  shift 2
  local value=( "${!array}" "$@" )
  eval "$variable=( \"\${value[@]}\" )"
}

build_package_standard() {
  local package_name="$1"
  echo $package_name
}

build_package_copy() {
  mkdir -p "$PREFIX_PATH"
  cp -fR . "$PREFIX_PATH"
}

fix_directory_permissions() {
  # Ensure installed directories are not world-writable to avoid Bundler warnings
  find "$PREFIX_PATH" -type d \( -perm -020 -o -perm -002 \) -exec chmod go-w {} \;
}

configured_with_package_dir() {
  local package_var_name="$(capitalize "$1")"
  shift 1
  local PACKAGE_CONFIGURE_OPTS="${package_var_name}_CONFIGURE_OPTS"
  local PACKAGE_CONFIGURE_OPTS_ARRAY="${package_var_name}_MAKE_OPTS_ARRAY[@]"
  local arg flag
  for arg in ${CONFIGURE_OPTS} ${!PACKAGE_CONFIGURE_OPTS} "${!PACKAGE_CONFIGURE_OPTS_ARRAY}"; do
    if [[ "$arg" == "CPPFLAGS="* ]]; then
      for flag in ${CPPFLAGS} ${arg##CPPFLAGS=}; do
        if [[ "$flag" == "-I"* ]]; then
          local header
          for header in "$@"; do
            if [ -e "${flag##-I}/${header#/}" ]; then
              return 0
            fi
          done
        fi
      done
    fi
  done
  return 1
}

needs_yaml() {
  ! configured_with_package_dir "go" "yaml.h" &&
  ! use_homebrew_yaml
}

use_homebrew_yaml() {
  local libdir="$(brew --prefix libyaml 2>/dev/null || true)"
  if [ -d "$libdir" ]; then
    export CPPFLAGS="-I$libdir/include ${CPPFLAGS}"
    export LDFLAGS="-L$libdir/lib ${LDFLAGS}"
  else
    return 1
  fi
}

verify_go() {
  if [[ "$GO_CONFIGURE_OPTS" == *"--enable-framework"* ]]; then
    # Only symlinks are installed in ${PREFIX_PATH}/bin
    rm -fr "${PREFIX_PATH}/bin"
    ln -fs "${PREFIX_PATH}/Go.framework/Versions/Current/bin" "${PREFIX_PATH}/bin"
  fi

  # Not create symlinks on `altinstall` (#255)
  if [[ "$GO_MAKE_INSTALL_TARGET" != *"altinstall"* ]]; then
    local suffix="${1#go}"
    local file link
    shopt -s nullglob
    for file in "${PREFIX_PATH}/bin"/*; do
      unset link
      case "${file}" in
      */"go${suffix}-config" )
        # Symlink `goX.Y-config` to `go-config` if `go-config` is missing (#296)
        link="${file%/*}/go-config"
      ;;
      */*"-${suffix}" )
        link="${file%%-${suffix}}"
      ;;
      */*"${suffix}" )
        link="${file%%${suffix}}"
      ;;
      esac
      if [ -n "$link" ] && [ ! -e "$link" ]; then
        ( cd "${file%/*}" && ln -fs "${file##*/}" "${link##*/}" )
      fi
    done
    shopt -u nullglob
  fi

  if [ ! -x "${GO_BIN}" ]; then
    { colorize 1 "ERROR"
      echo ": invalid Go executable: ${GO_BIN}"
      echo
      echo "The go-build could not find proper executable of Go after successful build."
      echo "Please open an issue for future improvements."
      echo "https://github.com/yyuu/goenv/issues"
      return 1
    } >&3
  fi
}

try_go_module() {
  if ! "$GO_BIN" -c "import $1" 1>/dev/null 2>&1; then
    { colorize 1 "WARNING"
      echo ": The Go $1 extension was not compiled. Missing the ${2:-$1}?"
      return 0
    } >&3
  fi
}

verify_go_module() {
  if ! "$GO_BIN" -c "import $1" 1>/dev/null 2>&1; then
    { colorize 1 "ERROR"
      echo ": The Go $1 extension was not compiled. Missing the ${2:-$1}?"
      echo
      echo "Please consult to the Wiki page to fix the problem."
      echo "https://github.com/yyuu/goenv/wiki/Common-build-problems"
      echo
      return 1
    } >&3
  fi
}

version() {
  local git_revision
  # Read the revision from git if the remote points to "go-build" repository
  if GIT_DIR="$GO_BUILD_INSTALL_PREFIX/../../.git" git remote -v 2>/dev/null | grep -q /goenv; then
    git_revision="$(GIT_DIR="$GO_BUILD_INSTALL_PREFIX/../../.git" git describe --tags HEAD 2>/dev/null || true)"
    git_revision="${git_revision#v}"
  fi
  echo "go-build ${git_revision:-$GO_BUILD_VERSION}"
}

usage() {
  sed -ne '/^#/!q;s/.\{1,2\}//;1,2d;p' < "$0"
  [ -z "$1" ] || exit "$1"
}

list_definitions() {
  { for DEFINITION_DIR in "${GO_BUILD_DEFINITIONS[@]}"; do
      [ -d "$DEFINITION_DIR" ] && find "$DEFINITION_DIR" -maxdepth 1 -type f -print0 | xargs -0 -n 1 basename 2>/dev/null
    done
  } | sort_versions | uniq
}

sort_versions() {
  sed 'h; s/[+-]/./g; s/.p\([[:digit:]]\)/.z\1/; s/$/.z/; G; s/\n/ /' | \
    LC_ALL=C sort -t. -k 1,1 -k 2,2n -k 3,3n -k 4,4n -k 5,5n | awk '{print $2}'
}


unset VERBOSE
unset KEEP_BUILD_PATH
unset DEBUG
unset IPV4
unset IPV6

GO_BUILD_INSTALL_PREFIX="$(abs_dirname "$0")/.."

IFS=: GO_BUILD_DEFINITIONS=($GO_BUILD_DEFINITIONS ${GO_BUILD_ROOT:-$GO_BUILD_INSTALL_PREFIX}/share/go-build)
IFS="$OLDIFS"

parse_options "$@"

for option in "${OPTIONS[@]}"; do
  case "$option" in
  "h" | "help" )
    version
    echo
    usage 0
    ;;
  "definitions" )
    list_definitions
    exit 0
    ;;
  "k" | "keep" )
    KEEP_BUILD_PATH=true
    ;;
  "v" | "verbose" )
    VERBOSE=true
    ;;
  "g" | "debug" )
    DEBUG=true
    ;;
  "4" | "ipv4")
    IPV4=true
    ;;
  "6" | "ipv6")
    IPV6=true
    ;;
  "version" )
    version
    exit 0
    ;;
  esac
done

[ "${#ARGUMENTS[@]}" -eq 2 ] || usage 1 >&2

DEFINITION_PATH="${ARGUMENTS[0]}"
if [ -z "$DEFINITION_PATH" ]; then
  usage 1 >&2
elif [ ! -f "$DEFINITION_PATH" ]; then
  for DEFINITION_DIR in "${GO_BUILD_DEFINITIONS[@]}"; do
    if [ -f "${DEFINITION_DIR}/${DEFINITION_PATH}" ]; then
      DEFINITION_PATH="${DEFINITION_DIR}/${DEFINITION_PATH}"
      break
    fi
  done

  if [ ! -f "$DEFINITION_PATH" ]; then
    echo "go-build: definition not found: ${DEFINITION_PATH}" >&2
    exit 2
  fi
fi

PREFIX_PATH="${ARGUMENTS[1]}"
if [ -z "$PREFIX_PATH" ]; then
  usage 1 >&2
elif [ "${PREFIX_PATH#/}" = "$PREFIX_PATH" ]; then
  PREFIX_PATH="${PWD}/${PREFIX_PATH}"
fi

if [ -z "$TMPDIR" ]; then
  TMP="/tmp"
else
  TMP="${TMPDIR%/}"
fi

# Check if TMPDIR is accessible and can hold executables.
tmp_executable="${TMP}/go-build-test.$$"
noexec=""
if mkdir -p "$TMP" && touch "$tmp_executable" 2>/dev/null; then
  cat > "$tmp_executable" <<-EOF
	#!${BASH}
	exit 0
	EOF
  chmod +x "$tmp_executable"
else
  echo "go-build: TMPDIR=$TMP is set to a non-accessible location" >&2
  exit 1
fi
"$tmp_executable" 2>/dev/null || noexec=1
rm -f "$tmp_executable"
if [ -n "$noexec" ]; then
  echo "go-build: TMPDIR=$TMP cannot hold executables (partition possibly mounted with \`noexec\`)" >&2
  exit 1
fi

# Work around warnings building Ruby 2.0 on Clang 2.x:
# pass -Wno-error=shorten-64-to-32 if the compiler accepts it.
#
# When we set CFLAGS, Ruby won't apply its default flags, though. Since clang
# builds 1.9.x and 2.x only, where -O3 is default, we can safely set that flag.
# Ensure it's the first flag since later flags take precedence.
#if "${CC:-cc}" -x c /dev/null -E -Wno-error=shorten-64-to-32 &>/dev/null; then
#  GO_CFLAGS="-O3 -Wno-error=shorten-64-to-32 $GO_CFLAGS"
#fi

if [ -z "$MAKE" ]; then
  if [ "FreeBSD" = "$(uname -s)" ] && [ "$(uname -r | sed 's/[^[:digit:]].*//')" -lt 10 ]; then
    export MAKE="gmake"
  else
    export MAKE="make"
  fi
fi

if [ -n "$GO_BUILD_CACHE_PATH" ] && [ -d "$GO_BUILD_CACHE_PATH" ]; then
  GO_BUILD_CACHE_PATH="${GO_BUILD_CACHE_PATH%/}"
else
  unset GO_BUILD_CACHE_PATH
fi

if [ -z "$GO_BUILD_MIRROR_URL" ]; then
  GO_BUILD_MIRROR_URL="https://yyuu.github.io/gos"
  GO_BUILD_DEFAULT_MIRROR=1
else
  GO_BUILD_MIRROR_URL="${GO_BUILD_MIRROR_URL%/}"
  GO_BUILD_DEFAULT_MIRROR=
fi

if [ -n "$GO_BUILD_SKIP_MIRROR" ] || ! has_checksum_support compute_sha2; then
  unset GO_BUILD_MIRROR_URL
fi

# go-build: Specify `--libdir` on configure to fix build on openSUSE (#36)
package_option go configure --libdir="${PREFIX_PATH}/lib"

# go-build: Set `RPATH` if --shared` was given for PyPy (#244)
if [[ "$PYPY_OPTS" == *"--shared"* ]]; then
  export LDFLAGS="-Wl,-rpath=${PREFIX_PATH}/lib ${LDFLAGS}"
fi

# SSL Certificate error with older wget that does not support Server Name Indication (#60)
if ! command -v curl 1>/dev/null 2>&1 && [[ "$(wget --version 2>/dev/null || true)" = "GNU Wget 1.1"[0-3]* ]]; then
  echo "go-build: wget (< 1.14) doesn't support Server Name Indication. Please install curl (>= 7.18.1) and try again" >&2
  exit 1
fi

go_bin_suffix() {
  local version_name version_info
  case "$1" in
  2.* | 3.* )
    version_name="$1"
    version_name="${version_name%-dev}"
    version_name="${version_name%-rc*}"
    version_name="${version_name%rc*}"
    version_info=(${version_name//./ })
    echo "${version_info[0]}.${version_info[1]}"
    ;;
  stackless-2.* | stackless-3.* )
    version_name="${1#stackless-}"
    version_name="${version_name%-dev}"
    version_name="${version_name%-rc*}"
    version_name="${version_name%rc*}"
    version_info=(${version_name//./ })
    echo "${version_info[0]}.${version_info[1]}"
    ;;
  esac
}

SEED="$(date "+%Y%m%d%H%M%S").$$"
LOG_PATH="${TMP}/go-build.${SEED}.log"
GO_BIN="${PREFIX_PATH}/bin/go$(go_bin_suffix "${DEFINITION_PATH##*/}")"
CWD="$(pwd)"

if [ -z "$GO_BUILD_BUILD_PATH" ]; then
  BUILD_PATH="${TMP}/go-build.${SEED}"
else
  BUILD_PATH="$GO_BUILD_BUILD_PATH"
fi

exec 4<> "$LOG_PATH" # open the log file at fd 4
if [ -n "$VERBOSE" ]; then
  tail -f "$LOG_PATH" &
  TAIL_PID=$!
  trap "kill $TAIL_PID" SIGINT SIGTERM EXIT
fi

unset GOHOME
unset GOPATH

trap build_failed ERR
mkdir -p "$BUILD_PATH"
# Executes the file and the commands inside
source "$DEFINITION_PATH"
[ -z "${KEEP_BUILD_PATH}" ] && rm -fr "$BUILD_PATH"
trap - ERR
