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

local path="$1"

# Use a subshell to avoid changing the current path

(

while [ -n "$path" ]; do

cd_path="${path%/*}"

if [[ "$cd_path" != "$path" ]]; then

cd "$cd_path"

fi

name="${path##*/}"

path="$(resolve_link "$name" || true)"

done

echo "$PWD"

)

if [ -t 1 ]; then printf "\e[%sm%s\e[m" "$1" "$2"

else echo -n "$2"

fi

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

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

local num

case "$(uname -s)" in

Darwin | *BSD )

num="$(sysctl -n hw.ncpu 2>/dev/null || true)"

;;

SunOS )

num="$(getconf NPROCESSORS_ONLN 2>/dev/null || true)"

;;

* )

num="$({ getconf _NPROCESSORS_ONLN ||

num="${num#0}"

;;

esac

echo "${num:-2}"

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

for arg in "${@:$(( $package_type_nargs + 1 ))}"; do

if [ "$last_arg" = "--if" ]; then

"$arg" || return 0

elif [ "$arg" != "--if" ]; then

make_args["${#make_args[@]}"]="$arg"

fi

last_arg="$arg"

done

pushd "$BUILD_PATH" >&4

"fetch_${package_type}" "${fetch_args[@]}"

make_package "${make_args[@]}"

popd >&4

{ echo "Installed ${package_name} to ${PREFIX_PATH}"

echo

} >&2

local package_name="$1"

shift

pushd "$package_name" >&4

setup_builtin_patches "$package_name"

before_install_package "$package_name"

build_package "$package_name" $*

after_install_package "$package_name"

cleanup_builtin_patches "$package_name"

fix_directory_permissions

popd >&4

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 -b)" || return 1

echo "${output%% *}"

else

return 1

fi

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

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}"

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" ;;

64) checksum_command="compute_sha2" ;;

*)

