#!/bin/bash

#

# Copyright (C) 2012-2013 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 ()

{

warn "$@: command not found"

#if $DEBUG; then

echo ""

echo "Stack trace:"

local frame=0

while caller $frame; do

((frame++));

done

echo ""

#fi

return 127

}

function error ()

{

echo "$BASH_SOURCE:$BASH_LINENO: $@" >&2

}

function die ()

{

echo "$BASH_SOURCE:$BASH_LINENO: $@" >&2

exit 1;

}

function warn ()

{

echo "$BASH_SOURCE:$BASH_LINENO: $@"

#echo "$BASH_SOURCE:$BASH_LINENO: $@" >&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

}

function assert_file ()

{

if [ ! -f "$1" ]; then

echo "$BASH_SOURCE:$BASH_LINENO: assert($1) does not exist: $2" >&2

exit 1;

fi

}

function assert_no_file ()

{

if [ -f "$1" ]; then

echo "$BASH_SOURCE:$BASH_LINENO: assert($1) file exists: $2" >&2

exit 1;

fi

}

function assert_no_directory ()

{

if [ -d "$1" ]; then

echo "$BASH_SOURCE:$BASH_LINENO: assert($1) directory exists: $2" >&2

exit 1;

fi

}

function 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

}

function command_exists ()

{

type "$1" &> /dev/null ;

}

function 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

}

# Validate the distribution name, or toss an erro

# values: darwin,fedora,rhel,ubuntu,debian,opensuse

function 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'

;;

debian)

VENDOR_DISTRIBUTION='debian'

;;

ubuntu)

VENDOR_DISTRIBUTION='ubuntu'

;;

suse)

VENDOR_DISTRIBUTION='opensuse'

;;

opensuse)

VENDOR_DISTRIBUTION='opensuse'

;;

*)

die "attempt to set an invalid VENDOR_DISTRIBUTION=$dist"

;;

esac

}

# Validate a Vendor's release name/number

function set_VENDOR_RELEASE ()

{

local release=`echo "$1" | tr '[A-Z]' '[a-z]'`

if $DEBUG; then

echo "VENDOR_DISTRIBUTION:$VENDOR_DISTRIBUTION"

echo "VENDOR_RELEASE:$release"

fi

case $VENDOR_DISTRIBUTION in

darwin)

case $release in

10.6*)

VENDOR_RELEASE='snow_leopard'

;;

10.7*)

VENDOR_RELEASE='mountain'

;;

mountain)

VENDOR_RELEASE='mountain'

;;

10.8.*)

echo "mountain_lion"

VENDOR_RELEASE='mountain_lion'

;;

*)

echo $VENDOR_RELEASE

VENDOR_RELEASE='unknown'

;;

esac

;;

fedora)

VENDOR_RELEASE="$release"

if [[ "x$VENDOR_RELEASE" == '18' ]]; then

VENDOR_RELEASE='sphericalcow'

fi

;;

rhel)

VENDOR_RELEASE="$release"

;;

debian)

VENDOR_RELEASE="$release"

;;

ubuntu)

VENDOR_RELEASE="$release"

if [[ "x$VENDOR_RELEASE" == 'x12.04' ]]; then

VENDOR_RELEASE="precise"

elif [[ "x$VENDOR_RELEASE" == 'x12.10' ]]; then

VENDOR_RELEASE="quantal"

fi

;;

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, oracle, suse

function set_VENDOR ()

{

local vendor=`echo "$1" | tr '[A-Z]' '[a-z]'`

case $vendor in

apple)

VENDOR='apple'

;;

redhat)

VENDOR='redhat'

;;

fedora)

VENDOR='redhat'

;;

redhat-release-server-*)

VENDOR='redhat'

;;

enterprise-release-*)

VENDOR='oracle'

;;

centos)

VENDOR='centos'

;;

canonical)

VENDOR='canonical'

;;

ubuntu)

VENDOR='canonical'

;;

debian)

VENDOR='debian'

;;

opensuse)

VENDOR='suse'

;;

suse)

VENDOR='suse'

;;

*)

die "An attempt was made to set an invalid VENDOR=$_vendor"

;;

esac

set_VENDOR_DISTRIBUTION $2

set_VENDOR_RELEASE $3

# Set which vendor/versions we trust for autoreconf

case $VENDOR_DISTRIBUTION in

fedora)

if [[ "x$VENDOR_RELEASE" == 'x18' ]]; then

AUTORECONF_REBUILD_HOST=true

elif [[ "x$VENDOR_RELEASE" == 'xsphericalcow' ]]; then

AUTORECONF_REBUILD_HOST=true

elif [[ "x$VENDOR_RELEASE" == 'x19' ]]; then

AUTORECONF_REBUILD_HOST=true

fi

;;

canonical)

if [[ "x$VENDOR_RELEASE" == 'xprecise' ]]; then

AUTORECONF_REBUILD_HOST=true

elif [[ "x$VENDOR_RELEASE" == 'xquantal' ]]; then

AUTORECONF_REBUILD_HOST=true

