+*.log
+*.trs
*.exe
*.gz
*.lo
# WARNINGS
#
+use_banner ()
+{
+ echo "#####################################################################################"
+ echo "#"
+ echo "#"
+ echo "#"
+ echo "# TARGET:$1"
+ echo "#"
+ echo "#"
+ echo "#"
+ echo "#####################################################################################"
+}
+
command_not_found_handle ()
{
warn "$@: command not found"
return 127
}
-function error ()
+error ()
{
echo "$BASH_SOURCE:$BASH_LINENO: $@" >&2
}
-function die ()
+die ()
{
echo "$BASH_SOURCE:$BASH_LINENO: $@" >&2
exit 1;
}
-function warn ()
+warn ()
{
echo "$BASH_SOURCE:$BASH_LINENO: $@"
#echo "$BASH_SOURCE:$BASH_LINENO: $@" >&1
}
-function nassert ()
+nassert ()
{
local param_name=\$"$1"
- local param_value=`eval "expr \"$param_name\" "`
+ local param_value="$(eval "expr \"$param_name\" ")"
if [ -n "$param_value" ]; then
echo "$bash_source:$bash_lineno: assert($param_name) had value of "$param_value"" >&2
fi
}
-function assert ()
+assert ()
{
local param_name=\$"$1"
- local param_value=`eval "expr \"$param_name\" "`
+ local param_value="$(eval "expr \"$param_name\" ")"
if [ -z "$param_value" ]; then
echo "$bash_source:$bash_lineno: assert($param_name)" >&2
fi
}
-function assert_file ()
+assert_file ()
{
if [ ! -f "$1" ]; then
echo "$BASH_SOURCE:$BASH_LINENO: assert($1) does not exist: $2" >&2
fi
}
-function assert_no_file ()
+assert_no_file ()
{
if [ -f "$1" ]; then
echo "$BASH_SOURCE:$BASH_LINENO: assert($1) file exists: $2" >&2
fi
}
-function assert_no_directory ()
+assert_no_directory ()
{
if [ -d "$1" ]; then
echo "$BASH_SOURCE:$BASH_LINENO: assert($1) directory exists: $2" >&2
fi
}
-function assert_exec_file ()
+assert_exec_file ()
{
if [ ! -f "$1" ]; then
echo "$BASH_SOURCE:$BASH_LINENO: assert($1) does not exist: $2" >&2
fi
}
-function command_exists ()
+command_exists ()
{
type "$1" &> /dev/null ;
}
-function rebuild_host_os ()
+rebuild_host_os ()
{
HOST_OS="${UNAME_MACHINE_ARCH}-${VENDOR}-${VENDOR_DISTRIBUTION}-${VENDOR_RELEASE}-${UNAME_KERNEL}-${UNAME_KERNEL_RELEASE}"
if [ -z "$1" ]; then
- if $VERBOSE; then
+ if $verbose; then
echo "HOST_OS=$HOST_OS"
fi
fi
# Validate the distribution name, or toss an erro
# values: darwin,fedora,rhel,ubuntu,debian,opensuse
-function set_VENDOR_DISTRIBUTION ()
+set_VENDOR_DISTRIBUTION ()
{
- local dist=`echo "$1" | tr '[A-Z]' '[a-z]'`
+ local dist="$(echo "$1" | tr '[:upper:]' '[:lower:]')"
case "$dist" in
darwin)
VENDOR_DISTRIBUTION='darwin'
}
# Validate a Vendor's release name/number
-function set_VENDOR_RELEASE ()
+set_VENDOR_RELEASE ()
{
- local release=`echo "$1" | tr '[A-Z]' '[a-z]'`
+ local release="$(echo "$1" | tr '[:upper:]' '[:lower:]')"
- if $DEBUG; then
+ if $verbose; then
echo "VENDOR_DISTRIBUTION:$VENDOR_DISTRIBUTION"
echo "VENDOR_RELEASE:$release"
fi
# Valid values are: apple, redhat, centos, canonical, oracle, suse
-function set_VENDOR ()
+set_VENDOR ()
{
- local vendor=`echo "$1" | tr '[A-Z]' '[a-z]'`
+ local vendor="$(echo "$1" | tr '[:upper:]' '[:lower:]')"
case $vendor in
apple)
;;
esac
- set_VENDOR_DISTRIBUTION $2
- set_VENDOR_RELEASE $3
+ set_VENDOR_DISTRIBUTION "$2"
+ set_VENDOR_RELEASE "$3"
# Set which vendor/versions we trust for autoreconf
case $VENDOR_DISTRIBUTION in
}
-function determine_target_platform ()
+determine_target_platform ()
{
- UNAME_MACHINE_ARCH=`(uname -m) 2>/dev/null` || UNAME_MACHINE_ARCH=unknown
- UNAME_KERNEL=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
- UNAME_KERNEL_RELEASE=`(uname -r) 2>/dev/null` || UNAME_KERNEL_RELEASE=unknown
+ UNAME_MACHINE_ARCH="$(uname -m 2>/dev/null)" || UNAME_MACHINE_ARCH=unknown
+ UNAME_KERNEL="$(uname -s 2>/dev/null)" || UNAME_SYSTEM=unknown
+ UNAME_KERNEL_RELEASE="$(uname -r 2>/dev/null)" || UNAME_KERNEL_RELEASE=unknown
if [[ -x '/usr/bin/sw_vers' ]]; then
- local _VERSION=`/usr/bin/sw_vers -productVersion`
+ local _VERSION="$(/usr/bin/sw_vers -productVersion)"
set_VENDOR 'apple' 'darwin' $_VERSION
elif [[ $(uname) == 'Darwin' ]]; then
set_VENDOR 'apple' 'darwin' 'mountain'
elif [[ -f '/etc/fedora-release' ]]; then
- local fedora_version=`cat /etc/fedora-release | awk ' { print $3 } '`
+ local fedora_version="$(awk ' { print $3 } ' < /etc/fedora-release)"
set_VENDOR 'redhat' 'fedora' $fedora_version
elif [[ -f '/etc/centos-release' ]]; then
- local centos_version=`cat /etc/centos-release | awk ' { print $7 } '`
+ local centos_version="$(awk ' { print $7 } ' < /etc/centos-release)"
set_VENDOR 'centos' 'rhel' $centos_version
elif [[ -f '/etc/SuSE-release' ]]; then
- local suse_distribution=`head -1 /etc/SuSE-release | awk ' { print $1 } '`
- local suse_version=`head -1 /etc/SuSE-release | awk ' { print $2 } '`
+ local suse_distribution="$(head -1 /etc/SuSE-release | awk ' { print $1 } ')"
+ local suse_version="$(head -1 /etc/SuSE-release | awk ' { print $2 } ')"
set_VENDOR 'suse' $suse_distribution $suse_version
elif [[ -f '/etc/redhat-release' ]]; then
- local rhel_version=`cat /etc/redhat-release | awk ' { print $7 } '`
- local _vendor=`rpm -qf /etc/redhat-release`
+ local rhel_version="$(awk ' { print $7 } ' < /etc/redhat-release)"
+ local _vendor="$(rpm -qf /etc/redhat-release)"
set_VENDOR $_vendor 'rhel' $rhel_version
elif [[ -f '/etc/os-release' ]]; then
source '/etc/os-release'
set_VENDOR $ID $ID $VERSION_ID
elif [[ -x '/usr/bin/lsb_release' ]]; then
- local _ID=`/usr/bin/lsb_release -s -i`
- local _VERSION=`/usr/bin/lsb_release -s -r`
+ local _ID="$(/usr/bin/lsb_release -s -i)"
+ local _VERSION="$(/usr/bin/lsb_release -s -r)"
set_VENDOR $_ID $_ID $_VERSION_ID
elif [[ -f '/etc/lsb-release' ]]; then
source '/etc/lsb-release'
rebuild_host_os
}
-function run_configure ()
+run_configure ()
{
# We will run autoreconf if we are required
run_autoreconf_if_required
# We always begin at the root of our build
- if [ ! popd ]; then
+ if [ ! $? ]; then
die "Programmer error, we entered run_configure with a stacked directory"
fi
if [[ -n "$BUILD_DIR" ]]; then
rm -r -f $BUILD_DIR
mkdir -p $BUILD_DIR
- safe_pushd $BUILD_DIR
fi
# Arguments for configure
- local BUILD_CONFIGURE_ARG=
+ local BUILD_CONFIGURE_ARG=''
- # If ENV DEBUG is set we enable both debug and asssert, otherwise we see if this is a VCS checkout and if so enable assert
+ # If debug is set we enable both debug and asssert, otherwise we see if this is a VCS checkout and if so enable assert
# Set ENV ASSERT in order to enable assert.
# If we are doing a valgrind run, we always compile with assert disabled
if $valgrind_run; then
- BUILD_CONFIGURE_ARG+= '--enable-assert=no'
+ BUILD_CONFIGURE_ARG="--enable-assert=no $BUILD_CONFIGURE_ARG"
else
- if $DEBUG; then
- BUILD_CONFIGURE_ARG+=' --enable-debug --enable-assert'
+ if $debug; then
+ BUILD_CONFIGURE_ARG="--enable-debug --enable-assert $BUILD_CONFIGURE_ARG"
elif [[ -n "$VCS_CHECKOUT" ]]; then
- BUILD_CONFIGURE_ARG+=' --enable-assert'
+ BUILD_CONFIGURE_ARG="--enable-assert $BUILD_CONFIGURE_ARG"
fi
fi
if [[ -n "$CONFIGURE_ARG" ]]; then
- BUILD_CONFIGURE_ARG+=" $CONFIGURE_ARG"
+ BUILD_CONFIGURE_ARG="$CONFIGURE_ARG $BUILD_CONFIGURE_ARG"
fi
if [[ -n "$PREFIX_ARG" ]]; then
- BUILD_CONFIGURE_ARG+=" $PREFIX_ARG"
+ BUILD_CONFIGURE_ARG="$PREFIX_ARG $BUILD_CONFIGURE_ARG"
fi
ret=1;
# If we are executing on OSX use CLANG, otherwise only use it if we find it in the ENV
case $HOST_OS in
*-darwin-*)
- CC=clang CXX=clang++ $top_srcdir/configure $BUILD_CONFIGURE_ARG || die "Cannot execute CC=clang CXX=clang++ configure $BUILD_CONFIGURE_ARG"
+ run CC=clang CXX=clang++ $CONFIGURE "$BUILD_CONFIGURE_ARG" || die "Cannot execute CC=clang CXX=clang++ configure $BUILD_CONFIGURE_ARG"
ret=$?
;;
rhel-5*)
command_exists 'gcc44' || die "Could not locate gcc44"
- CC=gcc44 CXX=gcc44 $top_srcdir/configure $BUILD_CONFIGURE_ARG || die "Cannot execute CC=gcc44 CXX=gcc44 configure $BUILD_CONFIGURE_ARG"
+ run CC=gcc44 CXX=gcc44 $top_srcdir/configure "$BUILD_CONFIGURE_ARG" || die "Cannot execute CC=gcc44 CXX=gcc44 configure $BUILD_CONFIGURE_ARG"
ret=$?
;;
*)
- $CONFIGURE $BUILD_CONFIGURE_ARG
+ run $CONFIGURE "$BUILD_CONFIGURE_ARG"
ret=$?
;;
esac
fi
}
-function setup_gdb_command () {
+setup_gdb_command ()
+{
GDB_TMPFILE=$(mktemp /tmp/gdb.XXXXXXXXXX)
- echo 'set logging overwrite on' > $GDB_TMPFILE
- echo 'set logging on' >> $GDB_TMPFILE
- echo 'set environment LIBTEST_IN_GDB=1' >> $GDB_TMPFILE
- echo 'run' >> $GDB_TMPFILE
- echo 'thread apply all bt' >> $GDB_TMPFILE
- echo 'quit' >> $GDB_TMPFILE
+ echo 'set logging overwrite on' > "$GDB_TMPFILE"
+ echo 'set logging on' >> "$GDB_TMPFILE"
+ echo 'set environment LIBTEST_IN_GDB=1' >> "$GDB_TMPFILE"
+ echo 'run' >> "$GDB_TMPFILE"
+ echo 'thread apply all bt' >> "$GDB_TMPFILE"
+ echo 'quit' >> "$GDB_TMPFILE"
GDB_COMMAND="gdb -f -batch -x $GDB_TMPFILE"
}
-function setup_valgrind_command () {
- VALGRIND_PROGRAM=`type -p valgrind`
+setup_valgrind_command ()
+{
+ VALGRIND_PROGRAM="$(type -p valgrind)"
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 save_BUILD ()
+save_BUILD ()
{
if [[ -n "$OLD_CONFIGURE" ]]; then
die "OLD_CONFIGURE($OLD_CONFIGURE) was set on push, programmer error!"
fi
}
-function restore_BUILD ()
+restore_BUILD ()
{
if [[ -n "$OLD_CONFIGURE" ]]; then
CONFIGURE=$OLD_CONFIGURE
export -n CC CXX
}
-function safe_pushd ()
-{
- pushd $1 &> /dev/null ;
-
- if [ -n "$BUILD_DIR" ]; then
- if $VERBOSE; then
- echo "BUILD_DIR=$BUILD_DIR"
- fi
- fi
-}
-
-function safe_popd ()
-{
- local directory_to_delete=`pwd`
- popd &> /dev/null ;
- if [ $? -eq 0 ]; then
- if [[ "$top_srcdir" == "$directory_to_delete" ]]; then
- die "We almost deleted top_srcdir($top_srcdir), programmer error"
- fi
-
- rm -r -f "$directory_to_delete"
- fi
-}
-
-function make_valgrind ()
+make_valgrind ()
{
# If the env VALGRIND_COMMAND is set then we assume it is valid
local valgrind_was_set=false
make_target 'check'
ret=$?
- # If we aren't going to error, we will clean up our environment
- if [ "$ret" -eq 0 ]; then
- make 'distclean'
- fi
-
valgrind_run=false
restore_BUILD
fi
}
-function make_install_system ()
+make_install_system ()
{
- local INSTALL_LOCATION=$(mktemp -d /tmp/XXXXXXXXXX)
+ local INSTALL_LOCATION="$(mktemp -d /tmp/XXXXXXXXXX)"
save_BUILD
PREFIX_ARG="--prefix=$INSTALL_LOCATION"
fi
restore_BUILD
- safe_popd
}
-function make_darwin_malloc ()
+make_darwin_malloc ()
{
run_configure_if_required
}
# This will reset our environment, and make sure built files are available.
-function make_for_snapshot ()
+make_for_snapshot ()
{
# Lets make sure we have a clean environment
assert_no_file 'Makefile'
assert_exec_file 'configure'
}
-function check_mingw ()
+check_mingw ()
{
command_exists 'mingw64-configure'
ret=$?
return 0
}
-function check_clang ()
+check_clang ()
{
command_exists 'clang'
ret=$?
return 0
}
-function check_clang_analyzer ()
+check_clang_analyzer ()
{
command_exists 'scan-build'
ret=$?
return 0
}
-function make_skeleton ()
+make_skeleton ()
{
run_configure
ret=$?
return $ret
}
-function make_for_mingw ()
+make_for_mingw ()
{
if ! check_mingw; then
return 1
return $ret
}
-function make_for_clang ()
+make_for_clang ()
{
if ! check_clang; then
return 1
return $ret
}
-function make_for_clang_analyzer ()
+make_for_clang_analyzer ()
{
if ! check_clang; then
return 1
CC=clang CXX=clang++
export CC CXX
+ CONFIGURE='scan-build ./configure'
CONFIGURE_ARGS='--enable-debug'
- make_skeleton
- ret=$?
-
- make_target 'clean' 'warn'
+ run_configure
scan-build -o clang-html make -j4 -k
restore_BUILD
-
- return $ret
}
# If we are locally testing, we should make sure the environment is setup correctly
-function check_for_jenkins ()
+check_for_jenkins ()
{
if ! $jenkins_build_environment; then
echo "Not inside of jenkins, simulating environment"
fi
}
-function make_universe ()
+make_universe ()
{
+ use_banner 'make maintainer-clean'
+ make_maintainer_clean
+
+ use_banner 'snapshot'
make_for_snapshot
+
+ use_banner 'valgrind'
make_valgrind
+
+ use_banner 'gdb'
make_gdb
+
+ use_banner 'rpm'
make_rpm
+
+ use_banner 'clang'
make_for_clang
+
+ use_banner 'clang analyzer'
make_for_clang_analyzer
- if [ check_mingw -eq 0 ]; then
+ use_banner 'mingw'
+ check_mingw
+ if [ $? -eq 0 ]; then
make_for_mingw
fi
+ use_banner 'make distcheck'
make_distcheck
+
+ use_banner 'make install'
make_install_system
}
-function check_snapshot ()
+check_snapshot ()
{
if [ -n "$BOOTSTRAP_SNAPSHOT_CHECK" ]; then
assert_file "$BOOTSTRAP_SNAPSHOT_CHECK" 'snapshot check failed'
fi
}
-function make_for_continuus_integration ()
+make_for_continuus_integration ()
{
# Setup the environment if we are local
check_for_jenkins
esac
make_maintainer_clean
-
- safe_popd
}
# The point to this test is to test bootstrap.sh itself
-function self_test ()
+self_test ()
{
# We start off with a clean env
make_maintainer_clean
- eval "./bootstrap.sh jenkins" || die "failed 'jenkins'"
- eval "./bootstrap.sh all" || die "failed 'all'"
- eval "./bootstrap.sh gdb" || die "failed 'gdb'"
- eval "./bootstrap.sh maintainer-clean" || die "failed 'maintainer-clean'"
+# eval "./bootstrap.sh jenkins" || die "failed 'jenkins'"
+# eval "./bootstrap.sh all" || die "failed 'all'"
+# eval "./bootstrap.sh gdb" || die "failed 'gdb'"
+# eval "./bootstrap.sh maintainer-clean" || die "failed 'maintainer-clean'"
}
-function make_install_html ()
+make_install_html ()
{
run_configure_if_required
assert_file 'configure'
make_target 'install-html'
}
-function make_gdb ()
+make_gdb ()
{
save_BUILD
# $1 target to compile
# $2 to die, or not to die, based on contents
-function make_target ()
+make_target ()
{
if [ -z "$1" ]; then
die "Programmer error, no target provided for make"
fi
if [ -n "$TESTS_ENVIRONMENT" ]; then
- if $VERBOSE; then
+ if $verbose; then
echo "TESTS_ENVIRONMENT=$TESTS_ENVIRONMENT"
fi
fi
fi
# $2 represents error or warn
- run $MAKE $1
+ run "$MAKE" "$1"
ret=$?
if [ $ret -ne 0 ]; then
if [ -n "$2" ]; then
warn "Failed to execute $MAKE $1: $ret"
+ elif [ $ret -eq 2 ]; then
+ die "Failed to execute $MAKE $1"
else
die "Failed to execute $MAKE $1: $ret"
fi
return $ret
}
-function make_distcheck ()
+make_distcheck ()
{
make_target 'distcheck'
}
-function make_rpm ()
+make_rpm ()
{
if command_exists 'rpmbuild'; then
if [ -f 'rpm.am' -o -d 'rpm' ]; then
+ mkdir -p ~/rpmbuild/{BUILD,RPMS,SOURCES,SPECS,SRPMS}
+ mkdir -p ~/rpmbuild/RPMS/{i386,i486,i586,i686,noarch,athlon}
+
run_configure_if_required
make_target 'rpm'
fi
}
-function make_maintainer_clean ()
+make_maintainer_clean ()
{
run_configure_if_required
make_target 'maintainer-clean' 'no_error'
assert_no_directory 'autom4te.cache'
}
-function make_check ()
+make_distclean ()
+{
+ run_configure_if_required
+ make_target 'distclean' 'no_error'
+
+ # Lets make sure we really cleaned up the environment
+ assert_no_file 'Makefile'
+ assert_file 'configure'
+}
+
+make_check ()
{
make_target 'check'
}
-function make_jenkins_default ()
+make_jenkins_default ()
{
run_configure
make_target 'all'
}
-function make_default ()
+make_default ()
{
run_configure_if_required
make_target 'all'
}
-function run_configure_if_required ()
+run_configure_if_required ()
{
run_autoreconf_if_required
assert_file 'Makefile' 'configure did not produce a Makefile'
}
-function run_make_maintainer_clean_if_possible ()
+run_make_maintainer_clean_if_possible ()
{
if [ -f 'Makefile' ]; then
make_maintainer_clean
fi
}
-function run_autoreconf_if_required ()
+run_autoreconf_if_required ()
{
if [ ! -x 'configure' ]; then
run_autoreconf
bash -n configure
}
-function run_autoreconf ()
+run_autoreconf ()
{
if [[ -z "$AUTORECONF" ]]; then
die "Programmer error, tried to call run_autoreconf () but AUTORECONF was not set"
fi
- if test $use_libtool = 1; then
+ if $use_libtool; then
assert $BOOTSTRAP_LIBTOOLIZE
- run $BOOTSTRAP_LIBTOOLIZE '--copy' '--install' '--force' || die "Cannot execute $BOOTSTRAP_LIBTOOLIZE"
+ run "$BOOTSTRAP_LIBTOOLIZE" '--copy' '--install' '--force' || die "Cannot execute $BOOTSTRAP_LIBTOOLIZE"
fi
- run $AUTORECONF $AUTORECONF_ARGS || die "Cannot execute $AUTORECONF"
+ run "$AUTORECONF" "$AUTORECONF_ARGS" || die "Cannot execute $AUTORECONF"
eval 'bash -n configure' || die "autoreconf generated a malformed configure"
}
-function run ()
+run ()
{
- if $VERBOSE; then
+ if $verbose; then
echo "\`$@' $ARGS"
fi
return 127;
fi
- eval $@ $ARGS
+ eval "$@" "$ARGS"
}
-function parse_command_line_options ()
+parse_command_line_options ()
{
local SHORTOPTS=':apcmt:dvh'
- nassert MAKE_TARGET
+ nassert OPT_TARGET
while getopts "$SHORTOPTS" opt; do
case $opt in
a) #--autoreconf
AUTORECONF_OPTION=true
- MAKE_TARGET='autoreconf'
+ OPT_TARGET+='autoreconf'
;;
p) #--print-env
- PRINT_SETUP_OPTION=true
+ print_setup_opt=true
;;
c) # --configure
CONFIGURE_OPTION=true
- MAKE_TARGET='configure'
+ OPT_TARGET+='configure'
;;
m) # maintainer-clean
CLEAN_OPTION=true
- MAKE_TARGET='clean_op'
+ ;;
+ o) # target
+ CONFIGURE_ARG="$OPTARG"
;;
t) # target
TARGET_OPTION=true
TARGET_OPTION_ARG="$OPTARG"
- MAKE_TARGET="$OPTARG"
+ OPT_TARGET+="$OPTARG"
;;
d) # debug
- DEBUG_OPTION=true
+ opt_debug=true
enable_debug
;;
h) # help
echo " -p # Print ENV";
echo " -c # Just run configure";
echo " -m # Just run maintainer-clean";
+ echo " -o # Specify configure arguments";
echo " -t # Make target";
echo " -d # Enable debug";
echo " -h # Show help";
exit
;;
v) # verbose
- VERBOSE_OPTION=true
- VERBOSE=true
+ opt_verbose=true
+ verbose=true
;;
:)
echo "Option -$OPTARG requires an argument." >&2
shift $((OPTIND-1))
if [ -n "$1" ]; then
- MAKE_TARGET="$@"
+ OPT_TARGET="$@"
fi
}
-function determine_vcs ()
+determine_vcs ()
{
if [[ -d '.git' ]]; then
VCS_CHECKOUT=git
fi
if [[ -n "$VCS_CHECKOUT" ]]; then
- VERBOSE=true
+ verbose=true
fi
}
-function require_libtoolise ()
+require_libtoolise ()
{
- use_libtool=0
grep '^[ ]*A[CM]_PROG_LIBTOOL' configure.ac >/dev/null \
- && use_libtool=1
+ && use_libtool=true
grep '^[ ]*LT_INIT' configure.ac >/dev/null \
- && use_libtool=1
+ && use_libtool=true
}
-function autoreconf_setup ()
+autoreconf_setup ()
{
# Set ENV MAKE in order to override "make"
if [[ -z "$MAKE" ]]; then
if command_exists 'gmake'; then
- MAKE=`type -p gmake`
+ MAKE="$(type -p gmake)"
else
if command_exists 'make'; then
- MAKE=`type -p make`
+ MAKE="$(type -p make)"
fi
fi
if [ "$VCS_CHECKOUT" ]; then
- if $DEBUG; then
+ if $debug; then
MAKE="$MAKE --warn-undefined-variables"
fi
fi
- if $DEBUG; then
+ if $debug; then
MAKE="$MAKE -d"
fi
fi
GNU_BUILD_FLAGS="--install --force"
fi
- if $VERBOSE; then
+ if $verbose; then
GNU_BUILD_FLAGS="$GNU_BUILD_FLAGS --verbose"
fi
fi
fi
- if test $use_libtool = 1; then
+ if $use_libtool; then
if [[ -n "$LIBTOOLIZE" ]]; then
- BOOTSTRAP_LIBTOOLIZE=`type -p $LIBTOOLIZE`
+ BOOTSTRAP_LIBTOOLIZE="$(type -p $LIBTOOLIZE)"
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
- BOOTSTRAP_LIBTOOLIZE=`type -p glibtoolize`
+ BOOTSTRAP_LIBTOOLIZE="$(type -p glibtoolize)"
if [[ -z "$BOOTSTRAP_LIBTOOLIZE" ]]; then
echo "Couldn't find glibtoolize, it is required on OSX"
return 1
fi
else
- BOOTSTRAP_LIBTOOLIZE=`type -p libtoolize`
+ BOOTSTRAP_LIBTOOLIZE="$(type -p libtoolize)"
if [[ -z "$BOOTSTRAP_LIBTOOLIZE" ]]; then
echo "Couldn't find libtoolize, it is required"
fi
fi
- if $VERBOSE; then
+ if $verbose; then
LIBTOOLIZE_OPTIONS="--verbose $BOOTSTRAP_LIBTOOLIZE_OPTIONS"
fi
- if $DEBUG; then
+ if $debug; then
LIBTOOLIZE_OPTIONS="--debug $BOOTSTRAP_LIBTOOLIZE_OPTIONS"
fi
# Test the ENV AUTOMAKE if it exists
if [[ -n "$AUTOMAKE" ]]; then
- run $AUTOMAKE '--help' &> /dev/null || die "Failed to run AUTOMAKE:$AUTOMAKE"
+ run "$AUTOMAKE" '--help' &> /dev/null || die "Failed to run AUTOMAKE:$AUTOMAKE"
fi
# Test the ENV AUTOCONF if it exists
if [[ -n "$AUTOCONF" ]]; then
- run $AUTOCONF '--help' &> /dev/null || die "Failed to run AUTOCONF:$AUTOCONF"
+ run "$AUTOCONF" '--help' &> /dev/null || die "Failed to run AUTOCONF:$AUTOCONF"
fi
# Test the ENV AUTOHEADER if it exists
if [[ -n "$AUTOHEADER" ]]; then
- run $AUTOHEADER '--help' &> /dev/null || die "Failed to run AUTOHEADER:$AUTOHEADER"
+ run "$AUTOHEADER" '--help' &> /dev/null || die "Failed to run AUTOHEADER:$AUTOHEADER"
fi
# Test the ENV AUTOM4TE if it exists
if [[ -n "$AUTOM4TE" ]]; then
- run $AUTOM4TE '--help' &> /dev/null || die "Failed to run AUTOM4TE:$AUTOM4TE"
+ run "$AUTOM4TE" '--help' &> /dev/null || die "Failed to run AUTOM4TE:$AUTOM4TE"
fi
# Test the ENV AUTOHEADER if it exists, if not we add one and add --install
if [[ -z "$ACLOCAL" ]]; then
ACLOCAL="aclocal --install"
fi
- run $ACLOCAL '--help' &> /dev/null || die "Failed to run ACLOCAL:$ACLOCAL"
+ run "$ACLOCAL" '--help' &> /dev/null || die "Failed to run ACLOCAL:$ACLOCAL"
if [[ -z "$AUTORECONF" ]]; then
- AUTORECONF=`type -p autoreconf`
+ AUTORECONF="$(type -p autoreconf)"
if [[ -z "$AUTORECONF" ]]; then
die "Couldn't find autoreconf"
fi
fi
- run $AUTORECONF '--help' &> /dev/null || die "Failed to run AUTORECONF:$AUTORECONF"
+ run "$AUTORECONF" '--help' &> /dev/null || die "Failed to run AUTORECONF:$AUTORECONF"
}
-function print_setup ()
+print_setup ()
{
- saved_debug_status=$DEBUG
- if $DEBUG; then
+ local saved_debug_status=$debug
+ if $debug; then
disable_debug
fi
echo "--configure"
fi
- if $DEBUG_OPTION; then
+ if $opt_debug; then
echo "--debug"
fi
- if $PRINT_SETUP_OPTION; then
+ if $print_setup_opt; then
echo "--print-env"
fi
echo "--target=$TARGET_OPTION_ARG"
fi
- if $VERBOSE_OPTION; then
+ if $opt_verbose; then
echo "--verbose"
fi
echo "VCS_CHECKOUT=$VCS_CHECKOUT"
fi
- if $VERBOSE; then
- echo "VERBOSE=true"
- fi
-
- if $DEBUG; then
- echo "DEBUG=true"
+ if $debug; then
+ echo "debug=true"
fi
if [[ -n "$WARNINGS" ]]; then
echo "WARNINGS=$WARNINGS"
fi
+
+ if $saved_debug_status; then
+ echo "DEBUG=true"
+ fi
+
echo '----------------------------------------------'
if $saved_debug_status; then
fi
}
-function make_clean_option ()
+make_clean_option ()
{
run_configure_if_required
fi
}
-function make_for_autoreconf ()
+make_for_autoreconf ()
{
if [ -f 'Makefile' ]; then
make_maintainer_clean
assert_no_file 'Makefile'
}
-function check_make_target()
+check_make_target()
{
+ local ret=0
case $1 in
'self')
;;
;;
*)
echo "Matched default"
- return 1
+ ret=1
;;
esac
- return 0
+ return $ret
}
-function bootstrap ()
+execute_job ()
{
+ # We should always have a target by this point
+ assert MAKE_TARGET
+
determine_target_platform
determine_vcs
# Set up whatever we need to do to use autoreconf later
+ use_libtool=false
require_libtoolise
if ! autoreconf_setup; then
return 1
fi
- if [ -z "$MAKE_TARGET" ]; then
- MAKE_TARGET="make_default"
- fi
-
- if $PRINT_SETUP_OPTION -o $DEBUG; then
+ if $print_setup_opt -o $debug; then
echo
print_setup
echo
# Exit if all we were looking for were the currently used options
- if $PRINT_SETUP_OPTION; then
+ if $print_setup_opt; then
exit
fi
fi
PREFIX_ARG="--prefix=$PREFIX"
fi
- # We should always have a target by this point
- assert MAKE_TARGET
+ if $CLEAN_OPTION; then
+ make_maintainer_clean
+ fi
- local MAKE_TARGET_ARRAY=($MAKE_TARGET)
+ local MAKE_TARGET_ARRAY
+ MAKE_TARGET_ARRAY=( $MAKE_TARGET )
for target in "${MAKE_TARGET_ARRAY[@]}"
do
fi
fi
+ if $jenkins_build_environment; then
+ use_banner $target
+ fi
+
local snapshot_run=false
local valgrind_run=false
make_default
;;
'clang')
+ make_distclean
if ! check_clang; then
die "clang was not found"
fi
fi
;;
'clang-analyzer')
+ make_distclean
if ! check_clang_analyzer; then
die "clang-analyzer was not found"
fi
fi
;;
'mingw')
- if ! check_mingw; then
- die "mingw was not found"
- fi
-
+ make_distclean
if ! make_for_mingw; then
die "Failed to build mingw: $?"
fi
make_darwin_malloc
;;
'valgrind')
- make_maintainer_clean
make_valgrind
;;
'universe')
make_target "$target"
;;
esac
-
- if $jenkins_build_environment; then
- if ! $snapshot_run; then
- run_make_maintainer_clean_if_possible
- fi
- fi
-
done
}
-function main ()
+main ()
{
+ # Are we running inside of Jenkins?
+ if [[ -n "$JENKINS_HOME" ]]; then
+ declare -r jenkins_build_environment=true
+ else
+ declare -r jenkins_build_environment=false
+ fi
+
# Variables we export
declare -x VCS_CHECKOUT=
# Variables we control globally
- local MAKE_TARGET=
+ local -a MAKE_TARGET=
local CONFIGURE=
+ local use_libtool=false
+ local verbose=false
+
+ #getop variables
+ local opt_debug=false
+ local opt_verbose=false
+
+ if [[ -n "$VERBOSE" ]]; then
+ verbose=true
+ fi
# Options for getopt
local AUTORECONF_OPTION=false
local CLEAN_OPTION=false
local CONFIGURE_OPTION=false
- local DEBUG_OPTION=false
- local PRINT_SETUP_OPTION=false
+ local print_setup_opt=false
local TARGET_OPTION=false
local TARGET_OPTION_ARG=
- local VERBOSE_OPTION=false
local OLD_CONFIGURE=
local OLD_CONFIGURE_ARG=
local AUTORECONF_REBUILD_HOST=false
local AUTORECONF_REBUILD=false
- local -r top_srcdir=`pwd`
+ local -r top_srcdir="$(pwd)"
# Default configure
if [ -z "$CONFIGURE" ]; then
rebuild_host_os no_output
- parse_command_line_options $@
+ local OPT_TARGET=
+ parse_command_line_options "$@"
+
+ nassert MAKE_TARGET
+
+ if [ -n "$OPT_TARGET" ]; then
+ MAKE_TARGET="$OPT_TARGET"
+ fi
# If we are running under Jenkins we predetermine what tests we will run against
# This MAKE_TARGET can be overridden by parse_command_line_options based MAKE_TARGET changes.
# We don't want Jenkins overriding other variables, so we NULL them.
if [ -z "$MAKE_TARGET" ]; then
if $jenkins_build_environment; then
- if [[ -n "$label" ]]; then
- check_make_target $label
- if [ $? -eq 0 ]; then
- MAKE_TARGET="$label"
+ if [[ -n "$JENKINS_TARGET" ]]; then
+ MAKE_TARGET="$JENKINS_TARGET"
+ else
+ if [[ -n "$label" ]]; then
+ check_make_target $label
+ if [ $? -eq 0 ]; then
+ MAKE_TARGET="$label"
+ fi
fi
- fi
- if [[ -n "$LABEL" ]]; then
- check_make_target $LABEL
- if [ $? -eq 0 ]; then
- MAKE_TARGET="$LABEL"
+
+ if [[ -n "$LABEL" ]]; then
+ check_make_target $LABEL
+ if [ $? -eq 0 ]; then
+ MAKE_TARGET="$LABEL"
+ fi
fi
- fi
- if [ -z "$MAKE_TARGET" ]; then
- MAKE_TARGET='jenkins'
+ if [ -z "$MAKE_TARGET" ]; then
+ MAKE_TARGET='jenkins'
+ fi
fi
fi
fi
- bootstrap
+ if [ -z "$MAKE_TARGET" ]; then
+ MAKE_TARGET="make_default"
+ fi
+
+ # We should always have a target by this point
+ assert MAKE_TARGET
+
+ execute_job
+ local ret=$?
jobs -l
wait
- exit 0
+ exit $ret
}
-function set_branch ()
+set_branch ()
{
if [ -z "$BRANCH" ]; then
if [ -z "$CI_PROJECT_TEAM" ]; then
fi
}
-function merge ()
+merge ()
{
if [ -z "$VCS_CHECKOUT" ]; then
die "Merges require VCS_CHECKOUT."
fi
}
-function enable_debug ()
+enable_debug ()
{
- if ! $DEBUG; then
- local caller_loc=`caller`
- if [ -n $1 ]; then
+ if ! $debug; then
+ local caller_loc="$(caller)"
+ if [[ -n "$1" ]]; then
echo "$caller_loc Enabling debug: $1"
else
echo "$caller_loc Enabling debug"
fi
set -x
- DEBUG=true
+ debug=true
fi
}
-function usage ()
+usage ()
{
cat << EOF
Usage: $program_name [OPTION]..
EOF
}
-function disable_debug ()
+disable_debug ()
{
set +x
- DEBUG=true
+ debug=false
}
-# Script begins here
+check_shell ()
+{
+ if [ -x '/usr/local/bin/shellcheck' ]; then
+ /usr/local/bin/shellcheck "$1"
+ local ret=$?
+
+ if [ "$ret" -ne 0 ]; then
+ die "$1 failed shellcheck"
+ fi
+ fi
+}
-program_name=$0
-
-env_debug_enabled=false
-if [[ -n "$JENKINS_HOME" ]]; then
- declare -r jenkins_build_environment=true
-else
- declare -r jenkins_build_environment=false
-fi
-
-export ACLOCAL
-export AUTOCONF
-export AUTOHEADER
-export AUTOM4TE
-export AUTOMAKE
-export AUTORECONF
-export CONFIGURE_ARG
-export DEBUG
-export GNU_BUILD_FLAGS
-export LIBTOOLIZE
-export LIBTOOLIZE_OPTIONS
-export MAKE
-export PREFIX_ARG
-export TESTS_ENVIRONMENT
-export VERBOSE
-export WARNINGS
-
-case $OSTYPE in
- darwin*)
- export MallocGuardEdges
- export MallocErrorAbort
- export MallocScribble
- ;;
-esac
-
-# We check for DEBUG twice, once before we source the config file, and once afterward
-env_debug_enabled=false
-if [[ -n "$DEBUG" ]]; then
- env_debug_enabled=true
- enable_debug
- print_setup
-fi
-
-# Variables which only can be set by .bootstrap
-BOOTSTRAP_SNAPSHOT=false
-BOOTSTRAP_SNAPSHOT_CHECK=
-
-if [ -f '.bootstrap' ]; then
- source '.bootstrap'
-fi
-
-if $env_debug_enabled; then
- enable_debug
-else
+bootstrap ()
+{
+ check_shell 'bootstrap.sh'
+ local env_debug_enabled=false
+ local debug=false
+
+ export ACLOCAL
+ export AUTOCONF
+ export AUTOHEADER
+ export AUTOM4TE
+ export AUTOMAKE
+ export AUTORECONF
+ export CONFIGURE_ARG
+ export DEBUG
+ export GNU_BUILD_FLAGS
+ export LIBTOOLIZE
+ export LIBTOOLIZE_OPTIONS
+ export MAKE
+ export PREFIX_ARG
+ export TESTS_ENVIRONMENT
+ export VERBOSE
+ export WARNINGS
+
+ case $OSTYPE in
+ darwin*)
+ export MallocGuardEdges
+ export MallocErrorAbort
+ export MallocScribble
+ ;;
+ esac
+
+ # We check for DEBUG twice, once before we source the config file, and once afterward
if [[ -n "$DEBUG" ]]; then
+ env_debug_enabled=true
+ fi
+
+ # Variables which only can be set by .bootstrap
+ BOOTSTRAP_SNAPSHOT=false
+ BOOTSTRAP_SNAPSHOT_CHECK=
+
+ if [ -f '.bootstrap' ]; then
+ source '.bootstrap'
+ fi
+
+ # We do this in order to protect the case where DEBUG that came from the ENV (i.e. it overrides what is found in .bootstrap
+ if $env_debug_enabled; then
+ enable_debug
+ elif [[ -n "$DEBUG" ]]; then
enable_debug "Enabling DEBUG from '.bootstrap'"
+ fi
+
+ if $env_debug_enabled; then
print_setup
fi
-fi
-# We do this in order to protect the case where DEBUG
-if ! $env_debug_enabled; then
- DEBUG=false
-fi
-main $@
+ main "$@"
+}
+
+# Script begins here
+declare -r program_name="$0"
+bootstrap "$@"
#include "clients/generator.h"
+#define KEY_BYTES 20
+
/* Use this for string generation */
static const char ALPHANUMERICS[]=
"0123456789ABCDEFGHIJKLMNOPQRSTWXYZabcdefghijklmnopqrstuvwxyz";
for (uint64_t x= 0; x < number_of; x++)
{
- pairs[x].key= (char *)calloc(100, sizeof(char));
+ pairs[x].key= (char *)calloc(KEY_BYTES, sizeof(char));
if (pairs[x].key == NULL)
goto error;
- get_random_string(pairs[x].key, 100);
- pairs[x].key_length= 100;
+ get_random_string(pairs[x].key, KEY_BYTES);
+ pairs[x].key_length= KEY_BYTES;
if (value_length)
{
/* LibMemcached
- * Copyright (C) 2011-2012 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2011-2013 Data Differential, http://datadifferential.com/
* Copyright (C) 2006-2009 Brian Aker
* All rights reserved.
*
#define DEFAULT_EXECUTE_NUMBER 10000
#define DEFAULT_CONCURRENCY 1
+#define VALUE_BYTES 4096
+
#define PROGRAM_NAME "memslap"
#define PROGRAM_DESCRIPTION "Generates a load against a memcached custer of servers."
if (opt_test == SET_TEST)
{
- context->execute_pairs= pairs_generate(opt_execute_number, 400);
+ context->execute_pairs= pairs_generate(opt_execute_number, VALUE_BYTES);
context->execute_number= opt_execute_number;
}
break;
case OPT_DEBUG: /* --debug or -d */
- opt_verbose = OPT_DEBUG;
+ opt_verbose= OPT_DEBUG;
break;
case OPT_VERSION: /* --version or -V */
/* We always used non-blocking IO for load since it is faster */
memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
- pairs_st *pairs= pairs_generate(number_of, 400);
+ pairs_st *pairs= pairs_generate(number_of, VALUE_BYTES);
*actual_loaded= execute_set(memc_clone, pairs, number_of);
memcached_free(memc_clone);
#include "utilities.h"
#define PROGRAM_NAME "memtouch"
-#define PROGRAM_DESCRIPTION "Update the expiration value of an alreasy existing value in the sever"
+#define PROGRAM_DESCRIPTION "Update the expiration value of an already existing value in the server"
/* Prototypes */
#define MAX_TOKENS 10
/* server information */
-typedef struct mcd_sever
+typedef struct mcd_server
{
char srv_host_name[MCD_HOST_LENGTH]; /* host name of server */
int srv_port; /* server port */
expiration values, the operation will succeed by seeding the value for that
key with a initial value to expire with the provided expiration time. The
flags will be set to zero.The value is then returned via the uint32_t
-value pointer you pass to it.
+value pointer you pass to it. memcached_increment_with_initial is only available
+when using the binary protocol.
memcached_decrement_with_initial takes a key and keylength and decrements
the value by the offset passed to it. If the object specified by key does
expiration values, the operation will succeed by seeding the value for that
key with a initial value to expire with the provided expiration time. The
flags will be set to zero.The value is then returned via the uint32_t
-value pointer you pass to it.
+value pointer you pass to it. memcached_decrement_with_initial is only available
+when using the binary protocol.
:c:func:`memcached_increment_by_key`, :c:func:`memcached_decrement_by_key`,
:c:func:`memcached_increment_with_initial_by_key`, and
if (memcached_fatal(rc))
{
+ fprintf(stderr, "%s:%d %s\n", __FILE__, __LINE__, memcached_strerror(NULL, rc));
assert(memcached_last_error(instance->root) != MEMCACHED_SUCCESS);
*value= UINT64_MAX;
}
+ else if (memcached_failed(rc))
+ {
+ *value= UINT64_MAX;
+ }
else
{
+ assert(memcached_last_error(instance->root) != MEMCACHED_NOTFOUND);
*value= instance->root->result.numeric_value;
}
}
case EWOULDBLOCK:
#endif
case EAGAIN:
-#ifdef TARGET_OS_LINUX
+#ifdef __linux
case ERESTART:
#endif
break; // No IO is fine, we can just move on
assert_msg(active_fd == -1 , "poll() returned an unexpected value");
switch (local_errno)
{
-#ifdef TARGET_OS_LINUX
+#ifdef __linux
case ERESTART:
#endif
case EINTR:
case EWOULDBLOCK:
#endif
case EAGAIN:
-#ifdef TARGET_OS_LINUX
+#ifdef __linux
case ERESTART:
#endif
{
case EWOULDBLOCK:
#endif
case EAGAIN:
-#ifdef TARGET_OS_LINUX
+#ifdef __linux
case ERESTART:
#endif
if (memcached_success(io_wait(instance, MEM_READ)))
{
char* value= NULL;
- if (memcached_string_length(self))
+ assert_msg(self, "Invalid memcached_string_st");
+ if (self)
{
- assert_msg(self, "Invalid memcached_string_st");
- // If we fail at adding the null, we copy and move on
- if (memcached_success(memcached_string_append_null(self)))
+ if (memcached_string_length(self))
{
- return memcached_string_c_copy(self);
+ // If we fail at adding the null, we copy and move on
+ if (memcached_failed(memcached_string_append_null(self)))
+ {
+ return NULL;
+ }
+
+ value= self->string;
+ _init_string(self);
}
-
- value= self->string;
-
- _init_string(self);
}
return value;
int error;
switch ((error= errno))
{
-#ifdef TARGET_OS_LINUX
+#ifdef __linux
case ERESTART:
#endif
case EINTR:
void create_core(void)
{
-#if defined(TARGET_OS_OSX) && TARGET_OS_OSX
- if (TARGET_OS_OSX)
+#if defined(__APPLE__) && __APPLE__
+ if (__APPLE__)
{
return;
}
size_t number_of_cpus()
{
size_t number_of_cpu= 1;
-#if defined(TARGET_OS_LINUX) && TARGET_OS_LINUX
+#if defined(__linux) && __linux
number_of_cpu= sysconf(_SC_NPROCESSORS_ONLN);
#elif defined(HAVE_SYS_SYSCTL_H) && defined(CTL_HW) && defined(HW_NCPU) && defined(HW_AVAILCPU) && defined(HW_NCPU)
int mib[4];
*
* Data Differential YATL (i.e. libtest) library
*
- * Copyright (C) 2012 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2012-2013 Data Differential, http://datadifferential.com/
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
#include <ctime>
#include <fnmatch.h>
#include <iostream>
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
#include <fstream>
#include <memory>
#include <sys/stat.h>
Valgrind does not currently work reliably, or sometimes at all, on OSX
- Fri Jun 15 11:24:07 EDT 2012
*/
-#if defined(TARGET_OS_OSX) && TARGET_OS_OSX
+#if defined(__APPLE__) && __APPLE__
if (valgrind_is_caller())
{
return EXIT_SKIP;
true_app.will_fail();
const char *args[]= { "--fubar", 0 };
-#if defined(TARGET_OS_OSX) && TARGET_OS_OSX
+#if defined(__APPLE__) && __APPLE__
ASSERT_EQ(Application::INVALID_POSIX_SPAWN, true_app.run(args));
-#elif defined(TARGET_OS_FREEBSD) && TARGET_OS_FREEBSD
+#elif defined(__FreeBSD__) && __FreeBSD__
ASSERT_EQ(Application::INVALID_POSIX_SPAWN, true_app.run(args));
#else
ASSERT_EQ(Application::SUCCESS, true_app.run(args));
static test_return_t gdb_wait_services_appliction_TEST(void *)
{
test_skip(true, false);
-#if defined(TARGET_OS_OSX) && TARGET_OS_OSX
- test_skip(0, TARGET_OS_OSX);
+#if defined(__APPLE__) && __APPLE__
+ test_skip(0, __APPLE__);
#endif
test_skip(0, access("/etc/services", R_OK ));
test_skip(0, access("libtest/abort", X_OK ));
test_skip(true, false);
-#if defined(TARGET_OS_OSX) && TARGET_OS_OSX
- test_skip(0, TARGET_OS_OSX);
+#if defined(__APPLE__) && __APPLE__
+ test_skip(0, __APPLE__);
#endif
libtest::Application abort_app("libtest/abort", true);
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#serial 5
+#serial 6
AC_DEFUN([AX_DEBUG],
[AC_PREREQ([2.63])dnl
[Add debug code/turns off optimizations (yes|no) @<:@default=no@:>@])],
[ax_enable_debug=yes
AC_DEFINE([DEBUG],[1],[Define to 1 to enable debugging code.])
- AX_CHECK_LIBRARY([MCHECK],[mcheck.h],[mcheck],[AX_APPEND_LINK_FLAGS([-lmcheck])])],
+ AX_CHECK_LIBRARY([MCHECK],[mcheck.h],[mcheck],[AX_APPEND_LINK_FLAGS([-lmcheck])])
+ AX_ADD_AM_MACRO([--debug],[AM_YFLAGS])
+ AX_ADD_AM_MACRO([-D_GLIBCXX_DEBUG],[AM_CPPFLAGS])],
[ax_enable_debug=no
AC_SUBST([MCHECK])
AC_DEFINE([DEBUG],[0],[Define to 1 to enable debugging code.])])
# -Wdeclaration-after-statement is counter to C99
# _APPEND_COMPILE_FLAGS_ERROR([-pedantic])
-#serial 10
+#serial 13
+
+AC_DEFUN([_SET_SANITIZE_FLAGS],
+ [AS_IF([test "x$MINGW" != xyes],[
+ AS_IF([test "x$enable_shared" = "xyes"],
+ [AS_CASE([$ax_harden_sanitize],
+ [thread],[
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=thread])],
+ [address],[
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=address])],
+ [rest],[
+ _APPEND_COMPILE_FLAGS_ERROR([-fno-omit-frame-pointer])
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=integer])
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=memory])
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=alignment])
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=bool])
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=bounds])
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=enum])
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=float-cast-overflow])
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=float-divide-by-zero])
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=integer-divide-by-zero])
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=null])
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=object-size])
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=return])
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=shift])
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=signed-integer-overflow])
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=unreachable])
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=unsigned-integer-overflow])
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=vla-bound])
+ _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=vptr])])
+ ])
+ ])
+ ])
AC_DEFUN([_WARNINGS_AS_ERRORS],
[AC_CACHE_CHECK([if all warnings into errors],[ac_cv_warnings_as_errors],
# Note: Should this be LIBS or LDFLAGS?
AC_DEFUN([_APPEND_LINK_FLAGS_ERROR],
- [AC_REQUIRE([AX_APPEND_LINK_FLAGS])
- AX_APPEND_LINK_FLAGS([$1],[LDFLAGS],[-Werror])
+ [AX_APPEND_LINK_FLAGS([$1],[LDFLAGS],[-Werror])
])
AC_DEFUN([_APPEND_COMPILE_FLAGS_ERROR],
- [AC_REQUIRE([AX_APPEND_COMPILE_FLAGS])
- AX_APPEND_COMPILE_FLAGS([$1],,[-Werror])
+ [AX_APPEND_COMPILE_FLAGS([$1],,[-Werror])
])
# Everything above this does the heavy lifting, while what follows does the specifics.
[AS_IF([test "$CC" != "clang"],
[_APPEND_LINK_FLAGS_ERROR([-z relro -z now])
AS_IF([test "x$ac_cv_warnings_as_errors" = xyes],[AX_APPEND_LINK_FLAGS([-Werror])])
- AS_IF([test "x$ac_cv_vcs_checkout" = xyes],[_APPEND_LINK_FLAGS_ERROR([-rdynamic])])
+ AS_IF([test "x$ac_cv_vcs_checkout" = xyes],
+ [_APPEND_LINK_FLAGS_ERROR([-rdynamic])
+# AX_APPEND_LINK_FLAGS([--coverage])])
])
])
+AC_DEFUN([_AX_HARDEN_SANITIZE],
+ [AC_REQUIRE([AX_DEBUG])
+ AC_ARG_WITH([sanitize],
+ [AS_HELP_STRING([--with-sanitize],
+ [Enable sanitize flag for compiler if it supports them @<:@default=no@:>@])],
+ [AS_CASE([$with_sanitize],
+ [thread],[
+ ax_harden_sanitize='thread'],
+ [address],[
+ ax_harden_sanitize='address'],
+ [ax_harden_sanitize='rest'])
+ ],
+ [AS_IF([test "x$ax_enable_debug" = xyes],[ax_harden_sanitize='rest'])])
+ ])
+
AC_DEFUN([_HARDEN_CC_COMPILER_FLAGS],
[AC_LANG_PUSH([C])dnl
AS_IF([test "x$ax_enable_debug" = xyes],
[CFLAGS=''
_APPEND_COMPILE_FLAGS_ERROR([-H])
- _APPEND_COMPILE_FLAGS_ERROR([-ggdb])
_APPEND_COMPILE_FLAGS_ERROR([-g])
- _APPEND_COMPILE_FLAGS_ERROR([-O0]),
+ _APPEND_COMPILE_FLAGS_ERROR([-g3])
+ _APPEND_COMPILE_FLAGS_ERROR([-fmudflapth])
+ _APPEND_COMPILE_FLAGS_ERROR([-fno-eliminate-unused-debug-types])
_APPEND_COMPILE_FLAGS_ERROR([-fno-omit-frame-pointer])
],[
_APPEND_COMPILE_FLAGS_ERROR([-g])
AS_IF([test "x$ac_cv_vcs_checkout" = xyes],
[_APPEND_COMPILE_FLAGS_ERROR([-fstack-check])
+# _APPEND_COMPILE_FLAGS_ERROR([--coverage])
_APPEND_COMPILE_FLAGS_ERROR([-Wpragmas])
_APPEND_COMPILE_FLAGS_ERROR([-Wunknown-pragmas])],
[_APPEND_COMPILE_FLAGS_ERROR([-Wno-unknown-pragmas])
_APPEND_COMPILE_FLAGS_ERROR([-Wundef])
_APPEND_COMPILE_FLAGS_ERROR([-Wunsafe-loop-optimizations])
_APPEND_COMPILE_FLAGS_ERROR([-funsafe-loop-optimizations])
- AS_IF([test "x$MINGW" != xyes],[
- AS_IF([test "x$ac_cv_vcs_checkout" = xyes],[
- AS_IF([test "x$enable_shared" = "xyes"],[
- _APPEND_COMPILE_FLAGS_ERROR([-fno-omit-frame-pointer])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=address])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=integer])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=thread])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=memory])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=alignment])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=bool])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=bounds])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=enum])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=float-cast-overflow])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=float-divide-by-zero])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=integer-divide-by-zero])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=null])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=object-size])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=return])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=shift])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=signed-integer-overflow])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=unreachable])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=unsigned-integer-overflow])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=vla-bound])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=vptr])
- ])
- ])
- ])
+
_APPEND_COMPILE_FLAGS_ERROR([-Wclobbered])
_APPEND_COMPILE_FLAGS_ERROR([-Wunused])
_APPEND_COMPILE_FLAGS_ERROR([-Wunused-result])
_APPEND_COMPILE_FLAGS_ERROR([-Wsizeof-pointer-memaccess])
_APPEND_COMPILE_FLAGS_ERROR([-Wpacked])
# _APPEND_COMPILE_FLAGS_ERROR([-Wlong-long])
- _APPEND_COMPILE_FLAGS_ERROR([-Wunreachable-code])
+# GCC 4.5 removed this.
+# _APPEND_COMPILE_FLAGS_ERROR([-Wunreachable-code])
+
+ _SET_SANITIZE_FLAGS
AS_IF([test "x$ax_enable_debug" = xno],
[AS_IF([test "x$ac_cv_vcs_checkout" = xyes],
- [AS_IF([test "x${target_os}" != "xmingw"],
+ [AS_IF([test "x${host_os}" != "xmingw"],
[AS_IF([test "x$ac_c_gcc_recent" = xyes],
[_APPEND_COMPILE_FLAGS_ERROR([-D_FORTIFY_SOURCE=2])
#_APPEND_COMPILE_FLAGS_ERROR([-Wstack-protector])
AC_DEFUN([_HARDEN_CXX_COMPILER_FLAGS],
[AC_LANG_PUSH([C++])
- AC_REQUIRE([_APPEND_COMPILE_FLAGS_ERROR])
-
AS_IF([test "x$ax_enable_debug" = xyes],
[CXXFLAGS=''
_APPEND_COMPILE_FLAGS_ERROR([-H])
- _APPEND_COMPILE_FLAGS_ERROR([-ggdb])
_APPEND_COMPILE_FLAGS_ERROR([-g])
- _APPEND_COMPILE_FLAGS_ERROR([-O0]),
+ _APPEND_COMPILE_FLAGS_ERROR([-g3])
+ _APPEND_COMPILE_FLAGS_ERROR([-fmudflapth])
+ _APPEND_COMPILE_FLAGS_ERROR([-fno-inline])
+ _APPEND_COMPILE_FLAGS_ERROR([-fno-eliminate-unused-debug-types])
_APPEND_COMPILE_FLAGS_ERROR([-fno-omit-frame-pointer])
],[
_APPEND_COMPILE_FLAGS_ERROR([-g])
AS_IF([test "x$ac_cv_vcs_checkout" = xyes],
[_APPEND_COMPILE_FLAGS_ERROR([-fstack-check])
+# _APPEND_COMPILE_FLAGS_ERROR([--coverage])
_APPEND_COMPILE_FLAGS_ERROR([-Wpragmas])
_APPEND_COMPILE_FLAGS_ERROR([-Wunknown-pragmas])],
[_APPEND_COMPILE_FLAGS_ERROR([-Wno-unknown-pragmas])
_APPEND_COMPILE_FLAGS_ERROR([-funsafe-loop-optimizations])
_APPEND_COMPILE_FLAGS_ERROR([-Wc++11-compat])
# _APPEND_COMPILE_FLAGS_ERROR([-Weffc++])
- AS_IF([test "x$MINGW" != xyes],[
- AS_IF([test "x$ac_cv_vcs_checkout" = xyes],[
- AS_IF([test "x$enable_shared" = "xyes"],[
- _APPEND_COMPILE_FLAGS_ERROR([-fno-omit-frame-pointer])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=address])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=integer])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=thread])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=memory])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=alignment])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=bool])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=bounds])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=enum])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=float-cast-overflow])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=float-divide-by-zero])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=integer-divide-by-zero])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=null])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=object-size])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=return])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=shift])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=signed-integer-overflow])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=unreachable])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=unsigned-integer-overflow])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=vla-bound])
- _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=vptr])
- ])
- ])
- ])
# _APPEND_COMPILE_FLAGS_ERROR([-Wold-style-cast])
_APPEND_COMPILE_FLAGS_ERROR([-Wclobbered])
_APPEND_COMPILE_FLAGS_ERROR([-Wunused])
_APPEND_COMPILE_FLAGS_ERROR([-Wsizeof-pointer-memaccess])
_APPEND_COMPILE_FLAGS_ERROR([-Wpacked])
# _APPEND_COMPILE_FLAGS_ERROR([-Wlong-long])
- _APPEND_COMPILE_FLAGS_ERROR([-Wunreachable-code])
+# GCC 4.5 removed this.
+# _APPEND_COMPILE_FLAGS_ERROR([-Wunreachable-code])
AS_IF([test "x$ax_enable_debug" = xno],
[AS_IF([test "x$ac_cv_vcs_checkout" = xyes],
- [AS_IF([test "x${target_os}" != "xmingw"],
+ [AS_IF([test "x${host_os}" != "xmingw"],
[AS_IF([test "x$ac_c_gcc_recent" = xyes],
[_APPEND_COMPILE_FLAGS_ERROR([-D_FORTIFY_SOURCE=2])
#_APPEND_COMPILE_FLAGS_ERROR([-Wstack-protector])
_APPEND_COMPILE_FLAGS_ERROR([-fstack-protector-all])
])])])])
+ _SET_SANITIZE_FLAGS
+
AS_IF([test "x$ac_cv_warnings_as_errors" = xyes],
[AX_APPEND_FLAG([-Werror])])
AC_LANG_POP([C++])
# _HARDEN_CC_COMPILER_FLAGS, _HARDEN_CXX_COMPILER_FLAGS
AC_DEFUN([AX_HARDEN_COMPILER_FLAGS],
[AC_PREREQ([2.63])dnl
- AC_REQUIRE([_WARNINGS_AS_ERRORS])
- AC_REQUIRE([AX_APPEND_LINK_FLAGS])
+ AC_REQUIRE([AC_CANONICAL_HOST])
AC_REQUIRE([AX_COMPILER_VERSION])
- AC_REQUIRE([AX_DEBUG])
- AC_REQUIRE([AX_VCS_CHECKOUT])
+ AC_REQUIRE([AX_ASSERT])
+ _WARNINGS_AS_ERRORS
+ _AX_HARDEN_SANITIZE
AC_REQUIRE([gl_VISIBILITY])
AS_IF([test -n "$CFLAG_VISIBILITY"],[CPPFLAGS="$CPPFLAGS $CFLAG_VISIBILITY"])
- AC_REQUIRE([_HARDEN_LINKER_FLAGS])
- AC_REQUIRE([_HARDEN_CC_COMPILER_FLAGS])
- AC_REQUIRE([_HARDEN_CXX_COMPILER_FLAGS])
+ _WARNINGS_AS_ERRORS
+ _HARDEN_LINKER_FLAGS
+ _HARDEN_CC_COMPILER_FLAGS
+ _HARDEN_CXX_COMPILER_FLAGS
])
+
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#serial 4
+#serial 3
AC_DEFUN([AX_PROG_MEMCACHED],
- [AX_WITH_PROG([MEMCACHED_BINARY],[memcached],[unknown])
- ax_memcached_success=
- AS_IF([test x"$MEMCACHED_BINARY" != xunknown],
- [AS_IF([test -x "$MEMCACHED_BINARY"],
- [ax_memcached_version=`$MEMCACHED_BINARY -h | sed 1q | awk '{print \$ 2 }' | sed 's|[\-a-z0-9]*$||' | awk -F. '{printf "%d.%d.%d", $[]1, $[]2, $[]3}'`
- AS_IF([test -n "$ax_memcached_version"],
- [ax_memcached_success='ok'
- AC_MSG_RESULT([memcached version "$ax_memcached_version"])
- AC_DEFINE_UNQUOTED([MEMCACHED_VERSION],"$ax_memcached_version",[Memcached binary version])])
- ])
- ])
-
- AS_IF([test -n "$ax_memcached_success"],
- [AC_DEFINE([HAVE_MEMCACHED_BINARY], [1], [If Memcached binary is available])
- AC_DEFINE_UNQUOTED([MEMCACHED_BINARY],"$MEMCACHED_BINARY",[Name of the memcached binary used in make test])
- ],
- [AC_DEFINE([HAVE_MEMCACHED_BINARY], [0], [If Memcached binary is available])
- MEMCACHED_BINARY=
- ])
- ])
+ [AX_WITH_PROG([MEMCACHED_BINARY],[memcached])
+ AS_IF([test -f "$ac_cv_path_MEMCACHED_BINARY"],
+ [AC_DEFINE([HAVE_MEMCACHED_BINARY], [1], [If Memcached binary is available])
+ AC_DEFINE_UNQUOTED([MEMCACHED_BINARY],"$ac_cv_path_MEMCACHED_BINARY",[Name of the memcached binary used in make test])
+ ax_memcached_version=`$MEMCACHED_BINARY -h | sed 1q | awk '{print \$ 2 }' | sed 's|[\-a-z0-9]*$||' | awk -F. '{printf "%d.%d.%d", $[]1, $[]2, $[]3}'`
+ AC_MSG_RESULT([memcached version "$ax_memcached_version"])
+ AC_DEFINE_UNQUOTED([MEMCACHED_VERSION],"$ax_memcached_version",[Memcached binary version])
+ ])
+ ])
#
# LICENSE
#
-# Copyright (c) 2012 Brian Aker <brian@tangent.org>
+# Copyright (c) 2012-2013 Brian Aker <brian@tangent.org>
#
# Copying and distribution of this file, with or without modification, are
# permitted in any medium without royalty provided the copyright notice
# and this notice are preserved. This file is offered as-is, without any
# warranty.
-#serial 3
+#serial 4
#
AC_DEFUN([AX_PLATFORM],
[AC_REQUIRE([AC_CANONICAL_HOST])
- AC_REQUIRE([AC_CANONICAL_TARGET])
AC_DEFINE_UNQUOTED([HOST_VENDOR],["$host_vendor"],[Vendor of Build System])
AC_DEFINE_UNQUOTED([HOST_OS],["$host_os"], [OS of Build System])
AC_DEFINE_UNQUOTED([HOST_CPU],["$host_cpu"], [CPU of Build System])
- AC_DEFINE_UNQUOTED([TARGET_VENDOR],["$target_vendor"],[Vendor of Target System])
- AC_DEFINE_UNQUOTED([TARGET_OS],["$target_os"], [OS of Target System])
- AC_DEFINE_UNQUOTED([TARGET_CPU],["$target_cpu"], [CPU of Target System])
-
- AS_CASE([$target_os],
+ AS_CASE([$host_os],
[*mingw*],
- [TARGET_WINDOWS="true"
- AC_DEFINE([TARGET_OS_WINDOWS], [1], [Whether we are building for Windows])
+ [HOST_WINDOWS="true"
+ AC_DEFINE([HOST_OS_WINDOWS], [1], [Whether we are building for Windows])
AC_DEFINE([EAI_SYSTEM], [11], [Another magical number])
AH_BOTTOM([
#ifndef HAVE_SYS_SOCKET_H
# define SHUT_RDWR SD_BOTH
#endif
])],
- [*freebsd*],[AC_DEFINE([TARGET_OS_FREEBSD],[1],[Whether we are building for FreeBSD])
+ [*freebsd*],[AC_DEFINE([HOST_OS_FREEBSD],[1],[Whether we are building for FreeBSD])
AC_DEFINE([__APPLE_CC__],[1],[Workaround for bug in FreeBSD headers])],
- [*solaris*],[AC_DEFINE([TARGET_OS_SOLARIS],[1],[Whether we are building for Solaris])],
+ [*solaris*],[AC_DEFINE([HOST_OS_SOLARIS],[1],[Whether we are building for Solaris])],
[*darwin*],
- [TARGET_OSX="true"],
+ [HOST_OSX="true"],
[*linux*],
- [TARGET_LINUX="true"
- AC_DEFINE([TARGET_OS_LINUX],[1],[Whether we build for Linux])])
+ [HOST_LINUX="true"
+ AC_DEFINE([HOST_OS_LINUX],[1],[Whether we build for Linux])])
- AM_CONDITIONAL([BUILD_WIN32],[test "x${TARGET_WINDOWS}" = "xtrue"])
- AM_CONDITIONAL([TARGET_OSX],[test "x${TARGET_OSX}" = "xtrue"])
- AM_CONDITIONAL([TARGET_LINUX],[test "x${TARGET_LINUX}" = "xtrue"])
+ AM_CONDITIONAL([BUILD_WIN32],[test "x${HOST_WINDOWS}" = "xtrue"])
+ AM_CONDITIONAL([HOST_OSX],[test "x${HOST_OSX}" = "xtrue"])
+ AM_CONDITIONAL([HOST_LINUX],[test "x${HOST_LINUX}" = "xtrue"])
+ AM_CONDITIONAL([HOST_FREEBSD],[test "x${HOST_OS_FREEBSD}" = "xtrue"])
])
# and this notice are preserved. This file is offered as-is, without any
# warranty.
-#serial 3
+#serial 5
AC_DEFUN([AX_PROG_SPHINX_BUILD],
- [AX_WITH_PROG([SPHINXBUILD],[sphinx-build],[:])
- AS_IF([test x"SPHINXBUILD" = x":"],
- [SPHINXBUILD=],
- [AS_IF([test -x "$SPHINXBUILD"],
- [AC_MSG_CHECKING([Checking to see if $SPHINXBUILD is recent])
- junk=`$SPHINXBUILD &> version_file`
- ax_sphinx_build_version=`head -1 version_file`
- rm version_file
- AC_MSG_RESULT([$SPHINXBUILD is version "$ax_sphinx_build_version"])
- $SPHINXBUILD -Q -C -b man -d conftest.d . . >/dev/null 2>&1
- AS_IF([test $? -eq 0], ,[SPHINXBUILD=])
- rm -rf conftest.d
- ])
- ])
+ [AX_WITH_PROG([SPHINXBUILD],[sphinx-build],[:])
+ AS_IF([test x"SPHINXBUILD" = x":"],
+ [SPHINXBUILD=],
+ [AS_IF([test -x "$SPHINXBUILD"],
+ [AC_MSG_CHECKING([Checking to see if $SPHINXBUILD is recent])
+ junk=`$SPHINXBUILD --version &> version_file`
+ AS_IF([test $? -eq 0],
+ [ax_sphinx_build_version=`head -1 version_file`],
+ [junk=`$SPHINXBUILD &> version_file`
+ ax_sphinx_build_version=`head -1 version_file`
+ rm version_file
+ AC_MSG_RESULT([$SPHINXBUILD is version "$ax_sphinx_build_version"])
+ $SPHINXBUILD -Q -C -b man -d conftest.d . . >/dev/null 2>&1
+ AS_IF([test $? -eq 0], ,[SPHINXBUILD=])
+ rm -rf conftest.d ])
+ ])
+ rm -f version_file
+ ])
- AS_IF([test -n "${SPHINXBUILD}"],
- [AC_SUBST([SPHINXBUILD])
- ifelse([$1], , :, [$1])],
- [ifelse([$2], , :, [$2])])
- ])
+ AS_IF([test -n "${SPHINXBUILD}"],
+ [AC_SUBST([SPHINXBUILD])
+ ifelse([$1], , :, [$1])],
+ [ifelse([$2], , :, [$2])])
+ ])
-dnl Copyright (C) 2011 Brian Aker (brian@tangent.org)
+# Copyright (C) 2011 Brian Aker (brian@tangent.org)
+#
+# serial 2
-AC_DEFUN([_SEARCH_LIBHIREDIS],[
- AC_REQUIRE([AX_CHECK_LIBRARY])
+AC_DEFUN([_SEARCH_HIREDIS],
+ [AC_REQUIRE([AX_CHECK_LIBRARY])
- AS_IF([test "x$ac_enable_hires" = "xyes"],[
- AX_CHECK_LIBRARY([LIBHIREDIS], [hiredis/hiredis.h], [hiredis],
- [
- LIBHIREDIS_LDFLAGS="-lhiredis"
- AC_DEFINE([HAVE_HIREDIS], [1], [If Hiredis available])
- ],
- [
- AC_DEFINE([HAVE_HIREDIS], [0], [If Hiredis is available])
- ac_enable_hires="no"
- ])
+ AS_IF([test "x$ac_enable_hiredis" = "xyes"],
+ [hiredis_header="hiredis/hiredis.h"],
+ [hiredis_header="does_not_exist"])
- ],
- [
- AC_DEFINE([HAVE_HIREDIS], [0], [If Hiredis is available])
- ])
+ AX_CHECK_LIBRARY([HIREDIS],[$hiredis_header],[hiredis],,
+ [AC_DEFINE([HAVE_HIREDIS],[0],[Define to 1 if HIREDIS is found])])
- AM_CONDITIONAL(HAVE_HIREDIS, [test "x$ac_cv_lib_hiredis_main" = "xyes"])
- ])
+ AS_IF([test "x$ax_cv_have_HIREDIS" = xno],[ac_enable_hiredis="no"])
+ ])
-AC_DEFUN([AX_HAVE_LIBHIREDIS],[
+ AC_DEFUN([AX_ENABLE_LIBHIREDIS],
+ [AC_ARG_ENABLE([hiredis],
+ [AS_HELP_STRING([--disable-hiredis],
+ [Build with hiredis support @<:@default=on@:>@])],
+ [ac_enable_hiredis="$enableval"],
+ [ac_enable_hiredis="yes"])
- AC_ARG_ENABLE([hires],
- [AS_HELP_STRING([--disable-hires],
- [Build with hires support @<:@default=on@:>@])],
- [ac_enable_hires="$enableval"],
- [ac_enable_hires="yes"])
-
- _SEARCH_LIBHIREDIS
-])
+ _SEARCH_HIREDIS
+ ])
{"partial mget", false, (test_callback_fn*)get_test5 },
{"stats_servername", false, (test_callback_fn*)stats_servername_test },
{"increment", false, (test_callback_fn*)increment_test },
- {"increment_with_initial", true, (test_callback_fn*)increment_with_initial_test },
+ {"memcached_increment_with_initial(0)", true, (test_callback_fn*)increment_with_initial_test },
+ {"memcached_increment_with_initial(999)", true, (test_callback_fn*)increment_with_initial_999_test },
{"decrement", false, (test_callback_fn*)decrement_test },
- {"decrement_with_initial", true, (test_callback_fn*)decrement_with_initial_test },
+ {"memcached_decrement_with_initial(3)", true, (test_callback_fn*)decrement_with_initial_test },
+ {"memcached_decrement_with_initial(999)", true, (test_callback_fn*)decrement_with_initial_999_test },
{"increment_by_key", false, (test_callback_fn*)increment_by_key_test },
{"increment_with_initial_by_key", true, (test_callback_fn*)increment_with_initial_by_key_test },
{"decrement_by_key", false, (test_callback_fn*)decrement_by_key_test },
return TEST_SUCCESS;
}
-test_return_t increment_with_initial_test(memcached_st *memc)
+static test_return_t __increment_with_initial_test(memcached_st *memc, uint64_t initial)
{
- test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
-
uint64_t new_number;
- uint64_t initial= 0;
test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
- test_compare(MEMCACHED_SUCCESS,
- memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
- test_compare(new_number, initial);
+ if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
+ {
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
+ test_compare(new_number, initial);
- test_compare(MEMCACHED_SUCCESS,
- memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
- test_compare(new_number, (initial +1));
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
+ test_compare(new_number, (initial +1));
+ }
+ else
+ {
+ test_compare(MEMCACHED_INVALID_ARGUMENTS,
+ memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
+ }
return TEST_SUCCESS;
}
+test_return_t increment_with_initial_test(memcached_st *memc)
+{
+ return __increment_with_initial_test(memc, 0);
+}
+
+test_return_t increment_with_initial_999_test(memcached_st *memc)
+{
+ return __increment_with_initial_test(memc, 999);
+}
+
test_return_t decrement_test(memcached_st *memc)
{
test_compare(return_value_based_on_buffering(memc),
return TEST_SUCCESS;
}
-test_return_t decrement_with_initial_test(memcached_st *memc)
+static test_return_t __decrement_with_initial_test(memcached_st *memc, uint64_t initial)
{
test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
- uint64_t initial= 3;
-
test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
uint64_t new_number;
return TEST_SUCCESS;
}
+test_return_t decrement_with_initial_test(memcached_st *memc)
+{
+ return __decrement_with_initial_test(memc, 3);
+}
+
+test_return_t decrement_with_initial_999_test(memcached_st *memc)
+{
+ return __decrement_with_initial_test(memc, 999);
+}
+
test_return_t increment_by_key_test(memcached_st *memc)
{
const char *master_key= "foo";
test_return_t increment_with_initial_by_key_test(memcached_st *memc)
{
- test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
-
uint64_t new_number;
const char *master_key= "foo";
const char *key= "number";
uint64_t initial= 0;
- test_compare(MEMCACHED_SUCCESS,
- memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
- key, strlen(key),
- 1, initial, 0, &new_number));
- test_compare(new_number, initial);
+ if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
+ {
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
+ key, strlen(key),
+ 1, initial, 0, &new_number));
+ test_compare(new_number, initial);
- test_compare(MEMCACHED_SUCCESS,
- memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
- key, strlen(key),
- 1, initial, 0, &new_number));
- test_compare(new_number, (initial +1));
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
+ key, strlen(key),
+ 1, initial, 0, &new_number));
+ test_compare(new_number, (initial +1));
+ }
+ else
+ {
+ test_compare(MEMCACHED_INVALID_ARGUMENTS,
+ memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
+ key, strlen(key),
+ 1, initial, 0, &new_number));
+ }
return TEST_SUCCESS;
}
uint64_t new_number;
uint64_t initial= 3;
- test_compare(MEMCACHED_SUCCESS,
- memcached_decrement_with_initial_by_key(memc,
- test_literal_param("foo"),
- test_literal_param("number"),
- 1, initial, 0, &new_number));
- test_compare(new_number, initial);
+ if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
+ {
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_decrement_with_initial_by_key(memc,
+ test_literal_param("foo"),
+ test_literal_param("number"),
+ 1, initial, 0, &new_number));
+ test_compare(new_number, initial);
- test_compare(MEMCACHED_SUCCESS,
- memcached_decrement_with_initial_by_key(memc,
- test_literal_param("foo"),
- test_literal_param("number"),
- 1, initial, 0, &new_number));
- test_compare(new_number, (initial - 1));
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_decrement_with_initial_by_key(memc,
+ test_literal_param("foo"),
+ test_literal_param("number"),
+ 1, initial, 0, &new_number));
+ test_compare(new_number, (initial - 1));
+ }
+ else
+ {
+ test_compare(MEMCACHED_INVALID_ARGUMENTS,
+ memcached_decrement_with_initial_by_key(memc,
+ test_literal_param("foo"),
+ test_literal_param("number"),
+ 1, initial, 0, &new_number));
+ }
return TEST_SUCCESS;
}
test_return_t decrement_test(memcached_st *memc);
test_return_t decrement_with_initial_by_key_test(memcached_st *memc);
test_return_t decrement_with_initial_test(memcached_st *memc);
+test_return_t decrement_with_initial_999_test(memcached_st *memc);
test_return_t delete_test(memcached_st *memc);
test_return_t deprecated_set_memory_alloc(memcached_st *memc);
test_return_t enable_cas(memcached_st *memc);
test_return_t increment_test(memcached_st *memc);
test_return_t increment_with_initial_by_key_test(memcached_st *memc);
test_return_t increment_with_initial_test(memcached_st *memc);
+test_return_t increment_with_initial_999_test(memcached_st *memc);
test_return_t init_test(memcached_st *not_used);
test_return_t jenkins_run (memcached_st *);
test_return_t key_setup(memcached_st *memc);
vector<char> return_value;
/* We need to empty the server before we continue the test */
+ bool flush_res= memc.flush();
+ if (flush_res == false)
+ {
+ std::string error_string;
+ ASSERT_TRUE(memc.error(error_string));
+ Error << error_string;
+ }
test_true(memc.flush());
test_true(memc.mget(keys));
static test_return_t cat_test(void *)
{
char buffer[1024];
- snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
+ int length= snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
const char *args[]= { buffer, "foo", 0 };
- memcached_st *memc= memcached(buffer, strlen(buffer));
+ memcached_st *memc= memcached(buffer, length);
test_true(memc);
test_compare(MEMCACHED_SUCCESS,
test_null(memcached_get(memc, test_literal_param("foo"), 0, 0, &rc));
test_compare(MEMCACHED_SUCCESS, rc);
+ snprintf(buffer, sizeof(buffer), "--servers=localhost:%d", int(default_port()));
test_compare(EXIT_SUCCESS, exec_cmdline(executable, args, true));
test_null(memcached_get(memc, test_literal_param("foo"), 0, 0, &rc));
static test_return_t NOT_FOUND_test(void *)
{
char buffer[1024];
- snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
+ int length= snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
const char *args[]= { buffer, "foo", 0 };
- memcached_st *memc= memcached(buffer, strlen(buffer));
- test_true(memc);
+ memcached_st *memc= memcached(buffer, length);
+ ASSERT_TRUE(memc);
test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0));
test_null(memcached_get(memc, test_literal_param("foo"), 0, 0, &rc));
test_compare(MEMCACHED_NOTFOUND, rc);
+ snprintf(buffer, sizeof(buffer), "--servers=localhost:%d", int(default_port()));
test_compare(EXIT_FAILURE, exec_cmdline(executable, args, true));
test_null(memcached_get(memc, test_literal_param("foo"), 0, 0, &rc));
return TEST_SUCCESS;
}
+#if 0
static test_return_t server_test(void *)
{
int fd;
return TEST_SUCCESS;
}
+#endif
test_st memcp_tests[] ={
{"--help", true, help_test },
+#if 0
{"--server_test", true, server_test },
+#endif
{0, 0, 0}
};
static test_return_t FOUND_test(void *)
{
char buffer[1024];
- snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
+ int length= snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
const char *args[]= { buffer, 0 };
- memcached_st *memc= memcached(buffer, strlen(buffer));
+ memcached_st *memc= memcached(buffer, length);
test_true(memc);
test_compare(MEMCACHED_SUCCESS,
test_null(memcached_get(memc, test_literal_param("foo"), 0, 0, &rc));
test_compare(MEMCACHED_SUCCESS, rc);
+ length= snprintf(buffer, sizeof(buffer), "--servers=localhost:%d", int(default_port()));
test_true(exec_cmdline(executable, args, true) <= EXIT_FAILURE);
memcached_free(memc);
static test_return_t exist_test(void *)
{
char buffer[1024];
- snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
+ int length= snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
const char *args[]= { buffer, "foo", 0 };
- memcached_st *memc= memcached(buffer, strlen(buffer));
+ memcached_st *memc= memcached(buffer, length);
test_true(memc);
test_compare(MEMCACHED_SUCCESS,
static test_return_t NOT_FOUND_test(void *)
{
char buffer[1024];
- snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
+ int length= snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
const char *args[]= { buffer, "foo", 0 };
- memcached_st *memc= memcached(buffer, strlen(buffer));
- test_true(memc);
+ memcached_st *memc= memcached(buffer, length);
+ ASSERT_TRUE(memc);
test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0));
static test_return_t check_version(void*)
{
char buffer[1024];
- snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
- memcached_st *memc= memcached(buffer, strlen(buffer));
- test_true(memc);
+ int length= snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
+ memcached_st *memc= memcached(buffer, length);
+ ASSERT_TRUE(memc);
test_return_t result= TEST_SUCCESS;
if (libmemcached_util_version_check(memc, 1, 4, 8) == false)
static test_return_t ping_TEST(void *)
{
char buffer[1024];
- snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
+ snprintf(buffer, sizeof(buffer), "--servers=localhost:%d", int(default_port()));
const char *args[]= { buffer, 0 };
test_compare(EXIT_SUCCESS, exec_cmdline(executable, args, true));
static test_return_t NOT_FOUND_TEST(void *)
{
char buffer[1024];
- snprintf(buffer, sizeof(buffer), "--server=nonexist.libmemcached.org:%d", int(default_port()));
+ snprintf(buffer, sizeof(buffer), "--servers=nonexist.libmemcached.org:%d", int(default_port()));
const char *args[]= { buffer, 0 };
test_compare(EXIT_FAILURE, exec_cmdline(executable, args, true));
test_null(memcached_get(memc, test_literal_param("foo"), 0, 0, &rc));
test_compare(MEMCACHED_SUCCESS, rc);
+ char memrm_buffer[1024];
+ snprintf(memrm_buffer, sizeof(memrm_buffer), "--servers=localhost:%d", int(default_port()));
const char *args[]= { buffer, "foo", 0 };
test_compare(EXIT_SUCCESS, exec_cmdline(executable, args, true));
static test_return_t multiple_NOT_FOUND_TEST(void *)
{
char buffer[1024];
- snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
+ snprintf(buffer, sizeof(buffer), "--servers=localhost:%d", int(default_port()));
const char *args[]= { buffer, "protocols", "foo", "mine", "bar", "dog", "cat", "foo", "mine",
"eye", "for", "the", "to", "not", "know", "what", "I", "should", "be", "doing", 0 };
static test_return_t touch_test(void *)
{
char buffer[1024];
- snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
+ int length= snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
- memcached_st *memc= memcached(buffer, strlen(buffer));
+ memcached_st *memc= memcached(buffer, length);
test_true(memc);
test_compare(MEMCACHED_SUCCESS,
static test_return_t NOT_FOUND_test(void *)
{
char buffer[1024];
- snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
- memcached_st *memc= memcached(buffer, strlen(buffer));
+ int length= snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
+ memcached_st *memc= memcached(buffer, length);
test_true(memc);
test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0));
test_compare(MEMCACHED_NOTFOUND, memcached_exist(memc, test_literal_param("foo")));
- snprintf(buffer, sizeof(buffer), "--servers=localhost:%d", int(default_port()));
+ length= snprintf(buffer, sizeof(buffer), "--servers=localhost:%d", int(default_port()));
const char *args[]= { "--expire=30", buffer, "foo", 0 };
test_compare(EXIT_FAILURE, exec_cmdline(executable, args, true));
static test_return_t check_version(void*)
{
char buffer[1024];
- snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
- memcached_st *memc= memcached(buffer, strlen(buffer));
+ int length= snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
+ memcached_st *memc= memcached(buffer, length);
test_true(memc);
test_return_t result= TEST_SUCCESS;
projects / awesomized / libmemcached / commitdiff
