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