#!/bin/bash # # Copyright (C) 2012 Brian Aker # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # * Redistributions in binary form must reproduce the above # copyright notice, this list of conditions and the following disclaimer # in the documentation and/or other materials provided with the # distribution. # # * The names of its contributors may not be used to endorse or # promote products derived from this software without specific prior # written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # Environment Variables that will influence the build: # AUTOMAKE # AUTORECONF # LIBTOOLIZE # MAKE # PREFIX # TESTS_ENVIRONMENT # VERBOSE # WARNINGS # command_not_found_handle () { echo "Command not found: '$@'" exit 127 } function die () { echo "$BASH_SOURCE:$BASH_LINENO: $@" >&2 exit 1; } function nassert () { local param_name=\$"$1" local param_value=`eval "expr \"$param_name\" "` if [ -n "$param_value" ]; then echo "$bash_source:$bash_lineno: assert($param_name) had value of "$param_value"" >&2 exit 1 fi } function assert () { local param_name=\$"$1" local param_value=`eval "expr \"$param_name\" "` if [ -z "$param_value" ]; then echo "$bash_source:$bash_lineno: assert($param_name)" >&2 exit 1 fi } assert_file () { if [ ! -f "$1" ]; then echo "$BASH_SOURCE:$BASH_LINENO: assert($1) does not exist: $2" >&2 exit 1; fi } assert_no_file () { if [ -f "$1" ]; then echo "$BASH_SOURCE:$BASH_LINENO: assert($1) file exists: $2" >&2 exit 1; fi } assert_exec_file () { if [ ! -f "$1" ]; then echo "$BASH_SOURCE:$BASH_LINENO: assert($1) does not exist: $2" >&2 exit 1; fi if [ ! -x "$1" ]; then echo "$BASH_SOURCE:$BASH_LINENO: assert($1) exists but is not executable: $2" >&2 exit 1; fi } command_exists () { type "$1" &> /dev/null ; } rebuild_host_os () { HOST_OS="${UNAME_MACHINE_ARCH}-${VENDOR}-${VENDOR_DISTRIBUTION}-${VENDOR_RELEASE}-${UNAME_KERNEL}-${UNAME_KERNEL_RELEASE}" if [ -z "$1" ]; then if $VERBOSE; then echo "HOST_OS=$HOST_OS" fi fi } # Valid values are: darwin,fedora,rhel,ubuntu set_VENDOR_DISTRIBUTION () { local dist=`echo "$1" | tr '[A-Z]' '[a-z]'` case "$dist" in darwin) VENDOR_DISTRIBUTION='darwin' ;; fedora) VENDOR_DISTRIBUTION='fedora' ;; rhel) VENDOR_DISTRIBUTION='rhel' ;; ubuntu) VENDOR_DISTRIBUTION='ubuntu' ;; opensuse) VENDOR_DISTRIBUTION='opensuse' ;; *) die "attempt to set an invalid VENDOR_DISTRIBUTION=$dist" ;; esac } set_VENDOR_RELEASE () { local release=`echo "$1" | tr '[A-Z]' '[a-z]'` case "$VENDOR_DISTRIBUTION" in darwin) VENDOR_RELEASE='mountain' ;; fedora) VENDOR_RELEASE="$release" ;; rhel) VENDOR_RELEASE="$release" ;; ubuntu) VENDOR_RELEASE="$release" ;; opensuse) VENDOR_RELEASE="$release" ;; unknown) die "attempt to set VENDOR_RELEASE without setting VENDOR_DISTRIBUTION" ;; *) die "attempt to set with an invalid VENDOR_DISTRIBUTION=$VENDOR_DISTRIBUTION" ;; esac } # Valid values are: apple, redhat, centos, canonical set_VENDOR () { local vendor=`echo "$1" | tr '[A-Z]' '[a-z]'` case $vendor in apple) VENDOR='apple' ;; redhat) VENDOR='redhat' ;; centos) VENDOR='centos' ;; canonical) VENDOR='canonical' ;; suse) VENDOR='suse' ;; *) die "An attempt was made to set an invalid VENDOR=$_vendor" ;; esac set_VENDOR_DISTRIBUTION $2 set_VENDOR_RELEASE $3 } determine_target_platform () { UNAME_MACHINE_ARCH=`(uname -m) 2>/dev/null` || UNAME_MACHINE_ARCH=unknown UNAME_KERNEL=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown UNAME_KERNEL_RELEASE=`(uname -r) 2>/dev/null` || UNAME_KERNEL_RELEASE=unknown if [[ $(uname) == 'Darwin' ]]; then set_VENDOR 'apple' 'darwin' 'mountain' elif [[ -f '/etc/fedora-release' ]]; then local fedora_version=`cat /etc/fedora-release | awk ' { print $3 } '` set_VENDOR 'redhat' 'fedora' $fedora_version if [[ "x$VENDOR_RELEASE" == 'x17' ]]; then AUTORECONF_REBUILD_HOST=true fi elif [[ -f '/etc/centos-release' ]]; then local centos_version=`cat /etc/centos-release | awk ' { print $7 } '` set_VENDOR 'centos' 'rhel' $centos_version elif [[ -f '/etc/SuSE-release' ]]; then local suse_distribution=`head -1 /etc/SuSE-release | awk ' { print $1 } '` local suse_version=`head -1 /etc/SuSE-release | awk ' { print $2 } '` set_VENDOR 'suse' $suse_distribution $suse_version elif [[ -f '/etc/redhat-release' ]]; then local rhel_version=`cat /etc/redhat-release | awk ' { print $7 } '` set_VENDOR 'redhat' 'rhel' $rhel_version elif [[ -f '/etc/lsb-release' ]]; then local debian_DISTRIB_ID=`cat /etc/lsb-release | grep DISTRIB_ID | awk -F= ' { print $2 } '` local debian_version=`cat /etc/lsb-release | grep DISTRIB_CODENAME | awk -F= ' { print $2 } '` set_VENDOR 'canonical' $debian_DISTRIB_ID $debian_version if [[ "x$VENDOR_RELEASE" == 'xprecise' ]]; then AUTORECONF_REBUILD_HOST=true fi fi rebuild_host_os } run_configure () { # We will run autoreconf if we are required run_autoreconf_if_required # We always begin at the root of our build if [ ! popd ]; then die "Programmer error, we entered run_configure with a stacked directory" fi local BUILD_DIR="$1" if [[ -n "$BUILD_DIR" ]]; then rm -r -f $BUILD_DIR mkdir -p $BUILD_DIR safe_pushd $BUILD_DIR fi # Arguments for configure local CONFIGURE_ARG= # Set ENV DEBUG in order to enable debugging if $DEBUG; then CONFIGURE_ARG='--enable-debug' fi # Set ENV ASSERT in order to enable assert if [[ -n "$ASSERT" ]]; then local ASSERT_ARG= ASSERT_ARG='--enable-assert' CONFIGURE_ARG="$ASSERT_ARG $CONFIGURE_ARG" fi # If we are executing on OSX use CLANG, otherwise only use it if we find it in the ENV case $HOST_OS in *-darwin-*) CC=clang CXX=clang++ $top_srcdir/configure $CONFIGURE_ARG || die "Cannot execute CC=clang CXX=clang++ configure $CONFIGURE_ARG $PREFIX_ARG" ;; rhel-5*) command_exists gcc44 || die "Could not locate gcc44" CC=gcc44 CXX=gcc44 $top_srcdir/configure $CONFIGURE_ARG $PREFIX_ARG || die "Cannot execute CC=gcc44 CXX=gcc44 configure $CONFIGURE_ARG $PREFIX_ARG" ;; *) $top_srcdir/configure $CONFIGURE_ARG $PREFIX_ARG || die "Cannot execute configure $CONFIGURE_ARG $PREFIX_ARG" ;; esac if [ ! -f 'Makefile' ]; then die "Programmer error, configure was run but no Makefile existed afterward" fi } setup_gdb_command () { GDB_TMPFILE=$(mktemp /tmp/gdb.XXXXXXXXXX) echo 'set logging overwrite on' > $GDB_TMPFILE echo 'set logging on' >> $GDB_TMPFILE echo 'set environment LIBTEST_IN_GDB=1' >> $GDB_TMPFILE echo 'run' >> $GDB_TMPFILE echo 'thread apply all bt' >> $GDB_TMPFILE echo 'quit' >> $GDB_TMPFILE GDB_COMMAND="gdb -f -batch -x $GDB_TMPFILE" } setup_valgrind_command () { VALGRIND_PROGRAM=`type -p valgrind` if [[ -n "$VALGRIND_PROGRAM" ]]; then VALGRIND_COMMAND="$VALGRIND_PROGRAM --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE" fi } push_PREFIX_ARG () { if [[ -n "$PREFIX_ARG" ]]; then OLD_PREFIX_ARG=$PREFIX_ARG PREFIX_ARG= fi if [[ -n "$1" ]]; then PREFIX_ARG="--prefix=$1" fi } pop_PREFIX_ARG () { if [[ -n "$OLD_PREFIX_ARG" ]]; then PREFIX_ARG=$OLD_TESTS_ENVIRONMENT OLD_PREFIX_ARG= else PREFIX_ARG= fi } push_TESTS_ENVIRONMENT () { if [[ -n "$OLD_TESTS_ENVIRONMENT" ]]; then die "OLD_TESTS_ENVIRONMENT was set on push, programmer error!" fi if [[ -n "$TESTS_ENVIRONMENT" ]]; then OLD_TESTS_ENVIRONMENT=$TESTS_ENVIRONMENT TESTS_ENVIRONMENT= fi } pop_TESTS_ENVIRONMENT () { TESTS_ENVIRONMENT= if [[ -n "$OLD_TESTS_ENVIRONMENT" ]]; then TESTS_ENVIRONMENT=$OLD_TESTS_ENVIRONMENT OLD_TESTS_ENVIRONMENT= fi } function safe_pushd () { pushd $1 &> /dev/null ; if $VERBOSE -a test -n "$BUILD_DIR"; then echo "BUILD_DIR=$BUILD_DIR" fi } function safe_popd () { local directory_to_delete=`pwd` popd &> /dev/null ; if [ $? -eq 0 ]; then if [[ "$top_srcdir" == "$directory_to_delete" ]]; then die "We almost deleted top_srcdir($top_srcdir), programmer error" fi rm -r -f "$directory_to_delete" fi } function make_valgrind () { if [[ "$VENDOR_DISTRIBUTION" == 'darwin' ]]; then make_darwin_malloc return fi # If the env VALGRIND_COMMAND is set then we assume it is valid local valgrind_was_set=false if [[ -z "$VALGRIND_COMMAND" ]]; then setup_valgrind_command if [[ -n "$VALGRIND_COMMAND" ]]; then valgrind_was_set=true fi else valgrind_was_set=true fi # If valgrind_was_set is set to no we bail if ! $valgrind_was_set; then echo 'valgrind was not present' return 1 fi # If we are required to run configure, do so now run_configure_if_required push_TESTS_ENVIRONMENT # If we don't have a configure, then most likely we will be missing libtool assert_file 'configure' if [[ -f 'libtool' ]]; then TESTS_ENVIRONMENT="./libtool --mode=execute $VALGRIND_COMMAND" else TESTS_ENVIRONMENT="$VALGRIND_COMMAND" fi make_target 'check' || return 1 pop_TESTS_ENVIRONMENT } function make_install_system () { local INSTALL_LOCATION=$(mktemp -d /tmp/XXXXXXXXXX) push_PREFIX_ARG $INSTALL_LOCATION if [ ! -d $INSTALL_LOCATION ] ; then die "ASSERT temp directory not found '$INSTALL_LOCATION'" fi run_configure #install_buid_dir push_TESTS_ENVIRONMENT make_target 'install' make_target 'installcheck' make_target 'uninstall' pop_TESTS_ENVIRONMENT pop_PREFIX_ARG rm -r -f $INSTALL_LOCATION make 'distclean' if [ -f 'Makefile' ]; then die "ASSERT Makefile should not exist" fi safe_popd } function make_darwin_malloc () { run_configure_if_required old_MallocGuardEdges=$MallocGuardEdges MallocGuardEdges=1 old_MallocErrorAbort=$MallocErrorAbort MallocErrorAbort=1 old_MallocScribble=$MallocScribble MallocScribble=1 make_check MallocGuardEdges=$old_MallocGuardEdges MallocErrorAbort=$old_MallocErrorAbort MallocScribble=$old_MallocScribble } function snapshot_check () { if [ ! -f "$BOOTSTRAP_SNAPSHOT_CHECK" ]; then make_for_snapshot fi if [ -n "$BOOTSTRAP_SNAPSHOT_CHECK" ]; then assert_file "$BOOTSTRAP_SNAPSHOT_CHECK" 'snapshot check failed' fi } # This will reset our environment, and make sure built files are available. function make_for_snapshot () { # Make sure it is clean make_maintainer_clean run_configure make_target 'dist' make_target 'distclean' # We should have a configure, but no Makefile at the end of this exercise assert_no_file 'Makefile' assert_exec_file 'configure' snapshot_check } function make_for_mingw32 () { # Make sure it is clean if [ -f Makefile -o -f configure ]; then make_maintainer_clean fi assert_no_file 'Makefile' if command_exists mingw32-configure; then run_autoreconf mingw32-configure || die 'mingw32-configure failed' assert_file 'Makefile' if command_exists mingw32-make; then mingw32-make || die 'mingw32-make failed' fi fi } # If we are locally testing, we should make sure the environment is setup correctly function check_for_jenkins () { if ! $jenkins_build_environment; then echo "Not inside of jenkins" if [ -f 'configure' ]; then make_maintainer_clean fi if $BOOTSTRAP_SNAPSHOT; then make_for_snapshot fi fi } function make_universe () { make_for_snapshot make_valgrind make_gdb make_rpm make_for_mingw32 make_distcheck make_install_system } function make_for_continuus_integration () { # Setup the environment if we are local check_for_jenkins # No matter then evironment, we should not have a Makefile at this point assert_no_file 'Makefile' # Platforms which require bootstrap should have some setup done before we hit this stage. # If we are building locally, skip this step, unless we are just testing locally. if $BOOTSTRAP_SNAPSHOT; then snapshot_check else # If we didn't require a snapshot, then we should not have a configure assert_no_file 'configure' run_autoreconf fi assert_no_file 'Makefile' 'Programmer error, Makefile existed where build state should have been clean' case $HOST_OS in *-fedora-*) run_configure assert_exec_file 'configure' assert_file 'Makefile' # make rpm includes "make distcheck" if [[ -f rpm.am ]]; then make_rpm elif [[ -d rpm ]]; then make_rpm else make_distcheck fi assert_exec_file 'configure' assert_file 'Makefile' make_install_system ;; *-precise-*) run_configure assert_exec_file 'configure' assert_file 'Makefile' make_distcheck assert_exec_file 'configure' assert_file 'Makefile' make_valgrind assert_exec_file 'configure' assert_file 'Makefile' make_install_system ;; *) make_jenkins_default ;; esac make_maintainer_clean safe_popd } # The point to this test is to test bootstrap.sh itself function self_test () { # We start off with a clean env make_maintainer_clean eval "./bootstrap.sh jenkins" || die "failed 'jenkins'" eval "./bootstrap.sh all" || die "failed 'all'" eval "./bootstrap.sh gdb" || die "failed 'gdb'" eval "./bootstrap.sh maintainer-clean" || die "failed 'maintainer-clean'" } function make_gdb () { run_configure_if_required if command_exists gdb; then push_TESTS_ENVIRONMENT # Set ENV GDB_COMMAND if [[ -z "$GDB_COMMAND" ]]; then setup_gdb_command fi # If we don't have a configure, then most likely we will be missing libtool assert_file 'configure' if [[ -f 'libtool' ]]; then TESTS_ENVIRONMENT="./libtool --mode=execute $GDB_COMMAND" else TESTS_ENVIRONMENT="$GDB_COMMAND" fi make_target check if [ -f 'gdb.txt' ]; then rm 'gdb.txt' fi pop_TESTS_ENVIRONMENT if [ -f '.gdb_history' ]; then rm '.gdb_history' fi else echo 'gdb was not present' return 1 fi } # $1 target to compile # $2 to die, or not to die, based on contents function make_target () { if [[ -z "$1" ]]; then die "Programmer error, no target provided for make" fi if [ ! -f 'Makefile' ]; then die "Programmer error, make was called before configure" run_configure fi if [ -n "$TESTS_ENVIRONMENT" -a $VERBOSE ]; then echo "TESTS_ENVIRONMENT=$TESTS_ENVIRONMENT" fi if [[ -z "$MAKE" ]]; then die "MAKE was not set" fi if [[ -n "$2" ]]; then run $MAKE $1 || return 1 else run $MAKE $1 || die "Cannot execute $MAKE $1" fi } function make_distcheck () { make_target 'distcheck' } function make_rpm () { if [ -f 'rpm.am' -o -d 'rpm' ]; then run_configure_if_required make_target 'rpm' fi } function make_maintainer_clean () { run_configure_if_required make_target 'maintainer-clean' 'no_error' } function make_check () { make_target 'check' } function make_jenkins_default () { run_configure make_target 'all' } function make_default () { run_configure_if_required make_target 'all' } function run_configure_if_required () { run_autoreconf_if_required if [ ! -f 'Makefile' ]; then run_configure fi assert_file 'Makefile' 'configure did not produce a Makefile' } function run_autoreconf_if_required () { if [ ! -x 'configure' ]; then run_autoreconf fi assert_exec_file 'configure' } function run_autoreconf () { if [[ -z "$AUTORECONF" ]]; then die "Programmer error, tried to call run_autoreconf () but AUTORECONF was not set" fi run $AUTORECONF || die "Cannot execute $AUTORECONF" eval 'bash -n configure' || die "autoreconf generated a malformed configure" } function run () { if $VERBOSE; then echo "\`$@' $ARGS" fi eval $@ $ARGS } parse_command_line_options () { local SHORTOPTS=':apcmt:dvh' nassert MAKE_TARGET while getopts "$SHORTOPTS" opt; do case $opt in a) #--autoreconf AUTORECONF_OPTION=true MAKE_TARGET='autoreconf' ;; p) #--print-env PRINT_SETUP_OPTION=true ;; c) # --configure CONFIGURE_OPTION=true MAKE_TARGET='configure' ;; m) # maintainer-clean CLEAN_OPTION=true MAKE_TARGET='clean_op' ;; t) # target TARGET_OPTION=true TARGET_OPTION_ARG="$OPTARG" MAKE_TARGET="$OPTARG" ;; d) # debug DEBUG_OPTION=true enable_debug ;; h) # help echo "bootstrap.sh [options] optional_target ..." exit ;; v) # verbose VERBOSE_OPTION=true VERBOSE=true ;; :) echo "Option -$OPTARG requires an argument." >&2 exit 1 ;; *) echo "$0: error - unrecognized option $1" 1>&2 exit 1 ;; esac done shift $((OPTIND-1)) if [ -n "$1" ]; then MAKE_TARGET="$@" fi } determine_vcs () { if [[ -d '.git' ]]; then VCS_CHECKOUT=git elif [[ -d '.bzr' ]]; then VCS_CHECKOUT=bzr elif [[ -d '.svn' ]]; then VCS_CHECKOUT=svn elif [[ -d '.hg' ]]; then VCS_CHECKOUT=hg fi if [[ -n "$VCS_CHECKOUT" ]]; then VERBOSE=true fi } autoreconf_setup () { # Set ENV MAKE in order to override "make" if [[ -z "$MAKE" ]]; then if command_exists gmake; then MAKE=`type -p gmake` else if command_exists make; then MAKE=`type -p make` fi fi if [ "$VCS_CHECKOUT" ]; then if $DEBUG; then MAKE="$MAKE --warn-undefined-variables" fi fi if $DEBUG; then MAKE="$MAKE -d" fi fi if [[ -z "$GNU_BUILD_FLAGS" ]]; then GNU_BUILD_FLAGS="--install --force" fi if $VERBOSE; then GNU_BUILD_FLAGS="$GNU_BUILD_FLAGS --verbose" fi if [ -z "$ACLOCAL_PATH" ]; then ACLOCAL_PATH="/usr/local/share/aclocal $ACLOCAL_PATH" fi if [[ -z "$WARNINGS" ]]; then if [[ -n "$VCS_CHECKOUT" ]]; then WARNINGS="all,error" else WARNINGS="all" fi fi if [[ -z "$LIBTOOLIZE" ]]; then # If we are using OSX, we first check to see glibtoolize is available if [[ "$VENDOR_DISTRIBUTION" == "darwin" ]]; then LIBTOOLIZE=`type -p glibtoolize` if [[ -z "$LIBTOOLIZE" ]]; then echo "Couldn't find glibtoolize, it is required on OSX" fi fi fi # Test the ENV AUTOMAKE if it exists if [[ -n "$AUTOMAKE" ]]; then run $AUTOMAKE '--help' &> /dev/null || die "Failed to run AUTOMAKE:$AUTOMAKE" fi # Test the ENV AUTOCONF if it exists if [[ -n "$AUTOCONF" ]]; then run $AUTOCONF '--help' &> /dev/null || die "Failed to run AUTOCONF:$AUTOCONF" fi # Test the ENV AUTOHEADER if it exists if [[ -n "$AUTOHEADER" ]]; then run $AUTOHEADER '--help' &> /dev/null || die "Failed to run AUTOHEADER:$AUTOHEADER" fi # Test the ENV AUTOM4TE if it exists if [[ -n "$AUTOM4TE" ]]; then run $AUTOM4TE '--help' &> /dev/null || die "Failed to run AUTOM4TE:$AUTOM4TE" fi if [[ -z "$AUTORECONF" ]]; then AUTORECONF=`type -p autoreconf` if [[ -z "$AUTORECONF" ]]; then die "Couldn't find autoreconf" fi if [[ -n "$GNU_BUILD_FLAGS" ]]; then AUTORECONF="$AUTORECONF $GNU_BUILD_FLAGS" fi fi run $AUTORECONF '--help' &> /dev/null || die "Failed to run AUTORECONF:$AUTORECONF" } print_setup () { saved_debug_status=$DEBUG if $DEBUG; then disable_debug fi echo '----------------------------------------------' echo 'BOOTSTRAP ENV' echo "AUTORECONF=$AUTORECONF" echo "HOST_OS=$HOST_OS" echo "getopt()" if $AUTORECONF_OPTION; then echo "--autoreconf" fi if $CLEAN_OPTION; then echo "--clean" fi if $CONFIGURE_OPTION; then echo "--configure" fi if $DEBUG_OPTION; then echo "--debug" fi if $PRINT_SETUP_OPTION; then echo "--print-env" fi if $TARGET_OPTION; then echo "--target=$TARGET_OPTION_ARG" fi if $VERBOSE_OPTION; then echo "--verbose" fi if [[ -n "$MAKE" ]]; then echo "MAKE=$MAKE" fi if [[ -n "$MAKE_TARGET" ]]; then echo "MAKE_TARGET=$MAKE_TARGET" fi if [[ -n "$PREFIX" ]]; then echo "PREFIX=$PREFIX" fi if [[ -n "$TESTS_ENVIRONMENT" ]]; then echo "TESTS_ENVIRONMENT=$TESTS_ENVIRONMENT" fi if [[ -n "$VCS_CHECKOUT" ]]; then echo "VCS_CHECKOUT=$VCS_CHECKOUT" fi if $VERBOSE; then echo "VERBOSE=true" fi if $DEBUG; then echo "DEBUG=true" fi if [[ -n "$WARNINGS" ]]; then echo "WARNINGS=$WARNINGS" fi echo '----------------------------------------------' if $saved_debug_status; then enable_debug fi } make_clean_option () { run_configure_if_required make_maintainer_clean if [[ "$VCS_CHECKOUT" == 'git' ]]; then run "$VCS_CHECKOUT" status --ignored elif [[ -n "$VCS_CHECKOUT" ]]; then run "$VCS_CHECKOUT" status fi } make_for_autoreconf () { if [ -f 'Makefile' ]; then make_maintainer_clean fi run_autoreconf assert_no_file 'Makefile' } check_make_target() { case $1 in 'self') ;; 'rpm') ;; 'gdb') ;; 'clean_op') ;; 'autoreconf') ;; 'install-system') ;; 'configure') ;; 'distcheck') ;; 'check') ;; 'snapshot') ;; 'mingw') ;; 'universe') ;; 'valgrind') ;; 'jenkins') ;; 'distclean') ;; 'maintainer-clean') ;; 'install') ;; 'all') ;; 'test-*') ;; 'valgrind-*') ;; 'gdb-*') ;; 'dist') ;; *) die "Unknown MAKE_TARGET option: $1" ;; esac } function bootstrap () { determine_target_platform determine_vcs # Set up whatever we need to do to use autoreconf later autoreconf_setup if [ -z "$MAKE_TARGET" ]; then MAKE_TARGET="make_default" fi if $PRINT_SETUP_OPTION -o $DEBUG; then echo print_setup echo # Exit if all we were looking for were the currently used options if $PRINT_SETUP_OPTION; then exit fi fi # Use OLD_TESTS_ENVIRONMENT for tracking the state of the variable local OLD_TESTS_ENVIRONMENT= # Set ENV PREFIX in order to set --prefix for ./configure if [[ -n "$PREFIX" ]]; then push_PREFIX_ARG $PREFIX fi # We should always have a target by this point assert MAKE_TARGET local MAKE_TARGET_ARRAY=($MAKE_TARGET) for target in "${MAKE_TARGET_ARRAY[@]}" do # If we are running inside of Jenkins, we want to only run some of the possible tests if $jenkins_build_environment; then check_make_target $target fi case $target in 'self') self_test ;; 'gdb') make_gdb ;; 'clean_op') make_clean_option ;; 'autoreconf') make_for_autoreconf ;; 'install-system') make_install_system ;; 'configure') run_configure ;; 'default') make run_configure ;; 'mingw') make_for_mingw32 ;; 'snapshot') make_for_snapshot ;; 'rpm') make_rpm ;; 'valgrind') make_valgrind ;; 'universe') make_universe ;; 'jenkins') make_for_continuus_integration ;; *) run_configure_if_required make_target "$target" ;; esac done } main () { # Variables we export declare -x VCS_CHECKOUT= # Variables we control globally local MAKE_TARGET= # Options for getopt local AUTORECONF_OPTION=false local CLEAN_OPTION=false local CONFIGURE_OPTION=false local DEBUG_OPTION=false local PRINT_SETUP_OPTION=false local TARGET_OPTION=false local TARGET_OPTION_ARG= local VERBOSE_OPTION=false # If we call autoreconf on the platform or not local AUTORECONF_REBUILD_HOST=false local AUTORECONF_REBUILD=false local -r top_srcdir=`pwd` # Variables for determine_target_platform () and rebuild_host_os () # UNAME_MACHINE_ARCH= uname -m # VENDOR= apple, redhat, centos, canonical # VENDOR_RELEASE= # RHEL{rhel,Tikanga,Santiago} # Ubuntu{ubuntu,Lucid,Maverick,Natty,Oneiric,Precise,Quantal} # Fedora{fedora,Verne,Beefy} # OSX{osx,lion,snow,mountain} # VENDOR_DISTRIBUTION= darwin,fedora,rhel,ubuntu # UNAME_KERNEL= Linux, Darwin,... # UNAME_KERNEL_RELEASE= Linux, Darwin,... local UNAME_MACHINE_ARCH=unknown local VENDOR=unknown local VENDOR_RELEASE=unknown local VENDOR_DISTRIBUTION=unknown local UNAME_KERNEL=unknown local UNAME_KERNEL_RELEASE=unknown local HOST_OS= rebuild_host_os no_output parse_command_line_options $@ # If we are running under Jenkins we predetermine what tests we will run against # This MAKE_TARGET can be overridden by parse_command_line_options based MAKE_TARGET changes. # We don't want Jenkins overriding other variables, so we NULL them. if [ -z "$MAKE_TARGET" -a $jenkins_build_environment ]; then MAKE_TARGET='jenkins' fi bootstrap jobs -l wait exit 0 } enable_debug () { if ! $DEBUG; then local caller_loc=`caller` if [ -n $1 ]; then echo "$caller_loc Enabling debug: $1" else echo "$caller_loc Enabling debug" fi set -x DEBUG=true fi } disable_debug () { set +x DEBUG=true } # Script begins here env_debug_enabled=false if [[ -n "$JENKINS_HOME" ]]; then declare -r jenkins_build_environment=true else declare -r jenkins_build_environment=false fi export AUTOCONF export AUTOHEADER export AUTOM4TE export AUTOMAKE export AUTORECONF export DEBUG export GNU_BUILD_FLAGS export MAKE export TESTS_ENVIRONMENT export VERBOSE export WARNINGS case $OSTYPE in darwin*) export MallocGuardEdges export MallocErrorAbort export MallocScribble ;; esac # We check for DEBUG twice, once before we source the config file, and once afterward env_debug_enabled=false if [[ -n "$DEBUG" ]]; then env_debug_enabled=true enable_debug print_setup fi # Variables which only can be set by .bootstrap BOOTSTRAP_SNAPSHOT=false BOOTSTRAP_SNAPSHOT_CHECK= if [ -f '.bootstrap' ]; then source '.bootstrap' fi if $env_debug_enabled; then enable_debug else if [[ -n "$DEBUG" ]]; then enable_debug "Enabling DEBUG from '.bootstrap'" print_setup fi fi # We do this in order to protect the case where DEBUG if ! $env_debug_enabled; then DEBUG=false fi main $@