~drizzle-trunk/libdrizzle/jenkins-Libdrizzle-109

function nassert ()

{

  local param_name=\$"$1"

 

  if [ -n "$param_value" ]; then

    echo "$bash_source:$bash_lineno: assert($param_name) had value of "$param_value"" >&2

function assert ()

{

  local param_name=\$"$1"

 

  if [ -z "$param_value" ]; then

    echo "$bash_source:$bash_lineno: assert($param_name)" >&2

{

  HOST_OS="${UNAME_MACHINE_ARCH}-${VENDOR}-${VENDOR_DISTRIBUTION}-${VENDOR_RELEASE}-${UNAME_KERNEL}-${UNAME_KERNEL_RELEASE}"

  if [ -z "$1" ]; then

      echo "HOST_OS=$HOST_OS"

    fi

  fi

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

function set_VENDOR_DISTRIBUTION ()

{

  case "$dist" in

    darwin)

      VENDOR_DISTRIBUTION='darwin'

# Validate a Vendor's release name/number 

function set_VENDOR_RELEASE ()

{

 

    echo "VENDOR_DISTRIBUTION:$VENDOR_DISTRIBUTION"

    echo "VENDOR_RELEASE:$release"

  fi

        VENDOR_RELEASE="precise"

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

        VENDOR_RELEASE="quantal"

      fi

      ;;

    opensuse)

#  Valid values are: apple, redhat, centos, canonical, oracle, suse

function set_VENDOR ()

{

 

  case $vendor in

    apple)

      ;;

  esac

 

 

  # Set which vendor/versions we trust for autoreconf

  case $VENDOR_DISTRIBUTION in

 

function determine_target_platform ()

{

 

  if [[ -x '/usr/bin/sw_vers' ]]; then 

    set_VENDOR 'apple' 'darwin' $_VERSION

  elif [[ $(uname) == 'Darwin' ]]; then

    set_VENDOR 'apple' 'darwin' 'mountain'

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

    set_VENDOR 'redhat' 'fedora' $fedora_version

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

    set_VENDOR 'centos' 'rhel' $centos_version

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

    set_VENDOR 'suse' $suse_distribution $suse_version

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

    set_VENDOR $_vendor 'rhel' $rhel_version

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

    source '/etc/os-release'

    set_VENDOR $ID $ID $VERSION_ID

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

    set_VENDOR $_ID $_ID $_VERSION_ID

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

    source '/etc/lsb-release'

  run_autoreconf_if_required

 

  # We always begin at the root of our build

    die "Programmer error, we entered run_configure with a stacked directory"

  fi

 

  fi

 

  # Arguments for configure

 

  # Set ENV ASSERT in order to enable assert.

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

  if $valgrind_run; then

  else

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

    fi

  fi

 

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

  fi

 

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

  fi

 

  ret=1;

  # If we are executing on OSX use CLANG, otherwise only use it if we find it in the ENV

  case $HOST_OS in

    *-darwin-*)

      ret=$?

      ;;

    rhel-5*)

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

      ret=$?

      ;;

    *)

      ret=$?

      ;;

  esac

  fi

}

 

  GDB_TMPFILE=$(mktemp /tmp/gdb.XXXXXXXXXX)

  GDB_COMMAND="gdb -f -batch -x $GDB_TMPFILE"

}

 

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

    VALGRIND_COMMAND="$VALGRIND_PROGRAM --error-exitcode=1 --leak-check=yes --malloc-fill=A5 --free-fill=DE --xml=yes --xml-file=\"valgrind-%p.xml\""

  fi

 

function safe_pushd ()

