exit 127
}
-die ()
+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
+ echo "$bash_source:$bash_lineno: assert($param_name)" >&2
exit 1
fi
}
fi
}
-safe_pushd ()
+function safe_pushd ()
{
pushd $1 &> /dev/null ;
fi
}
-safe_popd ()
+function safe_popd ()
{
local directory_to_delete=`pwd`
popd &> /dev/null ;
fi
}
-make_valgrind ()
+function make_valgrind ()
{
if [[ "$VENDOR_DISTRIBUTION" == 'darwin' ]]; then
make_darwin_malloc
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_COMMAND $VALGRIND_COMMAND"
+ TESTS_ENVIRONMENT="./libtool --mode=execute $VALGRIND_COMMAND"
else
TESTS_ENVIRONMENT="$VALGRIND_COMMAND"
fi
pop_TESTS_ENVIRONMENT
}
-make_install_system ()
+function make_install_system ()
{
local INSTALL_LOCATION=$(mktemp -d /tmp/XXXXXXXXXX)
push_PREFIX_ARG $INSTALL_LOCATION
safe_popd
}
-make_darwin_malloc ()
+function make_darwin_malloc ()
{
run_configure_if_required
MallocScribble=$old_MallocScribble
}
-snapshot_check ()
+function snapshot_check ()
{
if [ -n "$BOOTSTRAP_SNAPSHOT_CHECK" ]; then
assert_file "$BOOTSTRAP_SNAPSHOT_CHECK" 'snapshot check failed'
}
# This will reset our environment, and make sure built files are available.
-make_for_snapshot ()
+function make_for_snapshot ()
{
# Make sure it is clean
make_maintainer_clean
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
-check_for_jenkins ()
+function check_for_jenkins ()
{
if ! $jenkins_build_environment; then
echo "Not inside of jenkins"
fi
}
-make_for_continuus_integration ()
+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
make_install_system
;;
*)
- run_configure
- make_all
+ make_jenkins_default
;;
esac
safe_popd
}
-make_gdb ()
+# 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
setup_gdb_command
fi
- if [ -f 'libtool' ]; then
- TESTS_ENVIRONMENT="$LIBTOOL_COMMAND $GDB_COMMAND"
+ # 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
run_configure
fi
- if test -n "$TESTS_ENVIRONMENT" -a $VERBOSE; then
+ if [ -n "$TESTS_ENVIRONMENT" -a $VERBOSE ]; then
echo "TESTS_ENVIRONMENT=$TESTS_ENVIRONMENT"
fi
fi
}
-make_distcheck ()
+function make_distcheck ()
{
make_target 'distcheck'
}
-make_rpm ()
+function make_rpm ()
{
- make_target 'rpm'
+ if [ -f 'rpm.am' -o -d 'rpm' ]; then
+ run_configure_if_required
+ make_target 'rpm'
+ fi
}
-make_maintainer_clean ()
+function make_maintainer_clean ()
{
run_configure_if_required
make_target 'maintainer-clean' 'no_error'
}
-make_check ()
+function make_check ()
{
make_target 'check'
}
-make_all ()
+function make_jenkins_default ()
{
+ run_configure
+ make_target 'all'
+}
+
+function make_default ()
+{
+ run_configure_if_required
make_target 'all'
}
-run_configure_if_required ()
+function run_configure_if_required ()
{
run_autoreconf_if_required
assert_file 'Makefile' 'configure did not produce a Makefile'
}
-run_autoreconf_if_required ()
+function run_autoreconf_if_required ()
{
if [ ! -x 'configure' ]; then
run_autoreconf
assert_exec_file 'configure'
}
-run_autoreconf ()
+function run_autoreconf ()
{
if [[ -z "$AUTORECONF" ]]; then
die "Programmer error, tried to call run_autoreconf () but AUTORECONF was not set"
echo "\`$@' $ARGS"
fi
- $@ $ARGS
+ eval $@ $ARGS
}
parse_command_line_options ()
{
- local SHORTOPTS=':apcmt:dv'
+ local SHORTOPTS=':apcmt:dvh'
+
+ nassert MAKE_TARGET
while getopts "$SHORTOPTS" opt; do
case $opt in
DEBUG_OPTION=true
enable_debug
;;
+ h) # help
+ echo "bootstrap.sh [options] optional_target ..."
+ exit
+ ;;
v) # verbose
VERBOSE_OPTION=true
VERBOSE=true
esac
done
+ shift $((OPTIND-1))
+
if [ -n "$1" ]; then
- MAKE_TARGET="$1"
+ MAKE_TARGET="$@"
fi
}
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 command_exists make; then
- MAKE=`type -p make`
+ if $DEBUG; then
+ MAKE="$MAKE -d"
fi
fi
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"
check_make_target()
{
case $1 in
+ 'self')
+ ;;
'gdb')
;;
'clean_op')
;;
'configure')
;;
+ 'distcheck')
+ ;;
+ 'check')
+ ;;
'snapshot')
;;
+ 'mingw')
+ ;;
+ 'universe')
+ ;;
'valgrind')
;;
'jenkins')
;;
'all')
;;
+ 'test-*')
+ ;;
+ 'valgrind-*')
+ ;;
+ 'gdb-*')
+ ;;
'dist')
;;
*)
esac
}
-bootstrap ()
+function bootstrap ()
{
determine_target_platform
# 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
fi
fi
- # Setup LIBTOOL_COMMAND if we need it
- if [ -f 'libtool' ]; then
- LIBTOOL_COMMAND='./libtool --mode=execute'
- fi
-
# Use OLD_TESTS_ENVIRONMENT for tracking the state of the variable
local OLD_TESTS_ENVIRONMENT=
push_PREFIX_ARG $PREFIX
fi
- # Either we run a known target (or error), or we default to "all"
- if [[ -n "$MAKE_TARGET" ]]; then
+ # 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 $MAKE_TARGET
+ check_make_target $target
fi
- case $MAKE_TARGET in
+ case $target in
+ 'self')
+ self_test
+ ;;
'gdb')
make_gdb
;;
'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 $MAKE_TARGET
+ make_target "$target"
;;
esac
- else
- run_configure_if_required
- make_all
- fi
+ done
}
main ()
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 $jenkins_build_environment; then
+ if [ -z "$MAKE_TARGET" -a $jenkins_build_environment ]; then
MAKE_TARGET='jenkins'
fi
- parse_command_line_options $@
-
bootstrap
jobs -l