fi

;;

esac

}

function 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 [[ -x '/usr/bin/sw_vers' ]]; then

local _VERSION=`/usr/bin/sw_vers -productVersion`

set_VENDOR 'apple' 'darwin' $_VERSION

elif [[ $(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

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 } '`

local _vendor=`rpm -qf /etc/redhat-release`

set_VENDOR $_vendor 'rhel' $rhel_version

elif [[ -f '/etc/os-release' ]]; then

source '/etc/os-release'

set_VENDOR $ID $ID $VERSION_ID

elif [[ -x '/usr/bin/lsb_release' ]]; then

local _ID=`/usr/bin/lsb_release -s -i`

local _VERSION=`/usr/bin/lsb_release -s -r`

set_VENDOR $_ID $_ID $_VERSION_ID

elif [[ -f '/etc/lsb-release' ]]; then

source '/etc/lsb-release'

set_VENDOR 'canonical' $DISTRIB_ID $DISTRIB_CODENAME

fi

rebuild_host_os

}

function 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

if ! command_exists "$CONFIGURE"; then

die "$CONFIGURE does not exist"

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 BUILD_CONFIGURE_ARG=

# If ENV DEBUG is set we enable both debug and asssert, otherwise we see if this is a VCS checkout and if so enable assert

# Set ENV ASSERT in order to enable assert.

# If we are doing a valgrind run, we always compile with assert disabled

if $valgrind_run; then

BUILD_CONFIGURE_ARG+= " CXXFLAGS=-DNDEBUG "

BUILD_CONFIGURE_ARG+= " CFLAGS=-DNDEBUG "

else

if $DEBUG; then

BUILD_CONFIGURE_ARG+=' --enable-debug --enable-assert'

elif [[ -n "$VCS_CHECKOUT" ]]; then

BUILD_CONFIGURE_ARG+=' --enable-assert'

fi

fi

if [[ -n "$CONFIGURE_ARG" ]]; then

BUILD_CONFIGURE_ARG+=" $CONFIGURE_ARG"

fi

if [[ -n "$PREFIX_ARG" ]]; then

BUILD_CONFIGURE_ARG+=" $PREFIX_ARG"

fi

ret=1;

# 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 $BUILD_CONFIGURE_ARG || die "Cannot execute CC=clang CXX=clang++ configure $BUILD_CONFIGURE_ARG"

ret=$?

;;

rhel-5*)

command_exists 'gcc44' || die "Could not locate gcc44"

CC=gcc44 CXX=gcc44 $top_srcdir/configure $BUILD_CONFIGURE_ARG || die "Cannot execute CC=gcc44 CXX=gcc44 configure $BUILD_CONFIGURE_ARG"

ret=$?

;;

*)

$CONFIGURE $BUILD_CONFIGURE_ARG

ret=$?

;;

esac

if [ $ret -ne 0 ]; then

die "Could not execute $CONFIGURE $BUILD_CONFIGURE_ARG"

fi

if [ ! -f 'Makefile' ]; then

die "Programmer error, configure was run but no Makefile existed after $CONFIGURE was run"

fi

}

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

}

function 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 --malloc-fill=A5 --free-fill=DE --xml=yes --xml-file=\"valgrind-%p.xml\""

fi

}

function save_BUILD ()

{

if [[ -n "$OLD_CONFIGURE" ]]; then

die "OLD_CONFIGURE($OLD_CONFIGURE) was set on push, programmer error!"

fi

if [[ -n "$OLD_CONFIGURE_ARG" ]]; then

die "OLD_CONFIGURE_ARG($OLD_CONFIGURE_ARG) was set on push, programmer error!"

fi

if [[ -n "$OLD_PREFIX" ]]; then

die "OLD_PREFIX($OLD_PREFIX) was set on push, programmer error!"

fi

if [[ -n "$OLD_MAKE" ]]; then

die "OLD_MAKE($OLD_MAKE) was set on push, programmer error!"

fi

if [[ -n "$OLD_TESTS_ENVIRONMENT" ]]; then

die "OLD_TESTS_ENVIRONMENT($OLD_TESTS_ENVIRONMENT) was set on push, programmer error!"

fi

if [[ -n "$CONFIGURE" ]]; then

OLD_CONFIGURE=$CONFIGURE

fi

if [[ -n "$CONFIGURE_ARG" ]]; then

OLD_CONFIGURE_ARG=$CONFIGURE_ARG

fi

if [[ -n "$MAKE" ]]; then

OLD_MAKE=$MAKE

fi

if [[ -n "$TESTS_ENVIRONMENT" ]]; then

OLD_TESTS_ENVIRONMENT=$TESTS_ENVIRONMENT

fi

}

function restore_BUILD ()

