#!/usr/bin/env bash

#

# Usage: python-build [-kvp] <definition> <prefix>

# python-build --definitions

#

# -k/--keep Do not remove source tree after installation

# -v/--verbose Verbose mode: print compilation status to stdout

# -p/--patch Apply a patch from stdin before building

# -4/--ipv4 Resolve names to IPv4 addresses only

# -6/--ipv6 Resolve names to IPv6 addresses only

# --definitions List all built-in definitions

# -g/--debug Build a debug version

#

PYTHON_BUILD_VERSION="20150519"

set -E

exec 3<&2 # preserve original stderr at fd 3

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

}

# 9.1 -> 901

# 10.9 -> 1009

# 10.10 -> 1010

osx_version() {

local -a ver

IFS=. ver=( `sw_vers -productVersion` )

echo $(( ${ver[0]}*100 + ${ver[1]} ))

}

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_package() {

install_package_using "tarball" 1 "$@"

}

install_nightly_package() {

install_package_using "nightly_tarball" 2 "$@"

}

install_git() {

install_package_using "git" 2 "$@"

}

install_hg() {

install_package_using "hg" 2 "$@"

}

install_svn() {

install_package_using "svn" 2 "$@"

}

install_jar() {

install_package_using "jar" 1 "$@"

}

install_zip() {

install_package_using "zip" 1 "$@"

}

install_script() {

install_package_using "script" 1 "$@"

}

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

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

}

make_package() {

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

}

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_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

}

verify_checksum() {

# If there's no SHA2 support, return success

[ -n "$HAS_SHA2_SUPPORT" ] || return 0

local checksum_command="compute_sha2"

# If the specified filename doesn't exist, return success

local filename="$1"

[ -e "$filename" ] || return 0

# If there's no expected checksum, return success

local expected_checksum=`echo "$2" | tr [A-Z] [a-z]`

[ -n "$expected_checksum" ] || return 0

# If the checksum length is 32 chars, assume MD5, otherwise SHA2

if [ "${#expected_checksum}" -eq 32 ]; then

[ -n "$HAS_MD5_SUPPORT" ] || return 0

checksum_command="compute_md5"

fi

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

mirror_url="${PYTHON_BUILD_MIRROR_URL}/$checksum"

fi

fi

local tar_args="xzf"

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

if [ "$package_url" != "${package_url%tgz}" ]; then

package_filename="${package_filename%tar.gz}tgz"

fi

if [ "$package_url" != "${package_url%bz2}" ]; then

package_filename="${package_filename%.gz}.bz2"

tar_args="${tar_args/z/j}"

fi

if [ "$package_url" != "${package_url%xz}" ]; then

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

}

fetch_nightly_tarball() {

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

}

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

}

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

}

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

}

fetch_hg() {

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

}

fetch_svn() {

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

else

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

exit 1

fi

}

fetch_jar() {

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

}

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

}

fetch_script() {

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

}

build_package() {

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

}

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"

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

local PACKAGE_CFLAGS="${package_var_name}_CFLAGS"

[ "$package_var_name" = "PYTHON" ] && use_homebrew_readline || true

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

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

fi

if [ -z "$CC" ] && [ "$(uname -s)" = "Darwin" ] && [ "$(osx_version)" -ge 1010 ]; then

export CC=clang

fi

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

--libdir="${!PACKAGE_PREFIX_PATH:-$PREFIX_PATH}/lib" \

$CONFIGURE_OPTS ${!PACKAGE_CONFIGURE_OPTS} "${!PACKAGE_CONFIGURE_OPTS_ARRAY}"

) >&4 2>&1

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

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

} >&4 2>&1

}

build_package_autoconf() {

{ autoconf

} >&4 2>&1

}

build_package_ruby() {

local package_name="$1"

{ "$RUBY_BIN" setup.rb

} >&4 2>&1

}

build_package_python() {

local package_name="$1"

{ "$PYTHON_BIN" setup.py install

} >&4 2>&1

}

build_package_ree_installer() {

build_package_auto_tcltk

local options=""

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

options="--no-tcmalloc"

fi

local option

for option in $RUBY_CONFIGURE_OPTS ${RUBY_CONFIGURE_OPTS_ARRAY[@]}; do

options="$options -c $option"

done

# Work around install_useful_libraries crash with --dont-install-useful-gems

mkdir -p "$PREFIX_PATH/lib/ruby/gems/1.8/gems"

{ ./installer --auto "$PREFIX_PATH" --dont-install-useful-gems $options $CONFIGURE_OPTS

} >&4 2>&1

}

build_package_rbx() {

local package_name="$1"

{ [ ! -e "Gemfile" ] || bundle --path=vendor/bundle

if [ -n "$RUBY_BUILD_CACHE_PATH" ]; then

mkdir -p vendor

ln -s "$RUBY_BUILD_CACHE_PATH" vendor/prebuilt

fi

RUBYOPT="-rubygems $RUBYOPT" ./configure --prefix="$PREFIX_PATH" $RUBY_CONFIGURE_OPTS "${RUBY_CONFIGURE_OPTS_ARRAY[@]}"

rake install

fix_rbx_gem_binstubs "$PREFIX_PATH"

fix_rbx_irb "$PREFIX_PATH"

} >&4 2>&1

}