{ echo

echo "unexpected checksum length: ${#expected_checksum} (${expected_checksum})"

echo "expected 0 (no checksum), 32 (MD5), 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

local method="$1"

[ -n "$2" ] || return 1

shift 1

PYTHON_BUILD_HTTP_CLIENT="${PYTHON_BUILD_HTTP_CLIENT:-$(detect_http_client)}"

[ -n "$PYTHON_BUILD_HTTP_CLIENT" ] || return 1

"http_${method}_${PYTHON_BUILD_HTTP_CLIENT}" "$@"

local client

for client in aria2c curl wget; do

if type "$client" &>/dev/null; then

echo "$client"

return

fi

done

echo "error: please install \`aria2c\`, \`curl\`, or \`wget\` and try again" >&2

return 1

local out="${2:-$(mktemp "out.XXXXXX")}"

if aria2c --allow-overwrite=true --no-conf=true -o "${out}" ${ARIA2_OPTS} "$1" >&4; then

[ -n "$2" ] || cat "${out}"

else

false

fi

local package_name="$1"

local package_url="$2"

local mirror_url

local checksum

local extracted_dir

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

checksum="${package_url#*#}"

package_url="${package_url%%#*}"

if [ -n "$PYTHON_BUILD_MIRROR_URL" ]; then

if [[ -z "$PYTHON_BUILD_DEFAULT_MIRROR" || $package_url != */www.python.org/* ]]; then

mirror_url="${PYTHON_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 [ ! -d "$package_name" ]; then

extracted_dir="$(find_extracted_directory)"

mv "$extracted_dir" "$package_name"

fi

if [ -z "$KEEP_BUILD_PATH" ]; then

rm -f "$package_filename"

else

true

fi

fi

} >&4 2>&1

for f in *; do

if [ -d "$f" ]; then

echo "$f"

return

fi

done

echo "Extracted directory not found" >&2

return 1

local package_name="$1"

local package_url="$2"

local package_pattern="$3"

fetch_tarball "$1" "$2"

if [ ! -e "${package_name}" ]; then

local nightly_package_name="$(echo ${package_pattern})"

if [ -e "${nightly_package_name}" ]; then

ln -fs "${nightly_package_name}" "${package_name}"

fi

fi

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 "$PYTHON_BUILD_CACHE_PATH" ] || return 1

local cached_package_filename="${PYTHON_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

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 "$PYTHON_BUILD_CACHE_PATH" ]; then

local cached_package_filename="${PYTHON_BUILD_CACHE_PATH}/$package_filename"

{ mv "$package_filename" "$cached_package_filename"

ln -s "$cached_package_filename" "$package_filename"

} >&4 2>&1 || return 1

fi

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 "$PYTHON_BUILD_CACHE_PATH" ]; then

pushd "$PYTHON_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="$PYTHON_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

local package_name="$1"

local hg_url="$2"

local hg_ref="$3"

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

if type hg &>/dev/null; then

if [ -n "$PYTHON_BUILD_CACHE_PATH" ]; then

pushd "$PYTHON_BUILD_CACHE_PATH" >&4

local clone_name="$(sanitize "$hg_url")"

if [ -e "${clone_name}" ]; then

{ cd "${clone_name}"

hg pull --force "$hg_url"

} >&4 2>&1

else

{ hg clone --branch "$hg_ref" "$hg_url" "${clone_name}"

cd "${clone_name}"

hg update null

} >&4 2>&1

fi

hg_url="$PYTHON_BUILD_CACHE_PATH/${clone_name}"

popd >&4

fi

hg clone --branch "$hg_ref" "$hg_url" "${package_name}" >&4 2>&1

else

echo "error: please install \`mercurial\` and try again" >&2

exit 1

fi

local package_name="$1"

local svn_url="$2"

local svn_rev="$3"

echo "Checking out ${svn_url}..." >&2

if type svn &>/dev/null; then

svn co -r "$svn_rev" "$svn_url" "${package_name}" >&4 2>&1

elif type svnlite &>/dev/null; then

svnlite co -r "$svn_rev" "$svn_url" "${package_name}" >&4 2>&1

else

echo "error: please install Subversion and try again" >&2

exit 1

fi

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 "$PYTHON_BUILD_MIRROR_URL" ]; then

mirror_url="${PYTHON_BUILD_MIRROR_URL}/$checksum"

fi

fi

local package_filename="${package_name}.jar"

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

# Must use full path to jar and destination directory:

# http://bugs.jython.org/issue2350

{ if $JAVA -jar "$PWD/${package_name}.jar" -s -d "$PWD/${package_name}"; then

if [ -z "$KEEP_BUILD_PATH" ]; then

rm -f "$package_filename"

else

true

fi

fi

} >&4 2>&1

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 "$PYTHON_BUILD_MIRROR_URL" ]; then

mirror_url="${PYTHON_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

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 "$PYTHON_BUILD_MIRROR_URL" ]; then

mirror_url="${PYTHON_BUILD_MIRROR_URL}/$checksum"

fi

fi

local package_filename="${package_name}.sh" # TODO: extract suffix from ${package_url}

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

mkdir -p "$(dirname "${package_name}/${package_filename}")"

mv -f "${package_filename}" "${package_name}/${package_filename}"

local package_name="$1"

shift

if [ "$#" -eq 0 ]; then

local commands="standard"

else

local commands="$*"

fi

echo "Installing ${package_name}..." >&2

[ -n "$HAS_PATCH" ] && apply_python_patch "$package_name"

for command in $commands; do

"build_package_${command}" "$package_name"

done

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[@]}\" )"

local package_name="$1"

{ echo

echo "WARNING: $package_name is past its end of life and is now unsupported."

echo "It no longer receives bug fixes or critical security updates."

echo

} >&3

local package_name="$1"

{ echo

echo "WARNING: $package_name is nearing its end of life."

echo "It only receives critical security updates, no bug fixes."

echo

} >&3

local package_name="$1"

if [ "${MAKEOPTS+defined}" ]; then

MAKE_OPTS="$MAKEOPTS"

elif [ -z "${MAKE_OPTS+defined}" ]; then

MAKE_OPTS="-j $(num_cpu_cores)"

fi

# Support YAML_CONFIGURE_OPTS, PYTHON_CONFIGURE_OPTS, etc.

local package_var_name="$(capitalize "${package_name%%-*}")"

local PACKAGE_CONFIGURE="${package_var_name}_CONFIGURE"

local PACKAGE_PREFIX_PATH="${package_var_name}_PREFIX_PATH"

local PACKAGE_CONFIGURE_OPTS="${package_var_name}_CONFIGURE_OPTS"

local PACKAGE_CONFIGURE_OPTS_ARRAY="${package_var_name}_CONFIGURE_OPTS_ARRAY[@]"

local PACKAGE_MAKE_OPTS="${package_var_name}_MAKE_OPTS"

local PACKAGE_MAKE_OPTS_ARRAY="${package_var_name}_MAKE_OPTS_ARRAY[@]"

local PACKAGE_CFLAGS="${package_var_name}_CFLAGS"

if [ "$package_var_name" = "PYTHON" ]; then

use_homebrew_readline || use_freebsd_pkg || true

if is_mac -ge 1014; then

use_xcode_sdk_zlib || use_homebrew_zlib || true

fi

fi

( if [ "${CFLAGS+defined}" ] || [ "${!PACKAGE_CFLAGS+defined}" ]; then

export CFLAGS="$CFLAGS ${!PACKAGE_CFLAGS}"

fi

if [ -z "$CC" ] && is_mac -ge 1010; then

export CC=clang

fi

${!PACKAGE_CONFIGURE:-./configure} --prefix="${!PACKAGE_PREFIX_PATH:-$PREFIX_PATH}" \

$CONFIGURE_OPTS ${!PACKAGE_CONFIGURE_OPTS} "${!PACKAGE_CONFIGURE_OPTS_ARRAY}" || return 1

) >&4 2>&1

{ "$MAKE" $MAKE_OPTS ${!PACKAGE_MAKE_OPTS} "${!PACKAGE_MAKE_OPTS_ARRAY}"

} >&4 2>&1

local package_name="$1"

local package_var_name="$(capitalize "${package_name%%-*}")"

local PACKAGE_MAKE_INSTALL_OPTS="${package_var_name}_MAKE_INSTALL_OPTS"

local PACKAGE_MAKE_INSTALL_OPTS_ARRAY="${package_var_name}_MAKE_INSTALL_OPTS_ARRAY[@]"

local PACKAGE_MAKE_INSTALL_TARGET="${package_var_name}_MAKE_INSTALL_TARGET"

{ "$MAKE" "${!PACKAGE_MAKE_INSTALL_TARGET:-install}" $MAKE_INSTALL_OPTS ${!PACKAGE_MAKE_INSTALL_OPTS} "${!PACKAGE_MAKE_INSTALL_OPTS_ARRAY}"

} >&4 2>&1

local package_name="$1"

{ "$PYTHON_BIN" setup.py install

} >&4 2>&1

build_package_copy

{ if [ -x "${PREFIX_PATH}/bin/jython" ] && [ ! -x "${PREFIX_PATH}/bin/python" ]; then

( cd "${PREFIX_PATH}/bin" && ln -fs jython python )

fi

} >&4 2>&1

fix_jython_shebangs

# Workaround for Jython 2.7+ (#458)

for file in "${PREFIX_PATH}/bin"/*; do

case "$(head -1 "${file}")" in

"#!"*"/bin/jython" )

sed -i.bak "1 s:.*:#\!${PREFIX_PATH}\/bin\/jython:" "${file}"

;;

"#!"*"/bin/python2.7"* )

sed -i.bak "1 s:.*:#\!\/usr\/bin\/env python:" "${file}"

;;

esac

rm -f "${file}.bak"

done

mkdir -p "${PREFIX_PATH}/"

cp -fR . "${PREFIX_PATH}/"

chmod +x "${PREFIX_PATH}/"pyston

# FIXME ugly hack below adapted from

# https://github.com/dropbox/pyston/blob/master/docker/pyston/Dockerfile

( cd "${PREFIX_PATH}/" && ./pyston virtualenv/virtualenv.py . )

mkdir -p "${PREFIX_PATH}/bin"

cp -fR . "${PREFIX_PATH}/bin"

chmod +x "${PREFIX_PATH}/bin/"*.exe

( cd "${PREFIX_PATH}/bin" && ln -fs ipy.exe python )

if [ "${MAKEOPTS+defined}" ]; then

MAKE_OPTS="$MAKEOPTS"

elif [ -z "${MAKE_OPTS+defined}" ]; then

MAKE_OPTS="-j $(num_cpu_cores)"

fi

{ cd mpy-cross

"$MAKE" $MAKE_OPTS

cd ../ports/unix

"$MAKE" $MAKE_OPTS axtls

"$MAKE" $MAKE_OPTS CFLAGS_EXTRA="-DMICROPY_PY_SYS_PATH_DEFAULT='\"${PREFIX_PATH}/lib/micropython\"'"

"$MAKE" install $MAKE_INSTALL_OPTS PREFIX="${PREFIX_PATH}"

ln -fs micropython "${PREFIX_PATH}/bin/python"

mkdir -p "${PREFIX_PATH}/lib/micropython"

}>&4 2>&1

case "$(uname -s)" in

"Darwin" ) echo "osx64" ;;

"Linux" )

case "$(uname -m)" in

"armel" ) echo "linux-armel" ;;

"armhf" | "armv6l" | "armv7l" ) echo "linux-armhf" ;;

"i386" | "i486" | "i586" | "i686" | "i786" ) echo "linux" ;;

"ppc64" ) echo "linux-ppc64" ;;

"ppc64le" ) echo "linux-ppc64le" ;;

"x86_64" ) echo "linux64" ;;

"aarch64" ) echo "linux-aarch64" ;;

* ) return 1 ;;

esac

;;

"CYGWIN"* | "MINGW"* ) echo "win32" ;;

"FreeBSD" )

case "$(uname -m)" in

"x86_64" ) echo "freebsd64" ;;

* ) return 1 ;;

esac

;;

* ) return 1 ;;

esac

build_package_copy

mkdir -p "${PREFIX_PATH}/bin" "${PREFIX_PATH}/lib"

local bin

shopt -s nullglob

for bin in "bin/"*; do

if [ -f "${bin}" ] && [ -x "${bin}" ] && [ ! -L "${bin}" ]; then

case "${bin##*/}" in

"libpypy"* )

( cd "${PREFIX_PATH}/lib" && ln -fs "../bin/${bin##*/}" "${bin##*/}" )

;;

"pypy"* )

