git.m6w6.name Git - m6w6/libmemcached/blob - bootstrap.sh

   1 #!/bin/bash
   2 #
   3 # Copyright (C) 2012-2013 Brian Aker
   4 # All rights reserved.
   5 #
   6 # Redistribution and use in source and binary forms, with or without
   7 # modification, are permitted provided that the following conditions are
   8 # met:
   9 #
  10 #     * Redistributions of source code must retain the above copyright
  11 # notice, this list of conditions and the following disclaimer.
  12 #
  13 #     * Redistributions in binary form must reproduce the above
  14 # copyright notice, this list of conditions and the following disclaimer
  15 # in the documentation and/or other materials provided with the
  16 # distribution.
  17 #
  18 #     * The names of its contributors may not be used to endorse or
  19 # promote products derived from this software without specific prior
  20 # written permission.
  21 #
  22 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  26 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  32 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33
  34
  35 # Environment Variables that will influence the build:
  36 #   AUTOMAKE
  37 #   AUTORECONF
  38 #   LIBTOOLIZE
  39 #   MAKE
  40 #   PREFIX
  41 #   TESTS_ENVIRONMENT
  42 #   VERBOSE
  43 #   WARNINGS
  44 #
  45
  46 command_not_found_handle ()
  47 {
  48   warn "$@: command not found"
  49
  50   #if $DEBUG; then
  51     echo ""
  52     echo "Stack trace:"
  53     local frame=0
  54     while caller $frame; do
  55       ((frame++));
  56     done
  57     echo ""
  58   #fi
  59
  60   return 127
  61 }
  62
  63 function error ()
  64 {
  65   echo "$BASH_SOURCE:$BASH_LINENO: $@" >&2
  66 }
  67
  68 function die ()
  69 {
  70   echo "$BASH_SOURCE:$BASH_LINENO: $@" >&2
  71   exit 1;
  72 }
  73
  74 function warn ()
  75 {
  76   echo "$BASH_SOURCE:$BASH_LINENO: $@"
  77   #echo "$BASH_SOURCE:$BASH_LINENO: $@" >&1
  78 }
  79
  80 function nassert ()
  81 {
  82   local param_name=\$"$1"
  83   local param_value=`eval "expr \"$param_name\" "`
  84
  85   if [ -n "$param_value" ]; then
  86     echo "$bash_source:$bash_lineno: assert($param_name) had value of "$param_value"" >&2
  87     exit 1
  88   fi
  89 }
  90
  91 function assert ()
  92 {
  93   local param_name=\$"$1"
  94   local param_value=`eval "expr \"$param_name\" "`
  95
  96   if [ -z "$param_value" ]; then
  97     echo "$bash_source:$bash_lineno: assert($param_name)" >&2
  98     exit 1
  99   fi
 100 }
 101
 102 function assert_file ()
 103 {
 104   if [ ! -f "$1" ]; then
 105     echo "$BASH_SOURCE:$BASH_LINENO: assert($1) does not exist: $2" >&2
 106     exit 1;
 107   fi
 108 }
 109
 110 function assert_no_file ()
 111 {
 112   if [ -f "$1" ]; then
 113     echo "$BASH_SOURCE:$BASH_LINENO: assert($1) file exists: $2" >&2
 114     exit 1;
 115   fi
 116 }
 117
 118 function assert_no_directory ()
 119 {
 120   if [ -d "$1" ]; then
 121     echo "$BASH_SOURCE:$BASH_LINENO: assert($1) directory exists: $2" >&2
 122     exit 1;
 123   fi
 124 }
 125
 126 function assert_exec_file ()
 127 {
 128   if [ ! -f "$1" ]; then
 129     echo "$BASH_SOURCE:$BASH_LINENO: assert($1) does not exist: $2" >&2
 130     exit 1;
 131   fi
 132
 133   if [ ! -x "$1" ]; then
 134     echo "$BASH_SOURCE:$BASH_LINENO: assert($1) exists but is not executable: $2" >&2
 135     exit 1;
 136   fi
 137 }
 138
 139 function command_exists ()
 140 {
 141   type "$1" &> /dev/null ;
 142 }
 143
 144 function rebuild_host_os ()
 145 {
 146   HOST_OS="${UNAME_MACHINE_ARCH}-${VENDOR}-${VENDOR_DISTRIBUTION}-${VENDOR_RELEASE}-${UNAME_KERNEL}-${UNAME_KERNEL_RELEASE}"
 147   if [ -z "$1" ]; then
 148     if $VERBOSE; then
 149       echo "HOST_OS=$HOST_OS"
 150     fi
 151   fi
 152 }
 153
 154 # Validate the distribution name, or toss an erro
 155 #  values: darwin,fedora,rhel,ubuntu,debian,opensuse
 156 function set_VENDOR_DISTRIBUTION ()
 157 {
 158   local dist=`echo "$1" | tr '[A-Z]' '[a-z]'`
 159   case "$dist" in
 160     darwin)
 161       VENDOR_DISTRIBUTION='darwin'
 162       ;;
 163     fedora)
 164       VENDOR_DISTRIBUTION='fedora'
 165       ;;
 166     rhel)
 167       VENDOR_DISTRIBUTION='rhel'
 168       ;;
 169     debian)
 170       VENDOR_DISTRIBUTION='debian'
 171       ;;
 172     ubuntu)
 173       VENDOR_DISTRIBUTION='ubuntu'
 174       ;;
 175     suse)
 176       VENDOR_DISTRIBUTION='opensuse'
 177       ;;
 178     opensuse)
 179       VENDOR_DISTRIBUTION='opensuse'
 180       ;;
 181     *)
 182       die "attempt to set an invalid VENDOR_DISTRIBUTION=$dist"
 183       ;;
 184   esac
 185 }
 186
 187 # Validate a Vendor's release name/number
 188 function set_VENDOR_RELEASE ()
 189 {
 190   local release=`echo "$1" | tr '[A-Z]' '[a-z]'`
 191   case "$VENDOR_DISTRIBUTION" in
 192     darwin)
 193       case "$VENDOR_DISTRIBUTION" in
 194         10.6*)
 195           VENDOR_RELEASE='snow_leopard'
 196           ;;
 197         10.7*)
 198           VENDOR_RELEASE='mountain'
 199           ;;
 200         mountain)
 201           VENDOR_RELEASE='mountain'
 202           ;;
 203         10.8*)
 204           VENDOR_RELEASE='mountain_lion'
 205           ;;
 206         *)
 207           VENDOR_RELEASE='unknown'
 208           ;;
 209       esac
 210       ;;
 211     fedora)
 212       VENDOR_RELEASE="$release"
 213       if [[ "x$VENDOR_RELEASE" == '18' ]]; then
 214         VENDOR_RELEASE='sphericalcow'
 215       fi
 216       ;;
 217     rhel)
 218       VENDOR_RELEASE="$release"
 219       ;;
 220     debian)
 221       VENDOR_RELEASE="$release"
 222       ;;
 223     ubuntu)
 224       VENDOR_RELEASE="$release"
 225       if [[ "x$VENDOR_RELEASE" == 'x12.04' ]]; then
 226         VENDOR_RELEASE="precise"
 227       elif [[ "x$VENDOR_RELEASE" == 'x12.10' ]]; then
 228         VENDOR_RELEASE="quantal"
 229       fi
 230       ;;
 231     opensuse)
 232       VENDOR_RELEASE="$release"
 233       ;;
 234     unknown)
 235       die "attempt to set VENDOR_RELEASE without setting VENDOR_DISTRIBUTION"
 236       ;;
 237     *)
 238       die "attempt to set with an invalid VENDOR_DISTRIBUTION=$VENDOR_DISTRIBUTION"
 239       ;;
 240   esac
 241 }
 242
 243
 244 #  Valid values are: apple, redhat, centos, canonical, oracle, suse
 245 function set_VENDOR ()
 246 {
 247   local vendor=`echo "$1" | tr '[A-Z]' '[a-z]'`
 248
 249   case $vendor in
 250     apple)
 251       VENDOR='apple'
 252       ;;
 253     redhat)
 254       VENDOR='redhat'
 255       ;;
 256     fedora)
 257       VENDOR='redhat'
 258       ;;
 259     redhat-release-server-*)
 260       VENDOR='redhat'
 261       ;;
 262     enterprise-release-*)
 263       VENDOR='oracle'
 264       ;;
 265     centos)
 266       VENDOR='centos'
 267       ;;
 268     canonical)
 269       VENDOR='canonical'
 270       ;;
 271     ubuntu)
 272       VENDOR='canonical'
 273       ;;
 274     debian)
 275       VENDOR='debian'
 276       ;;
 277     opensuse)
 278       VENDOR='suse'
 279       ;;
 280     suse)
 281       VENDOR='suse'
 282       ;;
 283     *)
 284       die "An attempt was made to set an invalid VENDOR=$_vendor"
 285       ;;
 286   esac
 287
 288   set_VENDOR_DISTRIBUTION $2
 289   set_VENDOR_RELEASE $3
 290
 291   # Set which vendor/versions we trust for autoreconf
 292   case $VENDOR_DISTRIBUTION in
 293     fedora)
 294       if [[ "x$VENDOR_RELEASE" == 'x18' ]]; then
 295         AUTORECONF_REBUILD_HOST=true
 296       elif [[ "x$VENDOR_RELEASE" == 'xsphericalcow' ]]; then
 297         AUTORECONF_REBUILD_HOST=true
 298       elif [[ "x$VENDOR_RELEASE" == 'x19' ]]; then
 299         AUTORECONF_REBUILD_HOST=true
 300       fi
 301       ;;
 302     canonical)
 303       if [[ "x$VENDOR_RELEASE" == 'xprecise' ]]; then
 304         AUTORECONF_REBUILD_HOST=true
 305       elif [[ "x$VENDOR_RELEASE" == 'xquantal' ]]; then
 306         AUTORECONF_REBUILD_HOST=true
 307       fi
 308       ;;
 309   esac
 310
 311 }
 312
 313 function determine_target_platform ()
 314 {
 315   UNAME_MACHINE_ARCH=`(uname -m) 2>/dev/null` || UNAME_MACHINE_ARCH=unknown
 316   UNAME_KERNEL=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
 317   UNAME_KERNEL_RELEASE=`(uname -r) 2>/dev/null` || UNAME_KERNEL_RELEASE=unknown
 318
 319   if [[ -x '/usr/bin/sw_vers' ]]; then
 320     local _VERSION=`/usr/bin/sw_vers -productVersion`
 321     set_VENDOR 'apple' 'darwin' $_VERSION
 322   elif [[ $(uname) == 'Darwin' ]]; then
 323     set_VENDOR 'apple' 'darwin' 'mountain'
 324   elif [[ -f '/etc/fedora-release' ]]; then
 325     local fedora_version=`cat /etc/fedora-release | awk ' { print $3 } '`
 326     set_VENDOR 'redhat' 'fedora' $fedora_version
 327   elif [[ -f '/etc/centos-release' ]]; then
 328     local centos_version=`cat /etc/centos-release | awk ' { print $7 } '`
 329     set_VENDOR 'centos' 'rhel' $centos_version
 330   elif [[ -f '/etc/SuSE-release' ]]; then
 331     local suse_distribution=`head -1 /etc/SuSE-release | awk ' { print $1 } '`
 332     local suse_version=`head -1 /etc/SuSE-release | awk ' { print $2 } '`
 333     set_VENDOR 'suse' $suse_distribution $suse_version
 334   elif [[ -f '/etc/redhat-release' ]]; then
 335     local rhel_version=`cat /etc/redhat-release | awk ' { print $7 } '`
 336     local _vendor=`rpm -qf /etc/redhat-release`
 337     set_VENDOR $_vendor 'rhel' $rhel_version
 338   elif [[ -f '/etc/os-release' ]]; then
 339     source '/etc/os-release'
 340     set_VENDOR $ID $ID $VERSION_ID
 341   elif [[ -x '/usr/bin/lsb_release' ]]; then
 342     local _ID=`/usr/bin/lsb_release -s -i`
 343     local _VERSION=`/usr/bin/lsb_release -s -r`
 344     set_VENDOR $_ID $_ID $_VERSION_ID
 345   elif [[ -f '/etc/lsb-release' ]]; then
 346     source '/etc/lsb-release'
 347     set_VENDOR 'canonical' $DISTRIB_ID $DISTRIB_CODENAME
 348   fi
 349
 350   rebuild_host_os
 351 }
 352
 353 function run_configure ()
 354 {
 355   # We will run autoreconf if we are required
 356   run_autoreconf_if_required
 357
 358   # We always begin at the root of our build
 359   if [ ! popd ]; then
 360     die "Programmer error, we entered run_configure with a stacked directory"
 361   fi
 362
 363   if ! command_exists "$CONFIGURE"; then
 364     die "$CONFIGURE does not exist"
 365   fi
 366
 367   local BUILD_DIR="$1"
 368   if [[ -n "$BUILD_DIR" ]]; then
 369     rm -r -f $BUILD_DIR
 370     mkdir -p $BUILD_DIR
 371     safe_pushd $BUILD_DIR
 372   fi
 373
 374   # Arguments for configure
 375   local BUILD_CONFIGURE_ARG=
 376
 377   # 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
 378   # Set ENV ASSERT in order to enable assert
 379   if $DEBUG; then
 380     BUILD_CONFIGURE_ARG+=' --enable-debug --enable-assert'
 381   elif [[ -n "$VCS_CHECKOUT" ]]; then
 382     BUILD_CONFIGURE_ARG+=' --enable-assert'
 383   fi
 384
 385   if [[ -n "$CONFIGURE_ARG" ]]; then
 386     BUILD_CONFIGURE_ARG+=" $CONFIGURE_ARG"
 387   fi
 388
 389   if [[ -n "$PREFIX_ARG" ]]; then
 390     BUILD_CONFIGURE_ARG+=" $PREFIX_ARG"
 391   fi
 392
 393   ret=1;
 394   # If we are executing on OSX use CLANG, otherwise only use it if we find it in the ENV
 395   case $HOST_OS in
 396     *-darwin-*)
 397       CC=clang CXX=clang++ $top_srcdir/configure $BUILD_CONFIGURE_ARG || die "Cannot execute CC=clang CXX=clang++ configure $BUILD_CONFIGURE_ARG"
 398       ret=$?
 399       ;;
 400     rhel-5*)
 401       command_exists 'gcc44' || die "Could not locate gcc44"
 402       CC=gcc44 CXX=gcc44 $top_srcdir/configure $BUILD_CONFIGURE_ARG || die "Cannot execute CC=gcc44 CXX=gcc44 configure $BUILD_CONFIGURE_ARG"
 403       ret=$?
 404       ;;
 405     *)
 406       $CONFIGURE $BUILD_CONFIGURE_ARG
 407       ret=$?
 408       ;;
 409   esac
 410
 411   if [ $ret -ne 0 ]; then
 412     die "Could not execute $CONFIGURE $BUILD_CONFIGURE_ARG"
 413   fi
 414
 415   if [ ! -f 'Makefile' ]; then
 416     die "Programmer error, configure was run but no Makefile existed after $CONFIGURE was run"
 417   fi
 418 }
 419
 420 function setup_gdb_command () {
 421   GDB_TMPFILE=$(mktemp /tmp/gdb.XXXXXXXXXX)
 422   echo 'set logging overwrite on' > $GDB_TMPFILE
 423   echo 'set logging on' >> $GDB_TMPFILE
 424   echo 'set environment LIBTEST_IN_GDB=1' >> $GDB_TMPFILE
 425   echo 'run' >> $GDB_TMPFILE
 426   echo 'thread apply all bt' >> $GDB_TMPFILE
 427   echo 'quit' >> $GDB_TMPFILE
 428   GDB_COMMAND="gdb -f -batch -x $GDB_TMPFILE"
 429 }
 430
 431 function setup_valgrind_command () {
 432   VALGRIND_PROGRAM=`type -p valgrind`
 433   if [[ -n "$VALGRIND_PROGRAM" ]]; then
 434     VALGRIND_COMMAND="$VALGRIND_PROGRAM --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE"
 435   fi
 436 }
 437
 438 function save_BUILD ()
 439 {
 440   if [[ -n "$OLD_CONFIGURE" ]]; then
 441     die "OLD_CONFIGURE($OLD_CONFIGURE) was set on push, programmer error!"
 442   fi
 443
 444   if [[ -n "$OLD_CONFIGURE_ARG" ]]; then
 445     die "OLD_CONFIGURE_ARG($OLD_CONFIGURE_ARG) was set on push, programmer error!"
 446   fi
 447
 448   if [[ -n "$OLD_PREFIX" ]]; then
 449     die "OLD_PREFIX($OLD_PREFIX) was set on push, programmer error!"
 450   fi
 451
 452   if [[ -n "$OLD_MAKE" ]]; then
 453     die "OLD_MAKE($OLD_MAKE) was set on push, programmer error!"
 454   fi
 455
 456   if [[ -n "$OLD_TESTS_ENVIRONMENT" ]]; then
 457     die "OLD_TESTS_ENVIRONMENT($OLD_TESTS_ENVIRONMENT) was set on push, programmer error!"
 458   fi
 459
 460   if [[ -n "$CONFIGURE" ]]; then
 461     OLD_CONFIGURE=$CONFIGURE
 462   fi
 463
 464   if [[ -n "$CONFIGURE_ARG" ]]; then
 465     OLD_CONFIGURE_ARG=$CONFIGURE_ARG
 466   fi
 467
 468   if [[ -n "$MAKE" ]]; then
 469     OLD_MAKE=$MAKE
 470   fi
 471
 472   if [[ -n "$TESTS_ENVIRONMENT" ]]; then
 473     OLD_TESTS_ENVIRONMENT=$TESTS_ENVIRONMENT
 474   fi
 475 }
 476
 477 function restore_BUILD ()
 478 {
 479   if [[ -n "$OLD_CONFIGURE" ]]; then
 480     CONFIGURE=$OLD_CONFIGURE
 481   fi
 482
 483   if [[ -n "$OLD_CONFIGURE_ARG" ]]; then
 484     CONFIGURE_ARG=$OLD_CONFIGURE_ARG
 485   fi
 486
 487   if [[ -n "$OLD_PREFIX" ]]; then
 488     PREFIX_ARG=$OLD_PREFIX
 489   fi
 490
 491   if [[ -n "$OLD_MAKE" ]]; then
 492     MAKE=$OLD_MAKE
 493   fi
 494
 495   if [[ -n "$OLD_TESTS_ENVIRONMENT" ]]; then
 496     TESTS_ENVIRONMENT=$OLD_TESTS_ENVIRONMENT
 497   fi
 498
 499   OLD_CONFIGURE=
 500   OLD_CONFIGURE_ARG=
 501   OLD_PREFIX=
 502   OLD_MAKE=
 503   OLD_TESTS_ENVIRONMENT=
 504
 505   export -n CC CXX
 506 }
 507
 508 function safe_pushd ()
 509 {
 510   pushd $1 &> /dev/null ;
 511
 512   if [ -n "$BUILD_DIR" ]; then
 513     if $VERBOSE; then
 514       echo "BUILD_DIR=$BUILD_DIR"
 515     fi
 516   fi
 517 }
 518
 519 function safe_popd ()
 520 {
 521   local directory_to_delete=`pwd`
 522   popd &> /dev/null ;
 523   if [ $? -eq 0 ]; then
 524     if [[ "$top_srcdir" == "$directory_to_delete" ]]; then
 525       die "We almost deleted top_srcdir($top_srcdir), programmer error"
 526     fi
 527
 528     rm -r -f "$directory_to_delete"
 529   fi
 530 }
 531
 532 function make_valgrind ()
 533 {
 534   if [[ "$VENDOR_DISTRIBUTION" == 'darwin' ]]; then
 535     make_darwin_malloc
 536     return
 537   fi
 538
 539   # If the env VALGRIND_COMMAND is set then we assume it is valid
 540   local valgrind_was_set=false
 541   if [[ -z "$VALGRIND_COMMAND" ]]; then
 542     setup_valgrind_command
 543     if [[ -n "$VALGRIND_COMMAND" ]]; then
 544       valgrind_was_set=true
 545     fi
 546   else
 547     valgrind_was_set=true
 548   fi
 549
 550   # If valgrind_was_set is set to no we bail
 551   if ! $valgrind_was_set; then
 552     echo 'valgrind was not present'
 553     return 1
 554   fi
 555
 556   save_BUILD
 557
 558   # If we are required to run configure, do so now
 559   run_configure_if_required
 560
 561   # If we don't have a configure, then most likely we will be missing libtool
 562   assert_file 'configure'
 563   if [[ -f 'libtool' ]]; then
 564     TESTS_ENVIRONMENT="./libtool --mode=execute $VALGRIND_COMMAND"
 565   else
 566     TESTS_ENVIRONMENT="$VALGRIND_COMMAND"
 567   fi
 568
 569   make_target 'check' || return 1
 570
 571   restore_BUILD
 572 }
 573
 574 function make_install_system ()
 575 {
 576   local INSTALL_LOCATION=$(mktemp -d /tmp/XXXXXXXXXX)
 577
 578   save_BUILD
 579   PREFIX_ARG="--prefix=$INSTALL_LOCATION"
 580
 581   if [ ! -d $INSTALL_LOCATION ] ; then
 582     die "ASSERT temp directory not found '$INSTALL_LOCATION'"
 583   fi
 584
 585   run_configure #install_buid_dir
 586
 587   make_target 'install'
 588
 589   make_target 'installcheck'
 590
 591   make_target 'uninstall'
 592
 593   rm -r -f $INSTALL_LOCATION
 594   make 'distclean'
 595
 596   if [ -f 'Makefile' ]; then
 597     die "ASSERT Makefile should not exist"
 598   fi
 599
 600   restore_BUILD
 601   safe_popd
 602 }
 603
 604 function make_darwin_malloc ()
 605 {
 606   run_configure_if_required
 607
 608   old_MallocGuardEdges=$MallocGuardEdges
 609   MallocGuardEdges=1
 610   old_MallocErrorAbort=$MallocErrorAbort
 611   MallocErrorAbort=1
 612   old_MallocScribble=$MallocScribble
 613   MallocScribble=1
 614
 615   make_check
 616
 617   MallocGuardEdges=$old_MallocGuardEdges
 618   MallocErrorAbort=$old_MallocErrorAbort
 619   MallocScribble=$old_MallocScribble
 620 }
 621
 622 function snapshot_check ()
 623 {
 624   if [ ! -f "$BOOTSTRAP_SNAPSHOT_CHECK" ]; then
 625     make_for_snapshot
 626   fi
 627
 628   if [ -n "$BOOTSTRAP_SNAPSHOT_CHECK" ]; then
 629     assert_file "$BOOTSTRAP_SNAPSHOT_CHECK" 'snapshot check failed'
 630   fi
 631 }
 632
 633 # This will reset our environment, and make sure built files are available.
 634 function make_for_snapshot ()
 635 {
 636   # Make sure it is clean
 637   make_maintainer_clean
 638
 639   run_configure
 640   make_target 'dist'
 641   make_target 'distclean'
 642
 643   # We should have a configure, but no Makefile at the end of this exercise
 644   assert_no_file 'Makefile'
 645   assert_exec_file 'configure'
 646
 647   snapshot_check
 648 }
 649
 650 function check_mingw ()
 651 {
 652   command_exists 'mingw64-configure'
 653   ret=$?
 654   if [ "$ret" -ne 0 ]; then
 655     return 1
 656   fi
 657
 658   command_exists 'mingw64-make'
 659   ret=$?
 660   if [ "$ret" -ne 0 ]; then
 661     return 1
 662   fi
 663
 664   return 0
 665 }
 666
 667 function check_clang ()
 668 {
 669   command_exists 'clang'
 670   ret=$?
 671   if [ "$ret" -ne 0 ]; then
 672     return 1
 673   fi
 674
 675   return 0
 676 }
 677
 678 function check_clang_analyzer ()
 679 {
 680   command_exists 'scan-build'
 681   ret=$?
 682   if [ "$ret" -ne 0 ]; then
 683     return 1
 684   fi
 685
 686   return 0
 687 }
 688
 689 function make_skeleton ()
 690 {
 691   run_configure
 692   ret=$?
 693
 694   if [ $ret -eq 0 ]; then
 695     assert_file 'Makefile'
 696
 697     make_target 'all' 'warn'
 698     ret=$?
 699     if [ $ret -ne 0 ]; then
 700       warn "$MAKE failed"
 701     else
 702       if [[ -n "$DISPLAY" ]]; then
 703         if command_exists 'wine'; then
 704           TESTS_ENVIRONMENT='wine'
 705         fi
 706       fi
 707
 708       if [[ -n "$TESTS_ENVIRONMENT" ]]; then
 709         make_target 'check' 'warn' || warn "$MAKE check failed"
 710         ret=$?
 711       fi
 712     fi
 713
 714     if $jenkins_build_environment; then
 715       make_target 'clean' 'warn'
 716     fi
 717   fi
 718
 719   return $ret
 720 }
 721
 722 function make_for_mingw ()
 723 {
 724   if ! check_mingw; then
 725     return 1
 726   fi
 727
 728   # Make sure it is clean
 729   if [ -f Makefile -o -f configure ]; then
 730     make_maintainer_clean
 731   fi
 732
 733   run_autoreconf
 734
 735   save_BUILD
 736
 737   CONFIGURE='mingw64-configure'
 738   MAKE='mingw64-make'
 739   CONFIGURE_ARGS='--enable-static --disable-shared'
 740
 741   make_skeleton
 742   ret=$?
 743
 744   restore_BUILD
 745
 746   return $ret
 747 }
 748
 749 function make_for_clang ()
 750 {
 751   if ! check_clang; then
 752     return 1
 753   fi
 754
 755   # Make sure it is clean
 756   if [ -f Makefile -o -f configure ]; then
 757     make_maintainer_clean
 758   fi
 759
 760   run_autoreconf
 761
 762   save_BUILD
 763
 764   CC=clang CXX=clang++
 765   export CC CXX
 766
 767   make_skeleton
 768   ret=$?
 769
 770   make_target 'check'
 771
 772   restore_BUILD
 773
 774   return $ret
 775 }
 776
 777 function make_for_clang_analyzer ()
 778 {
 779   if ! check_clang; then
 780     return 1
 781   fi
 782
 783   if ! check_clang_analyzer; then
 784     die 'clang-analyzer was not found'
 785   fi
 786
 787   # Make sure it is clean
 788   if [ -f Makefile -o -f configure ]; then
 789     make_maintainer_clean
 790   fi
 791
 792   run_autoreconf
 793
 794   save_BUILD
 795
 796   CC=clang CXX=clang++
 797   export CC CXX
 798   CONFIGURE_ARGS='--enable-debug'
 799
 800   make_skeleton
 801   ret=$?
 802
 803   make_target 'clean' 'warn'
 804
 805   scan-build -o clang-html make -j4 -k
 806
 807   restore_BUILD
 808
 809   return $ret
 810 }
 811
 812 # If we are locally testing, we should make sure the environment is setup correctly
 813 function check_for_jenkins ()
 814 {
 815   if ! $jenkins_build_environment; then
 816     echo "Not inside of jenkins"
 817
 818     if [ -f 'configure' ]; then
 819       make_maintainer_clean
 820     fi
 821
 822     if $BOOTSTRAP_SNAPSHOT; then
 823       make_for_snapshot
 824     fi
 825   fi
 826 }
 827
 828 function make_universe ()
 829 {
 830   make_for_snapshot
 831   make_valgrind
 832   make_gdb
 833   make_rpm
 834   make_for_clang
 835   make_for_clang_analyzer
 836
 837   if [ check_mingw -eq 0 ]; then
 838     make_for_mingw
 839   fi
 840
 841   make_distcheck
 842   make_install_system
 843 }
 844
 845 function make_for_continuus_integration ()
 846 {
 847   # Setup the environment if we are local
 848   check_for_jenkins
 849
 850   # No matter then evironment, we should not have a Makefile at this point
 851   assert_no_file 'Makefile'
 852
 853   # Platforms which require bootstrap should have some setup done before we hit this stage.
 854   # If we are building locally, skip this step, unless we are just testing locally.
 855   if $BOOTSTRAP_SNAPSHOT; then
 856     snapshot_check
 857   else
 858     # If we didn't require a snapshot, then we should not have a configure
 859     assert_no_file 'configure'
 860
 861     run_autoreconf
 862   fi
 863
 864   assert_no_file 'Makefile' 'Programmer error, Makefile existed where build state should have been clean'
 865
 866   case $HOST_OS in
 867     *-fedora-*)
 868       run_configure
 869
 870       assert_exec_file 'configure'
 871       assert_file 'Makefile'
 872
 873       make_target 'all'
 874
 875       # make rpm includes "make distcheck"
 876       if [[ -f rpm.am ]]; then
 877         make_rpm
 878       elif [[ -d rpm ]]; then
 879         make_rpm
 880       else
 881         make_distcheck
 882       fi
 883
 884       assert_exec_file 'configure'
 885       assert_file 'Makefile'
 886
 887       make_install_system
 888       ;;
 889     *-precise-*)
 890       run_configure
 891
 892       assert_exec_file 'configure'
 893       assert_file 'Makefile'
 894
 895       make_target 'all'
 896
 897       make_distcheck
 898
 899       assert_exec_file 'configure'
 900       assert_file 'Makefile'
 901
 902       make_valgrind
 903
 904       assert_exec_file 'configure'
 905       assert_file 'Makefile'
 906
 907       make_install_system
 908       ;;
 909     *)
 910       make_jenkins_default
 911       ;;
 912   esac
 913
 914   make_maintainer_clean
 915
 916   safe_popd
 917 }
 918
 919 # The point to this test is to test bootstrap.sh itself
 920 function self_test ()
 921 {
 922   # We start off with a clean env
 923   make_maintainer_clean
 924
 925   eval "./bootstrap.sh jenkins" || die "failed 'jenkins'"
 926   eval "./bootstrap.sh all" || die "failed 'all'"
 927   eval "./bootstrap.sh gdb" || die "failed 'gdb'"
 928   eval "./bootstrap.sh maintainer-clean" || die "failed 'maintainer-clean'"
 929 }
 930
 931 function make_install_html ()
 932 {
 933   run_configure_if_required
 934   assert_file 'configure'
 935
 936   make_target 'install-html'
 937 }
 938
 939 function make_gdb ()
 940 {
 941   save_BUILD
 942
 943   if command_exists 'gdb'; then
 944     run_configure_if_required
 945
 946     # Set ENV GDB_COMMAND
 947     if [[ -z "$GDB_COMMAND" ]]; then
 948       setup_gdb_command
 949     fi
 950
 951     # If we don't have a configure, then most likely we will be missing libtool
 952     assert_file 'configure'
 953     if [[ -f 'libtool' ]]; then
 954       TESTS_ENVIRONMENT="./libtool --mode=execute $GDB_COMMAND"
 955     else
 956       TESTS_ENVIRONMENT="$GDB_COMMAND"
 957     fi
 958
 959     make_target 'check'
 960
 961     if [ -f 'gdb.txt' ]; then
 962       rm 'gdb.txt'
 963     fi
 964
 965     if [ -f '.gdb_history' ]; then
 966       rm '.gdb_history'
 967     fi
 968
 969     if $jenkins_build_environment; then
 970       make_target 'clean'
 971     fi
 972   else
 973     echo 'gdb was not present'
 974     return 1
 975   fi
 976
 977   restore_BUILD
 978 }
 979
 980 # $1 target to compile
 981 # $2 to die, or not to die, based on contents
 982 function make_target ()
 983 {
 984   if [ -z "$1" ]; then
 985     die "Programmer error, no target provided for make"
 986   fi
 987
 988   if [ ! -f 'Makefile' ]; then
 989     die "Programmer error, make was called before configure"
 990     run_configure
 991   fi
 992
 993   if [ -n "$TESTS_ENVIRONMENT" ]; then
 994     if $VERBOSE; then
 995       echo "TESTS_ENVIRONMENT=$TESTS_ENVIRONMENT"
 996     fi
 997   fi
 998
 999   if [ -z "$MAKE" ]; then
1000     die "MAKE was not set"
1001   fi
1002
1003   # $2 represents error or warn
1004   run $MAKE $1
1005   ret=$?
1006
1007   if [ $ret -ne 0 ]; then
1008     if [ -n "$2" ]; then
1009       warn "Failed to execute $MAKE $1: $ret"
1010     else
1011       die "Failed to execute $MAKE $1: $ret"
1012     fi
1013   fi
1014
1015   return $ret
1016 }
1017
1018 function make_distcheck ()
1019 {
1020   make_target 'distcheck'
1021 }
1022
1023 function make_rpm ()
1024 {
1025   if command_exists 'rpmbuild'; then
1026     if [ -f 'rpm.am' -o -d 'rpm' ]; then
1027       run_configure_if_required
1028       make_target 'rpm'
1029
1030       if $jenkins_build_environment; then
1031         make_target 'clean'
1032       fi
1033
1034     fi
1035   fi
1036 }
1037
1038 function make_maintainer_clean ()
1039 {
1040   run_configure_if_required
1041   make_target 'maintainer-clean' 'no_error'
1042
1043   # Lets make sure we really cleaned up the environment
1044   assert_no_file 'Makefile'
1045   assert_no_file 'configure'
1046   assert_no_directory 'autom4te.cache'
1047 }
1048
1049 function make_check ()
1050 {
1051   make_target 'check'
1052 }
1053
1054 function make_jenkins_default ()
1055 {
1056   run_configure
1057   make_target 'all'
1058 }
1059
1060 function make_default ()
1061 {
1062   run_configure_if_required
1063   make_target 'all'
1064 }
1065
1066 function run_configure_if_required ()
1067 {
1068   run_autoreconf_if_required
1069
1070   if [ ! -f 'Makefile' ]; then
1071     run_configure
1072   fi
1073
1074   assert_file 'Makefile' 'configure did not produce a Makefile'
1075 }
1076
1077 function run_make_maintainer_clean_if_possible ()
1078 {
1079   if [ -f 'Makefile' ]; then
1080     make_maintainer_clean
1081   fi
1082 }
1083
1084 function run_autoreconf_if_required ()
1085 {
1086   if [ ! -x 'configure' ]; then
1087     run_autoreconf
1088   fi
1089
1090   assert_exec_file 'configure'
1091   bash -n configure
1092 }
1093
1094 function run_autoreconf ()
1095 {
1096   if [[ -z "$AUTORECONF" ]]; then
1097     die "Programmer error, tried to call run_autoreconf () but AUTORECONF was not set"
1098   fi
1099
1100   if test $use_libtool = 1; then
1101     assert $BOOTSTRAP_LIBTOOLIZE
1102     run $BOOTSTRAP_LIBTOOLIZE '--copy' '--install' '--force' || die "Cannot execute $BOOTSTRAP_LIBTOOLIZE"
1103   fi
1104
1105   run $AUTORECONF || die "Cannot execute $AUTORECONF"
1106
1107   eval 'bash -n configure' || die "autoreconf generated a malformed configure"
1108 }
1109
1110 function run ()
1111 {
1112   if $VERBOSE; then
1113     echo "\`$@' $ARGS"
1114   fi
1115
1116   if [ -z "$1" ]; then
1117     return 127;
1118   fi
1119
1120   eval $@ $ARGS
1121 }
1122
1123 function parse_command_line_options ()
1124 {
1125   local SHORTOPTS=':apcmt:dvh'
1126
1127   nassert MAKE_TARGET
1128
1129   while getopts "$SHORTOPTS" opt; do
1130     case $opt in
1131       a) #--autoreconf
1132         AUTORECONF_OPTION=true
1133         MAKE_TARGET='autoreconf'
1134         ;;
1135       p) #--print-env
1136         PRINT_SETUP_OPTION=true
1137         ;;
1138       c) # --configure
1139         CONFIGURE_OPTION=true
1140         MAKE_TARGET='configure'
1141         ;;
1142       m) # maintainer-clean
1143         CLEAN_OPTION=true
1144         MAKE_TARGET='clean_op'
1145         ;;
1146       t) # target
1147         TARGET_OPTION=true
1148         TARGET_OPTION_ARG="$OPTARG"
1149         MAKE_TARGET="$OPTARG"
1150         ;;
1151       d) # debug
1152         DEBUG_OPTION=true
1153         enable_debug
1154         ;;
1155       h) # help
1156         echo "bootstrap.sh [options] optional_target ..."
1157         echo "  -a # Just run autoreconf";
1158         echo "  -p # Print ENV";
1159         echo "  -c # Just run configure";
1160         echo "  -m # Just run maintainer-clean";
1161         echo "  -t # Make target";
1162         echo "  -d # Enable debug";
1163         echo "  -h # Show help";
1164         echo "  -v # Be more verbose in output";
1165         exit
1166         ;;
1167       v) # verbose
1168         VERBOSE_OPTION=true
1169         VERBOSE=true
1170         ;;
1171       :)
1172         echo "Option -$OPTARG requires an argument." >&2
1173         exit 1
1174         ;;
1175       *)
1176         echo "$0: error - unrecognized option $1" 1>&2
1177         exit 1
1178         ;;
1179     esac
1180   done
1181
1182   shift $((OPTIND-1))
1183
1184   if [ -n "$1" ]; then
1185     MAKE_TARGET="$@"
1186   fi
1187 }
1188
1189 function determine_vcs ()
1190 {
1191   if [[ -d '.git' ]]; then
1192     VCS_CHECKOUT=git
1193   elif [[ -d '.bzr' ]]; then
1194     VCS_CHECKOUT=bzr
1195   elif [[ -d '.svn' ]]; then
1196     VCS_CHECKOUT=svn
1197   elif [[ -d '.hg' ]]; then
1198     VCS_CHECKOUT=hg
1199   else
1200     VCS_CHECKOUT=
1201   fi
1202
1203   if [[ -n "$VCS_CHECKOUT" ]]; then
1204     VERBOSE=true
1205   fi
1206 }
1207
1208 function require_libtoolise ()
1209 {
1210   use_libtool=0
1211   grep '^[         ]*A[CM]_PROG_LIBTOOL' configure.ac >/dev/null \
1212     && use_libtool=1
1213   grep '^[         ]*LT_INIT' configure.ac >/dev/null \
1214     && use_libtool=1
1215 }
1216
1217 function autoreconf_setup ()
1218 {
1219   # Set ENV MAKE in order to override "make"
1220   if [[ -z "$MAKE" ]]; then
1221     if command_exists 'gmake'; then
1222       MAKE=`type -p gmake`
1223     else
1224       if command_exists 'make'; then
1225         MAKE=`type -p make`
1226       fi
1227     fi
1228
1229     if [ "$VCS_CHECKOUT" ]; then
1230       if $DEBUG; then
1231         MAKE="$MAKE --warn-undefined-variables"
1232       fi
1233     fi
1234
1235     if $DEBUG; then
1236       MAKE="$MAKE -d"
1237     fi
1238   fi
1239
1240   if [[ -z "$GNU_BUILD_FLAGS" ]]; then
1241     GNU_BUILD_FLAGS="--install --force"
1242   fi
1243
1244   if $VERBOSE; then
1245     GNU_BUILD_FLAGS="$GNU_BUILD_FLAGS --verbose"
1246   fi
1247
1248   if [ -z "$ACLOCAL_PATH" ]; then
1249     ACLOCAL_PATH="/usr/local/share/aclocal $ACLOCAL_PATH"
1250   fi
1251
1252   if [[ -z "$WARNINGS" ]]; then
1253     if [[ -n "$VCS_CHECKOUT" ]]; then
1254       WARNINGS="all,error"
1255     else
1256       WARNINGS="all"
1257     fi
1258   fi
1259
1260   if test $use_libtool = 1; then
1261     if [[ -n "$LIBTOOLIZE" ]]; then
1262       BOOTSTRAP_LIBTOOLIZE=`type -p $LIBTOOLIZE`
1263
1264       if [[ -z "$BOOTSTRAP_LIBTOOLIZE" ]]; then
1265         echo "Couldn't find user supplied libtoolize, it is required"
1266         return 1
1267       fi
1268     else
1269       # If we are using OSX, we first check to see glibtoolize is available
1270       if [[ "$VENDOR_DISTRIBUTION" == "darwin" ]]; then
1271         BOOTSTRAP_LIBTOOLIZE=`type -p glibtoolize`
1272
1273         if [[ -z "$BOOTSTRAP_LIBTOOLIZE" ]]; then
1274           echo "Couldn't find glibtoolize, it is required on OSX"
1275           return 1
1276         fi
1277       else
1278         BOOTSTRAP_LIBTOOLIZE=`type -p libtoolize`
1279
1280         if [[ -z "$BOOTSTRAP_LIBTOOLIZE" ]]; then
1281           echo "Couldn't find libtoolize, it is required"
1282           return 1
1283         fi
1284       fi
1285     fi
1286     if $VERBOSE; then
1287       LIBTOOLIZE_OPTIONS="--verbose $BOOTSTRAP_LIBTOOLIZE_OPTIONS"
1288     fi
1289     if $DEBUG; then
1290       LIBTOOLIZE_OPTIONS="--debug $BOOTSTRAP_LIBTOOLIZE_OPTIONS"
1291     fi
1292     LIBTOOLIZE=true
1293   fi
1294
1295   # Test the ENV AUTOMAKE if it exists
1296   if [[ -n "$AUTOMAKE" ]]; then
1297     run $AUTOMAKE '--help'    &> /dev/null    || die "Failed to run AUTOMAKE:$AUTOMAKE"
1298   fi
1299
1300   # Test the ENV AUTOCONF if it exists
1301   if [[ -n "$AUTOCONF" ]]; then
1302     run $AUTOCONF '--help'    &> /dev/null    || die "Failed to run AUTOCONF:$AUTOCONF"
1303   fi
1304
1305   # Test the ENV AUTOHEADER if it exists
1306   if [[ -n "$AUTOHEADER" ]]; then
1307     run $AUTOHEADER '--help'  &> /dev/null    || die "Failed to run AUTOHEADER:$AUTOHEADER"
1308   fi
1309
1310   # Test the ENV AUTOM4TE if it exists
1311   if [[ -n "$AUTOM4TE" ]]; then
1312     run $AUTOM4TE '--help'    &> /dev/null    || die "Failed to run AUTOM4TE:$AUTOM4TE"
1313   fi
1314
1315   # Test the ENV AUTOHEADER if it exists, if not we add one and add --install
1316   if [[ -z "$ACLOCAL" ]]; then
1317     ACLOCAL="aclocal --install"
1318   fi
1319   run $ACLOCAL '--help'  &> /dev/null    || die "Failed to run ACLOCAL:$ACLOCAL"
1320
1321   if [[ -z "$AUTORECONF" ]]; then
1322     AUTORECONF=`type -p autoreconf`
1323
1324     if [[ -z "$AUTORECONF" ]]; then
1325       die "Couldn't find autoreconf"
1326     fi
1327
1328     if [[ -n "$GNU_BUILD_FLAGS" ]]; then
1329       AUTORECONF="$AUTORECONF $GNU_BUILD_FLAGS"
1330     fi
1331   fi
1332
1333   run $AUTORECONF '--help'  &> /dev/null    || die "Failed to run AUTORECONF:$AUTORECONF"
1334 }
1335
1336 function print_setup ()
1337 {
1338   saved_debug_status=$DEBUG
1339   if $DEBUG; then
1340     disable_debug
1341   fi
1342
1343   echo '----------------------------------------------'
1344   echo 'BOOTSTRAP ENV'
1345   echo "AUTORECONF=$AUTORECONF"
1346   echo "HOST_OS=$HOST_OS"
1347   echo "VENDOR=$VENDOR"
1348   echo "VENDOR_DISTRIBUTION=$VENDOR_DISTRIBUTION"
1349   echo "VENDOR_RELEASE=$VENDOR_RELEASE"
1350
1351   echo "getopt()"
1352   if $AUTORECONF_OPTION; then
1353     echo "--autoreconf"
1354   fi
1355
1356   if $CLEAN_OPTION; then
1357     echo "--clean"
1358   fi
1359
1360   if $CONFIGURE_OPTION; then
1361     echo "--configure"
1362   fi
1363
1364   if $DEBUG_OPTION; then
1365     echo "--debug"
1366   fi
1367
1368   if $PRINT_SETUP_OPTION; then
1369     echo "--print-env"
1370   fi
1371
1372   if $TARGET_OPTION; then
1373     echo "--target=$TARGET_OPTION_ARG"
1374   fi
1375
1376   if $VERBOSE_OPTION; then
1377     echo "--verbose"
1378   fi
1379
1380   if [[ -n "$MAKE" ]]; then
1381     echo "MAKE=$MAKE"
1382   fi
1383
1384   if [[ -n "$MAKE_TARGET" ]]; then
1385     echo "MAKE_TARGET=$MAKE_TARGET"
1386   fi
1387
1388   if [[ -n "$PREFIX" ]]; then
1389     echo "PREFIX=$PREFIX"
1390   fi
1391
1392   if [[ -n "$TESTS_ENVIRONMENT" ]]; then
1393     echo "TESTS_ENVIRONMENT=$TESTS_ENVIRONMENT"
1394   fi
1395
1396   if [[ -n "$VCS_CHECKOUT" ]]; then
1397     echo "VCS_CHECKOUT=$VCS_CHECKOUT"
1398   fi
1399
1400   if $VERBOSE; then
1401     echo "VERBOSE=true"
1402   fi
1403
1404   if $DEBUG; then
1405     echo "DEBUG=true"
1406   fi
1407
1408   if [[ -n "$WARNINGS" ]]; then
1409     echo "WARNINGS=$WARNINGS"
1410   fi
1411   echo '----------------------------------------------'
1412
1413   if $saved_debug_status; then
1414     enable_debug
1415   fi
1416 }
1417
1418 function make_clean_option ()
1419 {
1420   run_configure_if_required
1421
1422   make_maintainer_clean
1423
1424   if [[ "$VCS_CHECKOUT" == 'git' ]]; then
1425     run "$VCS_CHECKOUT" status --ignored
1426   elif [[ -n "$VCS_CHECKOUT" ]]; then
1427     run "$VCS_CHECKOUT" status
1428   fi
1429 }
1430
1431 function make_for_autoreconf ()
1432 {
1433   if [ -f 'Makefile' ]; then
1434     make_maintainer_clean
1435   fi
1436
1437   run_autoreconf
1438
1439   assert_no_file 'Makefile'
1440 }
1441
1442 function check_make_target()
1443 {
1444   case $1 in
1445     'self')
1446       ;;
1447     'rpm')
1448       ;;
1449     'gdb')
1450       ;;
1451     'clean_op')
1452       ;;
1453     'autoreconf')
1454       ;;
1455     'install-system')
1456       ;;
1457     'configure')
1458       ;;
1459     'distcheck')
1460       ;;
1461     'check')
1462       ;;
1463     'snapshot')
1464       ;;
1465     'mingw')
1466       ;;
1467     'universe')
1468       ;;
1469     'valgrind')
1470       ;;
1471     'jenkins')
1472       ;;
1473     'distclean')
1474       ;;
1475     'maintainer-clean')
1476       ;;
1477     'install')
1478       ;;
1479     'all')
1480       ;;
1481     'make_default')
1482       ;;
1483     'clang')
1484       ;;
1485     'clang-analyzer')
1486       ;;
1487     test-*)
1488       ;;
1489     valgrind-*)
1490       ;;
1491     gdb-*)
1492       ;;
1493     'dist')
1494       ;;
1495     *)
1496       echo "Matched default"
1497       return 1
1498       ;;
1499   esac
1500
1501   return 0
1502 }
1503
1504 function bootstrap ()
1505 {
1506   determine_target_platform
1507
1508   determine_vcs
1509
1510   # Set up whatever we need to do to use autoreconf later
1511   require_libtoolise
1512   if ! autoreconf_setup; then
1513     return 1
1514   fi
1515
1516   if [ -z "$MAKE_TARGET" ]; then
1517     MAKE_TARGET="make_default"
1518   fi
1519
1520   if $PRINT_SETUP_OPTION -o  $DEBUG; then
1521     echo
1522     print_setup
1523     echo
1524
1525     # Exit if all we were looking for were the currently used options
1526     if $PRINT_SETUP_OPTION; then
1527       exit
1528     fi
1529   fi
1530
1531   # Use OLD_TESTS_ENVIRONMENT for tracking the state of the variable
1532   local OLD_TESTS_ENVIRONMENT=
1533
1534   # Set ENV PREFIX in order to set --prefix for ./configure
1535   if [[ -n "$PREFIX" ]]; then
1536     PREFIX_ARG="--prefix=$PREFIX"
1537   fi
1538
1539   # We should always have a target by this point
1540   assert MAKE_TARGET
1541
1542   local MAKE_TARGET_ARRAY=($MAKE_TARGET)
1543
1544   for target in "${MAKE_TARGET_ARRAY[@]}"
1545   do
1546     # If we are running inside of Jenkins, we want to only run some of the possible tests
1547     if $jenkins_build_environment; then
1548       check_make_target $target
1549       ret=$?
1550       if [ $ret -ne 0 ]; then
1551         die "Unknown MAKE_TARGET option: $target"
1552       fi
1553     fi
1554
1555     local snapshot_run=false
1556
1557     case $target in
1558       'self')
1559         self_test
1560         ;;
1561       'gdb')
1562         make_gdb
1563         ;;
1564       'install-html')
1565         make_install_html
1566         ;;
1567       'clean_op')
1568         make_clean_option
1569         ;;
1570       'autoreconf')
1571         make_for_autoreconf
1572         ;;
1573       'install-system')
1574         make_install_system
1575         ;;
1576       'configure')
1577         run_configure
1578         ;;
1579       'make_default')
1580         make_default
1581         ;;
1582       'clang')
1583         if ! check_clang; then
1584           die "clang was not found"
1585         fi
1586
1587         if ! make_for_clang; then
1588           die "Failed to build clang: $?"
1589         fi
1590         ;;
1591       'clang-analyzer')
1592         if ! check_clang_analyzer; then
1593           die "clang-analyzer was not found"
1594         fi
1595         if ! check_clang; then
1596           die "clang was not found"
1597         fi
1598
1599         if ! make_for_clang_analyzer; then
1600           die "Failed to build clang-analyzer: $?"
1601         fi
1602         ;;
1603       'mingw')
1604         if ! check_mingw; then
1605           die "mingw was not found"
1606         fi
1607
1608         if ! make_for_mingw; then
1609           die "Failed to build mingw: $?"
1610         fi
1611         ;;
1612       'snapshot')
1613         make_for_snapshot
1614         snapshot_run=true
1615         ;;
1616       'rpm')
1617         make_rpm
1618         ;;
1619       'valgrind')
1620         make_valgrind
1621         ;;
1622       'universe')
1623         make_universe
1624         ;;
1625       'jenkins')
1626         make_for_continuus_integration
1627         ;;
1628       *)
1629         run_configure_if_required
1630         make_target "$target"
1631         ;;
1632     esac
1633
1634     if $jenkins_build_environment; then
1635       if ! $snapshot_run; then
1636         run_make_maintainer_clean_if_possible
1637       fi
1638     fi
1639
1640   done
1641 }
1642
1643 function main ()
1644 {
1645   # Variables we export
1646   declare -x VCS_CHECKOUT=
1647
1648   # Variables we control globally
1649   local MAKE_TARGET=
1650   local CONFIGURE=
1651
1652   # Options for getopt
1653   local AUTORECONF_OPTION=false
1654   local CLEAN_OPTION=false
1655   local CONFIGURE_OPTION=false
1656   local DEBUG_OPTION=false
1657   local PRINT_SETUP_OPTION=false
1658   local TARGET_OPTION=false
1659   local TARGET_OPTION_ARG=
1660   local VERBOSE_OPTION=false
1661
1662   local OLD_CONFIGURE=
1663   local OLD_CONFIGURE_ARG=
1664   local OLD_PREFIX=
1665   local OLD_MAKE=
1666   local OLD_TESTS_ENVIRONMENT=
1667
1668   # If we call autoreconf on the platform or not
1669   local AUTORECONF_REBUILD_HOST=false
1670   local AUTORECONF_REBUILD=false
1671
1672   local -r top_srcdir=`pwd`
1673
1674   # Default configure
1675   if [ -z "$CONFIGURE" ]; then
1676     CONFIGURE="$top_srcdir/configure"
1677   fi
1678
1679
1680   # Variables for determine_target_platform () and rebuild_host_os ()
1681   #   UNAME_MACHINE_ARCH= uname -m
1682   #   VENDOR= apple, redhat, centos, canonical
1683   #   VENDOR_RELEASE=
1684   #                  RHEL{rhel,Tikanga,Santiago}
1685   #                  Ubuntu{ubuntu,Lucid,Maverick,Natty,Oneiric,Precise,Quantal}
1686   #                  Fedora{fedora,Verne,Beefy}
1687   #                  OSX{osx,lion,snow,mountain}
1688   #   VENDOR_DISTRIBUTION= darwin,fedora,rhel,ubuntu
1689   #   UNAME_KERNEL= Linux, Darwin,...
1690   #   UNAME_KERNEL_RELEASE= Linux, Darwin,...
1691   local UNAME_MACHINE_ARCH=unknown
1692   local VENDOR=unknown
1693   local VENDOR_RELEASE=unknown
1694   local VENDOR_DISTRIBUTION=unknown
1695   local UNAME_KERNEL=unknown
1696   local UNAME_KERNEL_RELEASE=unknown
1697   local HOST_OS=
1698
1699   rebuild_host_os no_output
1700
1701   parse_command_line_options $@
1702
1703   # If we are running under Jenkins we predetermine what tests we will run against
1704   # This MAKE_TARGET can be overridden by parse_command_line_options based MAKE_TARGET changes.
1705   # We don't want Jenkins overriding other variables, so we NULL them.
1706   if [ -z "$MAKE_TARGET" ]; then
1707     if $jenkins_build_environment; then
1708       if [[ -n "$label" ]]; then
1709         check_make_target $label
1710         if [ $? -eq 0 ]; then
1711           MAKE_TARGET="$label"
1712         fi
1713       fi
1714
1715       if [ -z "$MAKE_TARGET" ]; then
1716         MAKE_TARGET='jenkins'
1717       fi
1718     fi
1719   fi
1720
1721   bootstrap
1722
1723   jobs -l
1724   wait
1725
1726   exit 0
1727 }
1728
1729 function set_branch ()
1730 {
1731   if [ -z "$BRANCH" ]; then
1732     if [ -z "$CI_PROJECT_TEAM" ]; then
1733       die "Variable CI_PROJECT_TEAM has not been set"
1734     fi
1735     if [ -z "$PROJECT" ]; then
1736       die "Variable PROJECT has not been set"
1737     fi
1738     if [ -z "$BUILD_TAG" ]; then
1739       die "Variable BUILD_TAG has not been set"
1740     fi
1741
1742     BRANCH="lp:~$CI_PROJECT_TEAM/$PROJECT/$BUILD_TAG"
1743     export BRANCH
1744   fi
1745
1746   if [ -z "$BRANCH" ]; then
1747     die "Missing values required to build BRANCH variable."
1748   fi
1749 }
1750
1751 function merge ()
1752 {
1753   if [ -z "$VCS_CHECKOUT" ]; then
1754     die "Merges require VCS_CHECKOUT."
1755   fi
1756
1757   set_branch
1758
1759   if [[ "$VCS_CHECKOUT" == 'bzr' ]]; then
1760     if test -n "$BRANCH_TO_MERGE"; then
1761       bzr merge $BRANCH_TO_MERGE
1762       bzr commit --message="Merge $BRANCH_TO_MERGE Build: $BUILD_TAG" --unchanged
1763     fi
1764
1765     bzr push "$BRANCH"
1766   elif [[ -n "$VCS_CHECKOUT" ]]; then
1767     die "Merge attempt occured, current VCS setup does not support this"
1768   fi
1769 }
1770
1771 function enable_debug ()
1772 {
1773   if ! $DEBUG; then
1774     local caller_loc=`caller`
1775     if [ -n $1 ]; then
1776       echo "$caller_loc Enabling debug: $1"
1777     else
1778       echo "$caller_loc Enabling debug"
1779     fi
1780     set -x
1781     DEBUG=true
1782   fi
1783 }
1784
1785 function usage ()
1786 {
1787   cat << EOF
1788   Usage: $program_name [OPTION]..
1789
1790   Bootstrap this package from the checked-out sources, and optionally walk through CI run.
1791
1792   Options:
1793
1794 EOF
1795 }
1796
1797 function disable_debug ()
1798 {
1799   set +x
1800   DEBUG=true
1801 }
1802
1803 # Script begins here
1804
1805 program_name=$0
1806
1807 env_debug_enabled=false
1808 if [[ -n "$JENKINS_HOME" ]]; then
1809   declare -r jenkins_build_environment=true
1810 else
1811   declare -r jenkins_build_environment=false
1812 fi
1813
1814 export ACLOCAL
1815 export AUTOCONF
1816 export AUTOHEADER
1817 export AUTOM4TE
1818 export AUTOMAKE
1819 export AUTORECONF
1820 export CONFIGURE_ARG
1821 export DEBUG
1822 export GNU_BUILD_FLAGS
1823 export LIBTOOLIZE
1824 export LIBTOOLIZE_OPTIONS
1825 export MAKE
1826 export PREFIX_ARG
1827 export TESTS_ENVIRONMENT
1828 export VERBOSE
1829 export WARNINGS
1830
1831 case $OSTYPE in
1832   darwin*)
1833     export MallocGuardEdges
1834     export MallocErrorAbort
1835     export MallocScribble
1836     ;;
1837 esac
1838
1839 # We check for DEBUG twice, once before we source the config file, and once afterward
1840 env_debug_enabled=false
1841 if [[ -n "$DEBUG" ]]; then
1842   env_debug_enabled=true
1843   enable_debug
1844   print_setup
1845 fi
1846
1847 # Variables which only can be set by .bootstrap
1848 BOOTSTRAP_SNAPSHOT=false
1849 BOOTSTRAP_SNAPSHOT_CHECK=
1850
1851 if [ -f '.bootstrap' ]; then
1852   source '.bootstrap'
1853 fi
1854
1855 if $env_debug_enabled; then
1856   enable_debug
1857 else
1858   if [[ -n "$DEBUG" ]]; then
1859     enable_debug "Enabling DEBUG from '.bootstrap'"
1860     print_setup
1861   fi
1862 fi
1863
1864 # We do this in order to protect the case where DEBUG
1865 if ! $env_debug_enabled; then
1866   DEBUG=false
1867 fi
1868
1869 main $@