build_package_mruby() {

local package_name="$1"

{ rake

mkdir -p "$PREFIX_PATH"

cp -fR build/host/* "$PREFIX_PATH"

cd "$PREFIX_PATH/bin"

ln -fs mruby ruby

ln -fs mirb irb

} >&4 2>&1

}

build_package_maglev() {

build_package_copy

{ cd "${PREFIX_PATH}"

./install.sh

cd "${PREFIX_PATH}/bin"

echo "Creating symlink for ruby*"

ln -fs maglev-ruby ruby

echo "Creating symlink for irb*"

ln -fs maglev-irb irb

} >&4 2>&1

echo

echo "Run 'maglev start' to start up the stone before using 'ruby' or 'irb'"

}

build_package_topaz() {

build_package_copy

{ cd "${PREFIX_PATH}/bin"

echo "Creating symlink for ruby*"

ln -fs topaz ruby

} >&4 2>&1

}

topaz_architecture() {

case "$(uname -s)" in

"Darwin") echo "osx64";;

"Linux") [[ "$(uname -m)" = "x86_64" ]] && echo "linux64" || echo "linux32";;

*)

echo "no nightly builds available" >&2

exit 1;;

esac

}

build_package_jruby() {

build_package_copy

cd "${PREFIX_PATH}/bin"

ln -fs jruby ruby

chmod +x ruby

install_jruby_launcher

remove_windows_files

fix_jruby_shebangs

}

graal_architecture() {

if [ "$(uname -m)" != "x86_64" ]; then

echo "no nightly builds available" >&2

exit 1

fi

case "$(uname -s)" in

"Darwin") echo "macosx-x86_64";;

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

*)

echo "no nightly builds available" >&2

exit 1;;

esac

}

install_jruby_launcher() {

# If this version of JRuby has been modified for Graal, don't overwrite the

# launcher scripts

if ! grep -q graalvm "${PREFIX_PATH}/bin/jruby"; then

cd "${PREFIX_PATH}/bin"

{ ./ruby gem install jruby-launcher

} >&4 2>&1

fi

}

fix_jruby_shebangs() {

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

if [ "$(head -c 20 "$file")" = "#!/usr/bin/env jruby" ]; then

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

rm "$file".bak

fi

done

}

remove_windows_files() {

cd "$PREFIX_PATH"

rm -f bin/*.exe bin/*.dll bin/*.bat bin/jruby.sh

}

build_package_jython() {

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

}

build_package_jython_builder() {

ant >&4 2>&1

( cd "dist" && build_package_jython )

}

build_package_ironpython() {

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 )

}

build_package_ironpython_builder() {

xbuild Build.proj /t:Stage "/p:Mono=true;BaseConfiguration=Release" >&4 2>&1

( cd "Stage/Release/IronPython-"* && build_package_ironpython )

}

pypy_architecture() {

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

"x86_64" ) echo "linux64" ;;

* ) return 1 ;;

esac

;;

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

"FreeBSD" )

case "$(uname -m)" in

"x86_64" ) echo "freebsd64" ;;

* ) return 1 ;;

esac

;;

* ) return 1 ;;

esac

}

build_package_pypy() {

build_package_copy

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

local pypy libpypy

shopt -s nullglob

for pypy in "bin/pypy"*; do

( cd "${PREFIX_PATH}/bin" && ln -fs "$(basename "${pypy}")" "$(basename "${pypy}" | sed -e 's/pypy/python/')" )

done

for libpypy in "bin/libpypy-c."*; do

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

done

shopt -u nullglob

}

build_package_pypy_builder() {

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

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

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

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

else

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

return 1

fi

{ mkdir -p "bin" "lib"

if [ -x "pypy-c" ]; then

mv -f "pypy-c" "bin/pypy"

fi

for libpypy in "libpypy-c."*; do

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

done

} >&4 2>&1

build_package_pypy

}

anaconda_architecture() {

case "$(uname -s)" in

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

"Linux" )

case "$(uname -m)" in

"i386" | "i486" | "i586" | "i686" | "i786" ) echo "Linux-x86" ;;

"x86_64" ) echo "Linux-x86_64" ;;

* ) return 1 ;;

esac

;;

* ) return 1 ;;

esac

}

build_package_anaconda() {

local package_name="$1"

{ bash "${package_name}.sh" -b -p "${PREFIX_PATH}"

} >&4 2>&1

}

build_package_miniconda() {

build_package_anaconda "$@"

"${PREFIX_PATH}/bin/conda" install --yes "pip"

}

build_package_copy() {

mkdir -p "$PREFIX_PATH"

cp -fR . "$PREFIX_PATH"

}

before_install_package() {

local stub=1

}

after_install_package() {

local stub=1

}

setup_builtin_patches() {

local package_name="$1"

local package_patch_path="${DEFINITION_PATH%/*}/patches/${DEFINITION_PATH##*/}/${package_name}"

ORIG_HAS_PATCH="$HAS_PATCH"

# Apply built-in patches if patch was not given from stdin

if [ -z "$HAS_PATCH" ] && [ -d "${package_patch_path}" ]; then

{ find "${package_patch_path}" -maxdepth 1 -type f

} 2>/dev/null | sort | xargs cat 1>"${package_name}.patch"

exec <&-

exec <"${package_name}.patch"

HAS_PATCH=true

fi

}

cleanup_builtin_patches() {

local package_name="$1"

rm -f "${package_name}.patch"

HAS_PATCH="$ORIG_HAS_PATCH"

}

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 {} \;

}

fix_rbx_gem_binstubs() {

local prefix="$1"

local gemdir="${prefix}/gems/bin"

local bindir="${prefix}/bin"

local file binstub

# Symlink Rubinius' `gems/bin/` into `bin/`

if [ -d "$gemdir" ] && [ ! -L "$gemdir" ]; then

for file in "$gemdir"/*; do

binstub="${bindir}/${file##*/}"

rm -f "$binstub"

{ echo "#!${bindir}/ruby"

grep -v '^#!' "$file"

} > "$binstub"