( cd "${PREFIX_PATH}/bin" && ln -fs "${bin##*/}" "python" )

;;

esac

fi

done

shopt -u nullglob

if [ -f "rpython/bin/rpython" ]; then # pypy 2.x

if [ -z "${PYPY_OPTS}" ]; then

local PYPY_OPTS="--opt=jit --batch --make-jobs=$(num_cpu_cores)"

fi

python "rpython/bin/rpython" ${PYPY_OPTS} "pypy/goal/targetpypystandalone.py" >&4 2>&1

elif [ -f "pypy/translator/goal/translate.py" ]; then # pypy 1.x

if [ -z "${PYPY_OPTS}" ]; then

local PYPY_OPTS="--opt=jit"

fi

( cd "pypy/translator/goal" && python "translate.py" ${PYPY_OPTS} "targetpypystandalone.py" ) 1>&4 2>&1

else

echo "not a pypy source tree" 1>&3

return 1

fi

{ mkdir -p "bin" "lib"

local pypy

for pypy in "pypy"*; do

if [ -f "${pypy}" ] && [ -x "${pypy}" ] && [ ! -L "${pypy}" ]; then

mv -f "${pypy}" "bin/${pypy##*/}"

fi

done

local libpypy

for libpypy in "libpypy"*; do

if [ -f "${libpypy}" ] && [ -x "${libpypy}" ] && [ ! -L "${libpypy}" ]; then

mv -f "${libpypy}" "bin/${libpypy##*/}"

fi

done

} >&4 2>&1

build_package_pypy

case "$(uname -s)" in

"Darwin" ) echo "macosx10.9-i386-x86_64" ;;

"Linux" )

case "$(uname -m)" in

"i368" | "i486" | "i586" | "i686" | "i786" ) echo "linux-x86" ;;

"x86_64" ) echo "linux-x86_64" ;;

* ) return 1 ;;

esac

;;

* ) return 1 ;;

esac

local package_name="$1"

{ bash "install.sh" --install-dir "${PREFIX_PATH}"

} >&4 2>&1

case "$(uname -s)" in

"Darwin" ) echo "MacOSX-x86_64" ;;

"Linux" )