{

 

  if [ -n "$BUILD_DIR" ]; then

      echo "BUILD_DIR=$BUILD_DIR"

    fi

  fi

 

function safe_popd ()

{

  popd &> /dev/null ;

  if [ $? -eq 0 ]; then

    if [[ "$top_srcdir" == "$directory_to_delete" ]]; then

 

  # If we don't have a configure, then most likely we will be missing libtool

  assert_file 'configure'

    TESTS_ENVIRONMENT="./libtool --mode=execute $VALGRIND_COMMAND"

  else

    TESTS_ENVIRONMENT="$VALGRIND_COMMAND"

  fi

 

  make_target 'check'

  ret=$?

 

 

function make_install_system ()

{

 

  save_BUILD

  PREFIX_ARG="--prefix=$INSTALL_LOCATION"

  MallocScribble=$old_MallocScribble

}

 

# This will reset our environment, and make sure built files are available.

function make_for_snapshot ()

{

 

  run_configure

  make_target 'distclean'

 

  # We should have a configure, but no Makefile at the end of this exercise

  assert_no_file 'Makefile'

  assert_exec_file 'configure'

}

 

function check_mingw ()

function check_for_jenkins ()

{

  if ! $jenkins_build_environment; then

 

    if [ -f 'configure' ]; then

      make_maintainer_clean

  make_for_clang

  make_for_clang_analyzer

 

    make_for_mingw

  fi

 

  make_install_system

}

 

function make_for_continuus_integration ()

{

  # Setup the environment if we are local

  # Platforms which require bootstrap should have some setup done before we hit this stage.

  # If we are building locally, skip this step, unless we are just testing locally. 

  if $BOOTSTRAP_SNAPSHOT; then

  else

    # If we didn't require a snapshot, then we should not have a configure

    assert_no_file 'configure'

  assert_no_file 'Makefile' 'Programmer error, Makefile existed where build state should have been clean'

 

  case $HOST_OS in

    *)

      make_jenkins_default

      ;;

  # We start off with a clean env

  make_maintainer_clean

 

}

 

function make_install_html ()

  fi

 

  if [ -n "$TESTS_ENVIRONMENT" ]; then

      echo "TESTS_ENVIRONMENT=$TESTS_ENVIRONMENT"

    fi

  fi

  fi

 

  # $2 represents error or warn

  ret=$?

 

  if [ $ret -ne 0 ]; then

    if [ -n "$2" ]; then

      warn "Failed to execute $MAKE $1: $ret"

    else

      die "Failed to execute $MAKE $1: $ret"

    fi

    die "Programmer error, tried to call run_autoreconf () but AUTORECONF was not set"

  fi

 

    assert $BOOTSTRAP_LIBTOOLIZE

  fi

 

 

  eval 'bash -n configure' || die "autoreconf generated a malformed configure"

}

 

function run ()

{

    echo "\`$@' $ARGS"

  fi

 

    return 127;

  fi

 

} 

 

function parse_command_line_options ()

    case $opt in

      a) #--autoreconf

        AUTORECONF_OPTION=true

        ;;

      p) #--print-env

        ;;

      c) # --configure

        CONFIGURE_OPTION=true

        ;;

      m) # maintainer-clean

        CLEAN_OPTION=true

        ;;

      t) # target

        TARGET_OPTION=true

        TARGET_OPTION_ARG="$OPTARG"

        ;;

      d) # debug

        enable_debug

        ;;

      h) # help

        exit

        ;;

      v) # verbose

        ;;

      :)

        echo "Option -$OPTARG requires an argument." >&2

  fi

 

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

  fi

}

 

function require_libtoolise ()

{

  grep '^[         ]*A[CM]_PROG_LIBTOOL' configure.ac >/dev/null \

  grep '^[         ]*LT_INIT' configure.ac >/dev/null \

}

 