{

if [[ -n "$OLD_CONFIGURE" ]]; then

CONFIGURE=$OLD_CONFIGURE

fi

if [[ -n "$OLD_CONFIGURE_ARG" ]]; then

CONFIGURE_ARG=$OLD_CONFIGURE_ARG

fi

if [[ -n "$OLD_PREFIX" ]]; then

PREFIX_ARG=$OLD_PREFIX

fi

if [[ -n "$OLD_MAKE" ]]; then

MAKE=$OLD_MAKE

fi

if [[ -n "$OLD_TESTS_ENVIRONMENT" ]]; then

TESTS_ENVIRONMENT=$OLD_TESTS_ENVIRONMENT

fi

OLD_CONFIGURE=

OLD_CONFIGURE_ARG=

OLD_PREFIX=

OLD_MAKE=

OLD_TESTS_ENVIRONMENT=

export -n CC CXX

}

function safe_pushd ()

{

pushd $1 &> /dev/null ;

if [ -n "$BUILD_DIR" ]; then

if $VERBOSE; then

echo "BUILD_DIR=$BUILD_DIR"

fi

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

save_BUILD

valgrind_run=true

# If we are required to run configure, do so now

run_configure

# 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'

ret=$?

# If we aren't going to error, we will clean up our environment

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

make 'distclean'

fi

valgrind_run=false

restore_BUILD

if [ "$ret" -ne 0 ]; then

return 1

fi

}

function make_install_system ()

{

local INSTALL_LOCATION=$(mktemp -d /tmp/XXXXXXXXXX)

save_BUILD

PREFIX_ARG="--prefix=$INSTALL_LOCATION"

if [ ! -d $INSTALL_LOCATION ] ; then

die "ASSERT temp directory not found '$INSTALL_LOCATION'"

fi

run_configure #install_buid_dir

make_target 'install'

make_target 'installcheck'

make_target 'uninstall'

rm -r -f $INSTALL_LOCATION

make 'distclean'

if [ -f 'Makefile' ]; then

die "ASSERT Makefile should not exist"

fi

restore_BUILD

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 check_mingw ()

{

command_exists 'mingw64-configure'

ret=$?

if [ "$ret" -ne 0 ]; then

return 1

fi

command_exists 'mingw64-make'

ret=$?

if [ "$ret" -ne 0 ]; then

return 1

fi

return 0

}

function check_clang ()

{

command_exists 'clang'

ret=$?

if [ "$ret" -ne 0 ]; then

return 1

fi

return 0

}

function check_clang_analyzer ()

{

command_exists 'scan-build'

ret=$?

if [ "$ret" -ne 0 ]; then

return 1

fi

return 0

}

function make_skeleton ()

{

run_configure

ret=$?

if [ $ret -eq 0 ]; then

assert_file 'Makefile'

make_target 'all' 'warn'

ret=$?

if [ $ret -ne 0 ]; then

warn "$MAKE failed"

else

if [[ -n "$DISPLAY" ]]; then

if command_exists 'wine'; then

TESTS_ENVIRONMENT='wine'

fi

fi

if [[ -n "$TESTS_ENVIRONMENT" ]]; then

make_target 'check' 'warn' || warn "$MAKE check failed"

ret=$?

fi

fi

if $jenkins_build_environment; then

make_target 'clean' 'warn'

fi

fi

return $ret

}

function make_for_mingw ()

{

if ! check_mingw; then

return 1

fi

# Make sure it is clean

if [ -f Makefile -o -f configure ]; then

make_maintainer_clean

fi

run_autoreconf

save_BUILD

CONFIGURE='mingw64-configure'

MAKE='mingw64-make'

CONFIGURE_ARGS='--enable-static --disable-shared'

make_skeleton

ret=$?

restore_BUILD

return $ret

}

function make_for_clang ()

{

if ! check_clang; then

return 1

fi

# Make sure it is clean

if [ -f Makefile -o -f configure ]; then

make_maintainer_clean

fi

run_autoreconf

save_BUILD

CC=clang CXX=clang++

export CC CXX

make_skeleton

ret=$?

make_target 'check'

restore_BUILD

return $ret

}

function make_for_clang_analyzer ()

{

if ! check_clang; then

return 1

fi

if ! check_clang_analyzer; then

die 'clang-analyzer was not found'

fi

# Make sure it is clean

if [ -f Makefile -o -f configure ]; then

make_maintainer_clean

fi

run_autoreconf

save_BUILD

CC=clang CXX=clang++

export CC CXX

CONFIGURE_ARGS='--enable-debug'

make_skeleton

ret=$?

make_target 'clean' 'warn'

scan-build -o clang-html make -j4 -k

restore_BUILD

return $ret

}

# 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_clang

make_for_clang_analyzer

if [ check_mingw -eq 0 ]; then

make_for_mingw

fi

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_target 'all'

# 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_target 'all'

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_install_html ()

{

run_configure_if_required

assert_file 'configure'

make_target 'install-html'

}

function make_gdb ()

{

save_BUILD

if command_exists 'gdb'; then

run_configure_if_required

# 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

if [ -f '.gdb_history' ]; then

rm '.gdb_history'

fi

if $jenkins_build_environment; then

make_target 'clean'

fi

else

echo 'gdb was not present'

return 1

fi

restore_BUILD