function autoreconf_setup ()

  # Set ENV MAKE in order to override "make"

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

    if command_exists 'gmake'; then

    else

      if command_exists 'make'; then

      fi

    fi

    

    if [ "$VCS_CHECKOUT" ]; then

        MAKE="$MAKE --warn-undefined-variables"

      fi

    fi

 

      MAKE="$MAKE -d"

    fi

  fi

    GNU_BUILD_FLAGS="--install --force"

  fi

 

    GNU_BUILD_FLAGS="$GNU_BUILD_FLAGS --verbose"

  fi

 

  if [ -z "$ACLOCAL_PATH" ]; then

  fi

 

  if [[ -z "$WARNINGS" ]]; then

    fi

  fi

 

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

 

      if [[ -z "$BOOTSTRAP_LIBTOOLIZE" ]]; then

        echo "Couldn't find user supplied libtoolize, it is required"

    else

      # If we are using OSX, we first check to see glibtoolize is available

      if [[ "$VENDOR_DISTRIBUTION" == "darwin" ]]; then

 

        if [[ -z "$BOOTSTRAP_LIBTOOLIZE" ]]; then

          echo "Couldn't find glibtoolize, it is required on OSX"

          return 1

        fi

      else

 

        if [[ -z "$BOOTSTRAP_LIBTOOLIZE" ]]; then

          echo "Couldn't find libtoolize, it is required"

      fi

    fi

 

      LIBTOOLIZE_OPTIONS="--verbose $BOOTSTRAP_LIBTOOLIZE_OPTIONS"

    fi

 

      LIBTOOLIZE_OPTIONS="--debug $BOOTSTRAP_LIBTOOLIZE_OPTIONS"

    fi

 

 

  # Test the ENV AUTOMAKE if it exists

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

  fi

 

  # Test the ENV AUTOCONF if it exists

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

  fi

 

  # Test the ENV AUTOHEADER if it exists

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

  fi

 

  # Test the ENV AUTOM4TE if it exists

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

  fi

 

  # Test the ENV AUTOHEADER if it exists, if not we add one and add --install

  if [[ -z "$ACLOCAL" ]]; then

    ACLOCAL="aclocal --install"

  fi

 

  if [[ -z "$AUTORECONF" ]]; then

 

    if [[ -z "$AUTORECONF" ]]; then

      die "Couldn't find autoreconf"

    fi

  fi

 

}

 

function print_setup ()

{

    disable_debug

  fi

 

    echo "--configure"

  fi

 

    echo "--debug"

  fi

 

    echo "--print-env"

  fi

 

    echo "--target=$TARGET_OPTION_ARG"

  fi

 

    echo "--verbose"

  fi

 

    echo "VCS_CHECKOUT=$VCS_CHECKOUT"

  fi

 

  fi

 

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

    echo "WARNINGS=$WARNINGS"

  fi

  echo '----------------------------------------------' 

 

  if $saved_debug_status; then

 

function check_make_target()

{

  case $1 in

    'self')

      ;;

      ;;

    *)

      echo "Matched default"

      ;;

  esac

 

}

 

{

  determine_target_platform

 

  determine_vcs

 

  # Set up whatever we need to do to use autoreconf later

  require_libtoolise

  if ! autoreconf_setup; then

    return 1

    MAKE_TARGET="make_default"

  fi

 

    echo 

    print_setup

    echo 

 

    # Exit if all we were looking for were the currently used options

      exit

    fi

  fi

  # We should always have a target by this point

  assert MAKE_TARGET

 

 

  for target in "${MAKE_TARGET_ARRAY[@]}"

  do

      'snapshot')

        make_for_snapshot

        snapshot_run=true

        ;;

      'rpm')

        make_rpm

    esac

 

    if $jenkins_build_environment; then

      fi

    fi

 

 

function main ()

{

  # Variables we export

  declare -x VCS_CHECKOUT=

 

  # Variables we control globally

  local CONFIGURE=

 

  # Options for getopt

  local AUTORECONF_OPTION=false

  local CLEAN_OPTION=false

  local CONFIGURE_OPTION=false

  local TARGET_OPTION=false

  local TARGET_OPTION_ARG=

 

  local OLD_CONFIGURE=

  local OLD_CONFIGURE_ARG=

  local AUTORECONF_REBUILD_HOST=false

  local AUTORECONF_REBUILD=false

 

 

  # Default configure

  if [ -z "$CONFIGURE" ]; then

 

  rebuild_host_os no_output

 

 

  # If we are running under Jenkins we predetermine what tests we will run against

  # This MAKE_TARGET can be overridden by parse_command_line_options based MAKE_TARGET changes.

        fi

      fi

 

      if [ -z "$MAKE_TARGET" ]; then

      fi

    fi

  fi

 

 

  jobs -l

  wait

 

}

 

function set_branch ()

 

function enable_debug ()

{

      echo "$caller_loc Enabling debug: $1"

    else

      echo "$caller_loc Enabling debug"

    fi

    set -x

  fi

}

 

function disable_debug ()

{

  set +x

}

 

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

    enable_debug "Enabling DEBUG from '.bootstrap'"

    print_setup

  fi