libmemcached

Merge lp://staging/~posulliv/libmemcached/sol-build-fixes into lp://staging/~tangent-org/libmemcached/trunk

sol-build-fixes
Merge into trunk

Proposed by Padraig O'Sullivan on 2009-07-15

Status:	Merged
Merged at revision:	not available
Proposed branch:	lp://staging/~posulliv/libmemcached/sol-build-fixes
Merge into:	lp://staging/~tangent-org/libmemcached/trunk
Diff against target:	None lines
To merge this branch:	bzr merge lp://staging/~posulliv/libmemcached/sol-build-fixes
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Libmemcached-developers		2009-07-15	Pending
Review via email: mp+8842@code.staging.launchpad.net

Revision history for this message

Padraig O'Sullivan (posulliv) wrote on 2009-07-15:

Contains some small fixes for solaris builds.

-Padraig

lp://staging/~posulliv/libmemcached/sol-build-fixes updated on 2009-07-15

565. By Padraig O'Sullivan on 2009-07-15: Updated the ChangeLog and the .pod document indicating the changes I made to
the memcached_get and memcached_get_by_key API calls.

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Monty Taylor

Padraig O'Sullivan

libmemcached

Merge lp://staging/~posulliv/libmemcached/sol-build-fixes into lp://staging/~tangent-org/libmemcached/trunk

Commit message

Description of the change

Preview Diff

Subscribers

 === modified file 'libmemcached/common.h'
 --- libmemcached/common.h	2009-07-08 13:38:34 +0000
 +++ libmemcached/common.h	2009-07-15 18:26:30 +0000
@@ -136,7 +136,7 @@
  LIBMEMCACHED_LOCAL
  memcached_return memcached_key_test(const char **keys, size_t *key_length,
--                                    unsigned int number_of_keys);
++                                    size_t number_of_keys);
  LIBMEMCACHED_LOCAL
 === modified file 'libmemcached/memcached.hh'
 --- libmemcached/memcached.hh	2009-07-15 09:05:00 +0000
 +++ libmemcached/memcached.hh	2009-07-15 18:26:30 +0000
@@ -109,7 +109,7 @@
      if (!real_keys.empty())
+     {
        memcached_return rc= memcached_mget(&memc, &real_keys[0], &key_len[0],
--                                          static_cast<unsigned int>(real_keys.size()));
++                                          real_keys.size());
        return (rc == MEMCACHED_SUCCESS);
+     }
 === modified file 'libmemcached/memcached_get.c'
 --- libmemcached/memcached_get.c	2009-07-08 13:38:34 +0000
 +++ libmemcached/memcached_get.c	2009-07-15 18:26:30 +0000
@@ -103,7 +103,7 @@
  memcached_return memcached_mget(memcached_st *ptr,
                                  const char **keys, size_t *key_length,
--                                unsigned int number_of_keys)
++                                size_t number_of_keys)
+ {
    return memcached_mget_by_key(ptr, NULL, 0, keys, key_length, number_of_keys);
+ }
@@ -112,14 +112,14 @@
                                             unsigned int master_server_key,
                                             bool is_master_key_set,
                                             const char **keys, size_t *key_length,
--                                           unsigned int number_of_keys);
++                                           size_t number_of_keys);
  memcached_return memcached_mget_by_key(memcached_st *ptr,
                                         const char *master_key,
                                         size_t master_key_length,
                                         const char **keys,
                                         size_t *key_length,
--                                       unsigned int number_of_keys)
++                                       size_t number_of_keys)
+ {
    unsigned int x;
    memcached_return rc= MEMCACHED_NOTFOUND;
@@ -260,7 +260,7 @@
                                             unsigned int master_server_key,
                                             bool is_master_key_set,
                                             const char **keys, size_t *key_length,
--                                           unsigned int number_of_keys)
++                                           size_t number_of_keys)
+ {
    memcached_return rc= MEMCACHED_NOTFOUND;
    uint32_t x;
@@ -361,7 +361,7 @@
  static memcached_return replication_binary_mget(memcached_st *ptr,
                                               uint32_t* hash, bool* dead_servers,
                                               const char **keys, size_t *key_length,
--                                             unsigned int number_of_keys)
++                                             size_t number_of_keys)
+ {
    memcached_return rc= MEMCACHED_NOTFOUND;
    uint32_t x;
@@ -460,7 +460,7 @@
                                             unsigned int master_server_key,
                                             bool is_master_key_set,
                                             const char **keys, size_t *key_length,
--                                           unsigned int number_of_keys)
++                                           size_t number_of_keys)
+ {
    memcached_return rc;
 === modified file 'libmemcached/memcached_get.h'
 --- libmemcached/memcached_get.h	2009-07-08 13:38:34 +0000
 +++ libmemcached/memcached_get.h	2009-07-15 18:26:30 +0000
@@ -24,7 +24,7 @@
  LIBMEMCACHED_API
  memcached_return memcached_mget(memcached_st *ptr,
                                  const char **keys, size_t *key_length,
--                                unsigned int number_of_keys);
++                                size_t number_of_keys);
  LIBMEMCACHED_API
  char *memcached_get_by_key(memcached_st *ptr,
@@ -40,7 +40,7 @@
                                         master_key_length,
                                         const char **keys,
                                         size_t *key_length,
--                                       unsigned int number_of_keys);
++                                       size_t number_of_keys);
  LIBMEMCACHED_API
  char *memcached_fetch(memcached_st *ptr,
 === modified file 'libmemcached/memcached_key.c'
 --- libmemcached/memcached_key.c	2009-07-08 13:38:34 +0000
 +++ libmemcached/memcached_key.c	2009-07-15 18:26:30 +0000
@@ -1,7 +1,7 @@
  #include "common.h"
  memcached_return memcached_key_test(const char **keys, size_t *key_length,
--                                    unsigned int number_of_keys)
++                                    size_t number_of_keys)
+ {
    uint32_t x;
    memcached_return rc;
 === added file 'm4/lib-ld.m4'
 --- m4/lib-ld.m4	1970-01-01 00:00:00 +0000
 +++ m4/lib-ld.m4	2009-07-16 02:58:56 +0000
@@ -0,0 +1,110 @@
++# lib-ld.m4 serial 3 (gettext-0.13)
++dnl Copyright (C) 1996-2003 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl Subroutines of libtool.m4,
++dnl with replacements s/AC_/AC_LIB/ and s/lt_cv/acl_cv/ to avoid collision
++dnl with libtool.m4.
++
++dnl From libtool-1.4. Sets the variable with_gnu_ld to yes or no.
++AC_DEFUN([AC_LIB_PROG_LD_GNU],
++[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], acl_cv_prog_gnu_ld,
++[# I'd rather use --version here, but apparently some GNU ld's only accept -v.
++case `$LD -v 2>&1 </dev/null` in
++*GNU* | *'with BFD'*)
++  acl_cv_prog_gnu_ld=yes ;;
++*)
++  acl_cv_prog_gnu_ld=no ;;
++esac])
++with_gnu_ld=$acl_cv_prog_gnu_ld
++])
++
++dnl From libtool-1.4. Sets the variable LD.
++AC_DEFUN([AC_LIB_PROG_LD],
++[AC_ARG_WITH(gnu-ld,
++[  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]],
++test "$withval" = no || with_gnu_ld=yes, with_gnu_ld=no)
++AC_REQUIRE([AC_PROG_CC])dnl
++AC_REQUIRE([AC_CANONICAL_HOST])dnl
++# Prepare PATH_SEPARATOR.
++# The user is always right.
++if test "${PATH_SEPARATOR+set}" != set; then
++  echo "#! /bin/sh" >conf$$.sh
++  echo  "exit 0"   >>conf$$.sh
++  chmod +x conf$$.sh
++  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
++    PATH_SEPARATOR=';'
++  else
++    PATH_SEPARATOR=:
++  fi
++  rm -f conf$$.sh
++fi
++ac_prog=ld
++if test "$GCC" = yes; then
++  # Check if gcc -print-prog-name=ld gives a path.
++  AC_MSG_CHECKING([for ld used by GCC])
++  case $host in
++  *-*-mingw*)
++    # gcc leaves a trailing carriage return which upsets mingw
++    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
++  *)
++    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
++  esac
++  case $ac_prog in
++    # Accept absolute paths.
++    [[\\/]* | [A-Za-z]:[\\/]*)]
++      [re_direlt='/[^/][^/]*/\.\./']
++      # Canonicalize the path of ld
++      ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
++      while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
++	ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
++      done
++      test -z "$LD" && LD="$ac_prog"
++      ;;
++  "")
++    # If it fails, then pretend we aren't using GCC.
++    ac_prog=ld
++    ;;
++  *)
++    # If it is relative, then search for the first ld in PATH.
++    with_gnu_ld=unknown
++    ;;
++  esac
++elif test "$with_gnu_ld" = yes; then
++  AC_MSG_CHECKING([for GNU ld])
++else
++  AC_MSG_CHECKING([for non-GNU ld])
++fi
++AC_CACHE_VAL(acl_cv_path_LD,
++[if test -z "$LD"; then
++  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
++  for ac_dir in $PATH; do
++    test -z "$ac_dir" && ac_dir=.
++    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
++      acl_cv_path_LD="$ac_dir/$ac_prog"
++      # Check to see if the program is GNU ld.  I'd rather use --version,
++      # but apparently some GNU ld's only accept -v.
++      # Break only if it was the GNU/non-GNU ld that we prefer.
++      case `"$acl_cv_path_LD" -v 2>&1 < /dev/null` in
++      *GNU* | *'with BFD'*)
++	test "$with_gnu_ld" != no && break ;;
++      *)
++	test "$with_gnu_ld" != yes && break ;;
++      esac
++    fi
++  done
++  IFS="$ac_save_ifs"
++else
++  acl_cv_path_LD="$LD" # Let the user override the test with a path.
++fi])
++LD="$acl_cv_path_LD"
++if test -n "$LD"; then
++  AC_MSG_RESULT($LD)
++else
++  AC_MSG_RESULT(no)
++fi
++test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])
++AC_LIB_PROG_LD_GNU
++])
 === added file 'm4/lib-link.m4'
 --- m4/lib-link.m4	1970-01-01 00:00:00 +0000
 +++ m4/lib-link.m4	2009-07-16 02:58:56 +0000
@@ -0,0 +1,767 @@
++# lib-link.m4 serial 18 (gettext-0.18)
++dnl Copyright (C) 2001-2009 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Bruno Haible.
++
++AC_PREREQ([2.54])
++
++dnl AC_LIB_LINKFLAGS(name [, dependencies]) searches for libname and
++dnl the libraries corresponding to explicit and implicit dependencies.
++dnl Sets and AC_SUBSTs the LIB${NAME} and LTLIB${NAME} variables and
++dnl augments the CPPFLAGS variable.
++dnl Sets and AC_SUBSTs the LIB${NAME}_PREFIX variable to nonempty if libname
++dnl was found in ${LIB${NAME}_PREFIX}/$acl_libdirstem.
++AC_DEFUN([AC_LIB_LINKFLAGS],
++[
++  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
++  AC_REQUIRE([AC_LIB_RPATH])
++  pushdef([Name],[translit([$1],[./-], [___])])
++  pushdef([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
++                                [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
++  AC_CACHE_CHECK([how to link with lib[]$1], [ac_cv_lib[]Name[]_libs], [
++    AC_LIB_LINKFLAGS_BODY([$1], [$2])
++    ac_cv_lib[]Name[]_libs="$LIB[]NAME"
++    ac_cv_lib[]Name[]_ltlibs="$LTLIB[]NAME"
++    ac_cv_lib[]Name[]_cppflags="$INC[]NAME"
++    ac_cv_lib[]Name[]_prefix="$LIB[]NAME[]_PREFIX"
++  ])
++  LIB[]NAME="$ac_cv_lib[]Name[]_libs"
++  LTLIB[]NAME="$ac_cv_lib[]Name[]_ltlibs"
++  INC[]NAME="$ac_cv_lib[]Name[]_cppflags"
++  LIB[]NAME[]_PREFIX="$ac_cv_lib[]Name[]_prefix"
++  AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)
++  AC_SUBST([LIB]NAME)
++  AC_SUBST([LTLIB]NAME)
++  AC_SUBST([LIB]NAME[_PREFIX])
++  dnl Also set HAVE_LIB[]NAME so that AC_LIB_HAVE_LINKFLAGS can reuse the
++  dnl results of this search when this library appears as a dependency.
++  HAVE_LIB[]NAME=yes
++  popdef([NAME])
++  popdef([Name])
++])
++
++dnl AC_LIB_HAVE_LINKFLAGS(name, dependencies, includes, testcode, [system])
++dnl searches for libname and the libraries corresponding to explicit and
++dnl implicit dependencies, together with the specified include files and
++dnl the ability to compile and link the specified testcode. If found, it
++dnl sets and AC_SUBSTs HAVE_LIB${NAME}=yes and the LIB${NAME} and
++dnl LTLIB${NAME} variables and augments the CPPFLAGS variable, and
++dnl #defines HAVE_LIB${NAME} to 1. Otherwise, it sets and AC_SUBSTs
++dnl HAVE_LIB${NAME}=no and LIB${NAME} and LTLIB${NAME} to empty.
++dnl Sets and AC_SUBSTs the LIB${NAME}_PREFIX variable to nonempty if libname
++dnl was found in ${LIB${NAME}_PREFIX}/$acl_libdirstem.
++AC_DEFUN([AC_LIB_HAVE_LINKFLAGS],
++[
++  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
++  AC_REQUIRE([AC_LIB_RPATH])
++  pushdef([Name],[translit([$1],[./-], [___])])
++  pushdef([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
++                                [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
++
++  dnl Search for lib[]Name and define LIB[]NAME, LTLIB[]NAME and INC[]NAME
++  dnl accordingly.
++  AC_LIB_LINKFLAGS_BODY([$1], [$2], [$5])
++
++  dnl Add $INC[]NAME to CPPFLAGS before performing the following checks,
++  dnl because if the user has installed lib[]Name and not disabled its use
++  dnl via --without-lib[]Name-prefix, he wants to use it.
++  ac_save_CPPFLAGS="$CPPFLAGS"
++  AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)
++
++  AC_CACHE_CHECK([for lib[]$1], [ac_cv_lib[]Name], [
++    ac_save_LIBS="$LIBS"
++    LIBS="$LIBS $LIB[]NAME"
++    AC_TRY_LINK([$3], [$4], [ac_cv_lib[]Name=yes], [ac_cv_lib[]Name=no])
++    LIBS="$ac_save_LIBS"
++  ])
++  if test "$ac_cv_lib[]Name" = yes; then
++    HAVE_LIB[]NAME=yes
++    AC_DEFINE([HAVE_LIB]NAME, 1, [Define if you have the $1 library.])
++    AC_MSG_CHECKING([how to link with lib[]$1])
++    AC_MSG_RESULT([$LIB[]NAME])
++  else
++    HAVE_LIB[]NAME=no
++    dnl If $LIB[]NAME didn't lead to a usable library, we don't need
++    dnl $INC[]NAME either.
++    CPPFLAGS="$ac_save_CPPFLAGS"
++    LIB[]NAME=
++    LTLIB[]NAME=
++    LIB[]NAME[]_PREFIX=
++  fi
++  AC_SUBST([HAVE_LIB]NAME)
++  AC_SUBST([LIB]NAME)
++  AC_SUBST([LTLIB]NAME)
++  AC_SUBST([LIB]NAME[_PREFIX])
++  popdef([NAME])
++  popdef([Name])
++])
++
++dnl Determine the platform dependent parameters needed to use rpath:
++dnl   acl_libext,
++dnl   acl_shlibext,
++dnl   acl_hardcode_libdir_flag_spec,
++dnl   acl_hardcode_libdir_separator,
++dnl   acl_hardcode_direct,
++dnl   acl_hardcode_minus_L.
++AC_DEFUN([AC_LIB_RPATH],
++[
++  dnl Tell automake >= 1.10 to complain if config.rpath is missing.
++  m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([config.rpath])])
++  AC_REQUIRE([AC_PROG_CC])                dnl we use $CC, $GCC, $LDFLAGS
++  AC_REQUIRE([AC_LIB_PROG_LD])            dnl we use $LD, $with_gnu_ld
++  AC_REQUIRE([AC_CANONICAL_HOST])         dnl we use $host
++  AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT]) dnl we use $ac_aux_dir
++  AC_CACHE_CHECK([for shared library run path origin], [acl_cv_rpath], [
++    CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \
++    ${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh
++    . ./conftest.sh
++    rm -f ./conftest.sh
++    acl_cv_rpath=done
++  ])
++  wl="$acl_cv_wl"
++  acl_libext="$acl_cv_libext"
++  acl_shlibext="$acl_cv_shlibext"
++  acl_libname_spec="$acl_cv_libname_spec"
++  acl_library_names_spec="$acl_cv_library_names_spec"
++  acl_hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec"
++  acl_hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator"
++  acl_hardcode_direct="$acl_cv_hardcode_direct"
++  acl_hardcode_minus_L="$acl_cv_hardcode_minus_L"
++  dnl Determine whether the user wants rpath handling at all.
++  AC_ARG_ENABLE([rpath],
++    [  --disable-rpath         do not hardcode runtime library paths],
++    :, enable_rpath=yes)
++])
++
++dnl AC_LIB_FROMPACKAGE(name, package)
++dnl declares that libname comes from the given package. The configure file
++dnl will then not have a --with-libname-prefix option but a
++dnl --with-package-prefix option. Several libraries can come from the same
++dnl package. This declaration must occur before an AC_LIB_LINKFLAGS or similar
++dnl macro call that searches for libname.
++AC_DEFUN([AC_LIB_FROMPACKAGE],
++[
++  pushdef([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
++                                [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
++  define([acl_frompackage_]NAME, [$2])
++  popdef([NAME])
++  pushdef([PACK],[$2])
++  pushdef([PACKUP],[translit(PACK,[abcdefghijklmnopqrstuvwxyz./-],
++                                  [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
++  define([acl_libsinpackage_]PACKUP,
++    m4_ifdef([acl_libsinpackage_]PACKUP, [acl_libsinpackage_]PACKUP[[, ]],)[lib$1])
++  popdef([PACKUP])
++  popdef([PACK])
++])
++
++dnl AC_LIB_LINKFLAGS_BODY(name [, dependencies, system]) searches for
++dnl libname and the libraries corresponding to explicit and implicit
++dnl dependencies.
++dnl Sets the LIB${NAME}, LTLIB${NAME} and INC${NAME} variables.
++dnl Also, sets the LIB${NAME}_PREFIX variable to nonempty if libname was found
++dnl in ${LIB${NAME}_PREFIX}/$acl_libdirstem.
++dnl If system==system, -isystem is used instead of -I
++AC_DEFUN([AC_LIB_LINKFLAGS_BODY],
++[
++  AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])
++  pushdef([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
++                                [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
++  pushdef([PACK],[m4_ifdef([acl_frompackage_]NAME, [acl_frompackage_]NAME, lib[$1])])
++  pushdef([PACKUP],[translit(PACK,[abcdefghijklmnopqrstuvwxyz./-],
++                                  [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
++  pushdef([PACKLIBS],[m4_ifdef([acl_frompackage_]NAME, [acl_libsinpackage_]PACKUP, lib[$1])])
++  dnl Autoconf >= 2.61 supports dots in --with options.
++  pushdef([P_A_C_K],[m4_if(m4_version_compare(m4_defn([m4_PACKAGE_VERSION]),[2.61]),[-1],[translit(PACK,[.],[_])],PACK)])
++  dnl By default, look in $includedir and $libdir.
++  use_additional=yes
++  if test "x$GCC" = "xyes" -a "x$3" = "xsystem"
++  then
++    i_system="-isystem "
++  else
++    i_system="-I"
++  fi
++
++  AC_LIB_WITH_FINAL_PREFIX([
++    eval additional_includedir=\"$includedir\"
++    eval additional_libdir=\"$libdir\"
++  ])
++  AC_ARG_WITH(P_A_C_K[-prefix],
++[[  --with-]]P_A_C_K[[-prefix[=DIR]  search for ]PACKLIBS[ in DIR/include and DIR/lib
++  --without-]]P_A_C_K[[-prefix     don't search for ]PACKLIBS[ in includedir and libdir]],
++[
++    if test "X$withval" = "Xno"; then
++      use_additional=no
++    else
++      if test "X$withval" = "X"; then
++        AC_LIB_WITH_FINAL_PREFIX([
++          eval additional_includedir=\"$includedir\"
++          eval additional_libdir=\"$libdir\"
++        ])
++      else
++        additional_includedir="$withval/include"
++        additional_libdir="$withval/$acl_libdirstem"
++        if test "$acl_libdirstem2" != "$acl_libdirstem" \
++           && ! test -d "$withval/$acl_libdirstem"; then
++          additional_libdir="$withval/$acl_libdirstem2"
++        fi
++      fi
++    fi
++])
++  dnl Search the library and its dependencies in $additional_libdir and
++  dnl $LDFLAGS. Using breadth-first-seach.
++  LIB[]NAME=
++  LTLIB[]NAME=
++  INC[]NAME=
++  LIB[]NAME[]_PREFIX=
++  rpathdirs=
++  ltrpathdirs=
++  names_already_handled=
++  names_next_round='$1 $2'
++  while test -n "$names_next_round"; do
++    names_this_round="$names_next_round"
++    names_next_round=
++    for name in $names_this_round; do
++      already_handled=
++      for n in $names_already_handled; do
++        if test "$n" = "$name"; then
++          already_handled=yes
++          break
++        fi
++      done
++      if test -z "$already_handled"; then
++        names_already_handled="$names_already_handled $name"
++        dnl See if it was already located by an earlier AC_LIB_LINKFLAGS
++        dnl or AC_LIB_HAVE_LINKFLAGS call.
++        uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'`
++        eval value=\"\$HAVE_LIB$uppername\"
++        if test -n "$value"; then
++          if test "$value" = yes; then
++            eval value=\"\$LIB$uppername\"
++            test -z "$value" || LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$value"
++            eval value=\"\$LTLIB$uppername\"
++            test -z "$value" || LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$value"
++          else
++            dnl An earlier call to AC_LIB_HAVE_LINKFLAGS has determined
++            dnl that this library doesn't exist. So just drop it.
++            :
++          fi
++        else
++          dnl Search the library lib$name in $additional_libdir and $LDFLAGS
++          dnl and the already constructed $LIBNAME/$LTLIBNAME.
++          found_dir=
++          found_la=
++          found_so=
++          found_a=
++          eval libname=\"$acl_libname_spec\"    # typically: libname=lib$name
++          if test -n "$acl_shlibext"; then
++            shrext=".$acl_shlibext"             # typically: shrext=.so
++          else
++            shrext=
++          fi
++          if test $use_additional = yes; then
++            dir="$additional_libdir"
++            dnl The same code as in the loop below:
++            dnl First look for a shared library.
++            if test -n "$acl_shlibext"; then
++              if test -f "$dir/$libname$shrext"; then
++                found_dir="$dir"
++                found_so="$dir/$libname$shrext"
++              else
++                if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
++                  ver=`(cd "$dir" && \
++                        for f in "$libname$shrext".*; do echo "$f"; done \
++                        | sed -e "s,^$libname$shrext\\\\.,," \
++                        | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
++                        | sed 1q ) 2>/dev/null`
++                  if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
++                    found_dir="$dir"
++                    found_so="$dir/$libname$shrext.$ver"
++                  fi
++                else
++                  eval library_names=\"$acl_library_names_spec\"
++                  for f in $library_names; do
++                    if test -f "$dir/$f"; then
++                      found_dir="$dir"
++                      found_so="$dir/$f"
++                      break
++                    fi
++                  done
++                fi
++              fi
++            fi
++            dnl Then look for a static library.
++            if test "X$found_dir" = "X"; then
++              if test -f "$dir/$libname.$acl_libext"; then
++                found_dir="$dir"
++                found_a="$dir/$libname.$acl_libext"
++              fi
++            fi
++            if test "X$found_dir" != "X"; then
++              if test -f "$dir/$libname.la"; then
++                found_la="$dir/$libname.la"
++              fi
++            fi
++          fi
++          if test "X$found_dir" = "X"; then
++            for x in $LDFLAGS $LTLIB[]NAME; do
++              AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
++              case "$x" in
++                -L*)
++                  dir=`echo "X$x" | sed -e 's/^X-L//'`
++                  dnl First look for a shared library.
++                  if test -n "$acl_shlibext"; then
++                    if test -f "$dir/$libname$shrext"; then
++                      found_dir="$dir"
++                      found_so="$dir/$libname$shrext"
++                    else
++                      if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
++                        ver=`(cd "$dir" && \
++                              for f in "$libname$shrext".*; do echo "$f"; done \
++                              | sed -e "s,^$libname$shrext\\\\.,," \
++                              | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
++                              | sed 1q ) 2>/dev/null`
++                        if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
++                          found_dir="$dir"
++                          found_so="$dir/$libname$shrext.$ver"
++                        fi
++                      else
++                        eval library_names=\"$acl_library_names_spec\"
++                        for f in $library_names; do
++                          if test -f "$dir/$f"; then
++                            found_dir="$dir"
++                            found_so="$dir/$f"
++                            break
++                          fi
++                        done
++                      fi
++                    fi
++                  fi
++                  dnl Then look for a static library.
++                  if test "X$found_dir" = "X"; then
++                    if test -f "$dir/$libname.$acl_libext"; then
++                      found_dir="$dir"
++                      found_a="$dir/$libname.$acl_libext"
++                    fi
++                  fi
++                  if test "X$found_dir" != "X"; then
++                    if test -f "$dir/$libname.la"; then
++                      found_la="$dir/$libname.la"
++                    fi
++                  fi
++                  ;;
++              esac
++              if test "X$found_dir" != "X"; then
++                break
++              fi
++            done
++          fi
++          if test "X$found_dir" != "X"; then
++            dnl Found the library.
++            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$found_dir -l$name"
++            if test "X$found_so" != "X"; then
++              dnl Linking with a shared library. We attempt to hardcode its
++              dnl directory into the executable's runpath, unless it's the
++              dnl standard /usr/lib.
++              if test "$enable_rpath" = no \
++                 || test "X$found_dir" = "X/usr/$acl_libdirstem" \
++                 || test "X$found_dir" = "X/usr/$acl_libdirstem2"; then
++                dnl No hardcoding is needed.
++                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
++              else
++                dnl Use an explicit option to hardcode DIR into the resulting
++                dnl binary.
++                dnl Potentially add DIR to ltrpathdirs.
++                dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.
++                haveit=
++                for x in $ltrpathdirs; do
++                  if test "X$x" = "X$found_dir"; then
++                    haveit=yes
++                    break
++                  fi
++                done
++                if test -z "$haveit"; then
++                  ltrpathdirs="$ltrpathdirs $found_dir"
++                fi
++                dnl The hardcoding into $LIBNAME is system dependent.
++                if test "$acl_hardcode_direct" = yes; then
++                  dnl Using DIR/libNAME.so during linking hardcodes DIR into the
++                  dnl resulting binary.
++                  LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
++                else
++                  if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
++                    dnl Use an explicit option to hardcode DIR into the resulting
++                    dnl binary.
++                    LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
++                    dnl Potentially add DIR to rpathdirs.
++                    dnl The rpathdirs will be appended to $LIBNAME at the end.
++                    haveit=
++                    for x in $rpathdirs; do
++                      if test "X$x" = "X$found_dir"; then
++                        haveit=yes
++                        break
++                      fi
++                    done
++                    if test -z "$haveit"; then
++                      rpathdirs="$rpathdirs $found_dir"
++                    fi
++                  else
++                    dnl Rely on "-L$found_dir".
++                    dnl But don't add it if it's already contained in the LDFLAGS
++                    dnl or the already constructed $LIBNAME
++                    haveit=
++                    for x in $LDFLAGS $LIB[]NAME; do
++                      AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
++                      if test "X$x" = "X-L$found_dir"; then
++                        haveit=yes
++                        break
++                      fi
++                    done
++                    if test -z "$haveit"; then
++                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir"
++                    fi
++                    if test "$acl_hardcode_minus_L" != no; then
++                      dnl FIXME: Not sure whether we should use
++                      dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"
++                      dnl here.
++                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
++                    else
++                      dnl We cannot use $acl_hardcode_runpath_var and LD_RUN_PATH
++                      dnl here, because this doesn't fit in flags passed to the
++                      dnl compiler. So give up. No hardcoding. This affects only
++                      dnl very old systems.
++                      dnl FIXME: Not sure whether we should use
++                      dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"
++                      dnl here.
++                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"
++                    fi
++                  fi
++                fi
++              fi
++            else
++              if test "X$found_a" != "X"; then
++                dnl Linking with a static library.
++                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_a"
++              else
++                dnl We shouldn't come here, but anyway it's good to have a
++                dnl fallback.
++                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir -l$name"
++              fi
++            fi
++            dnl Assume the include files are nearby.
++            additional_includedir=
++            case "$found_dir" in
++              */$acl_libdirstem | */$acl_libdirstem/)
++                basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'`
++                if test "$name" = '$1'; then
++                  LIB[]NAME[]_PREFIX="$basedir"
++                fi
++                additional_includedir="$basedir/include"
++                ;;
++              */$acl_libdirstem2 | */$acl_libdirstem2/)
++                basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem2/"'*$,,'`
++                if test "$name" = '$1'; then
++                  LIB[]NAME[]_PREFIX="$basedir"
++                fi
++                additional_includedir="$basedir/include"
++                ;;
++            esac
++            if test "X$additional_includedir" != "X"; then
++              dnl Potentially add $additional_includedir to $INCNAME.
++              dnl But don't add it
++              dnl   1. if it's the standard /usr/include,
++              dnl   2. if it's /usr/local/include and we are using GCC on Linux,
++              dnl   3. if it's already present in $CPPFLAGS or the already
++              dnl      constructed $INCNAME,
++              dnl   4. if it doesn't exist as a directory.
++              if test "X$additional_includedir" != "X/usr/include"; then
++                haveit=
++                if test "X$additional_includedir" = "X/usr/local/include"; then
++                  if test -n "$GCC"; then
++                    case $host_os in
++                      linux* | gnu* | k*bsd*-gnu) haveit=yes;;
++                    esac
++                  fi
++                fi
++                if test -z "$haveit"; then
++                  for x in $CPPFLAGS $INC[]NAME; do
++                    AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
++                    if test "X$x" = "X${i_system}$additional_includedir"; then
++                      haveit=yes
++                      break
++                    fi
++                  done
++                  if test -z "$haveit"; then
++                    if test -d "$additional_includedir"; then
++                      dnl Really add $additional_includedir to $INCNAME.
++                      INC[]NAME="${INC[]NAME}${INC[]NAME:+ }${i_system}$additional_includedir"
++                    fi
++                  fi
++                fi
++              fi
++            fi
++            dnl Look for dependencies.
++            if test -n "$found_la"; then
++              dnl Read the .la file. It defines the variables
++              dnl dlname, library_names, old_library, dependency_libs, current,
++              dnl age, revision, installed, dlopen, dlpreopen, libdir.
++              save_libdir="$libdir"
++              case "$found_la" in
++                */* | *\\*) . "$found_la" ;;
++                *) . "./$found_la" ;;
++              esac
++              libdir="$save_libdir"
++              dnl We use only dependency_libs.
++              for dep in $dependency_libs; do
++                case "$dep" in
++                  -L*)
++                    additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
++                    dnl Potentially add $additional_libdir to $LIBNAME and $LTLIBNAME.
++                    dnl But don't add it
++                    dnl   1. if it's the standard /usr/lib,
++                    dnl   2. if it's /usr/local/lib and we are using GCC on Linux,
++                    dnl   3. if it's already present in $LDFLAGS or the already
++                    dnl      constructed $LIBNAME,
++                    dnl   4. if it doesn't exist as a directory.
++                    if test "X$additional_libdir" != "X/usr/$acl_libdirstem" \
++                       && test "X$additional_libdir" != "X/usr/$acl_libdirstem2"; then
++                      haveit=
++                      if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem" \
++                         || test "X$additional_libdir" = "X/usr/local/$acl_libdirstem2"; then
++                        if test -n "$GCC"; then
++                          case $host_os in
++                            linux* | gnu* | k*bsd*-gnu) haveit=yes;;
++                          esac
++                        fi
++                      fi
++                      if test -z "$haveit"; then
++                        haveit=
++                        for x in $LDFLAGS $LIB[]NAME; do
++                          AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
++                          if test "X$x" = "X-L$additional_libdir"; then
++                            haveit=yes
++                            break
++                          fi
++                        done
++                        if test -z "$haveit"; then
++                          if test -d "$additional_libdir"; then
++                            dnl Really add $additional_libdir to $LIBNAME.
++                            LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$additional_libdir"
++                          fi
++                        fi
++                        haveit=
++                        for x in $LDFLAGS $LTLIB[]NAME; do
++                          AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
++                          if test "X$x" = "X-L$additional_libdir"; then
++                            haveit=yes
++                            break
++                          fi
++                        done
++                        if test -z "$haveit"; then
++                          if test -d "$additional_libdir"; then
++                            dnl Really add $additional_libdir to $LTLIBNAME.
++                            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$additional_libdir"
++                          fi
++                        fi
++                      fi
++                    fi
++                    ;;
++                  -R*)
++                    dir=`echo "X$dep" | sed -e 's/^X-R//'`
++                    if test "$enable_rpath" != no; then
++                      dnl Potentially add DIR to rpathdirs.
++                      dnl The rpathdirs will be appended to $LIBNAME at the end.
++                      haveit=
++                      for x in $rpathdirs; do
++                        if test "X$x" = "X$dir"; then
++                          haveit=yes
++                          break
++                        fi
++                      done
++                      if test -z "$haveit"; then
++                        rpathdirs="$rpathdirs $dir"
++                      fi
++                      dnl Potentially add DIR to ltrpathdirs.
++                      dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.
++                      haveit=
++                      for x in $ltrpathdirs; do
++                        if test "X$x" = "X$dir"; then
++                          haveit=yes
++                          break
++                        fi
++                      done
++                      if test -z "$haveit"; then
++                        ltrpathdirs="$ltrpathdirs $dir"
++                      fi
++                    fi
++                    ;;
++                  -l*)
++                    dnl Handle this in the next round.
++                    names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`
++                    ;;
++                  *.la)
++                    dnl Handle this in the next round. Throw away the .la's
++                    dnl directory; it is already contained in a preceding -L
++                    dnl option.
++                    names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
++                    ;;
++                  *)
++                    dnl Most likely an immediate library name.
++                    LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$dep"
++                    LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$dep"
++                    ;;
++                esac
++              done
++            fi
++          else
++            dnl Didn't find the library; assume it is in the system directories
++            dnl known to the linker and runtime loader. (All the system
++            dnl directories known to the linker should also be known to the
++            dnl runtime loader, otherwise the system is severely misconfigured.)
++            LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"
++            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-l$name"
++          fi
++        fi
++      fi
++    done
++  done
++  if test "X$rpathdirs" != "X"; then
++    if test -n "$acl_hardcode_libdir_separator"; then
++      dnl Weird platform: only the last -rpath option counts, the user must
++      dnl pass all path elements in one option. We can arrange that for a
++      dnl single library, but not when more than one $LIBNAMEs are used.
++      alldirs=
++      for found_dir in $rpathdirs; do
++        alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir"
++      done
++      dnl Note: acl_hardcode_libdir_flag_spec uses $libdir and $wl.
++      acl_save_libdir="$libdir"
++      libdir="$alldirs"
++      eval flag=\"$acl_hardcode_libdir_flag_spec\"
++      libdir="$acl_save_libdir"
++      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"
++    else
++      dnl The -rpath options are cumulative.
++      for found_dir in $rpathdirs; do
++        acl_save_libdir="$libdir"
++        libdir="$found_dir"
++        eval flag=\"$acl_hardcode_libdir_flag_spec\"
++        libdir="$acl_save_libdir"
++        LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"
++      done
++    fi
++  fi
++  if test "X$ltrpathdirs" != "X"; then
++    dnl When using libtool, the option that works for both libraries and
++    dnl executables is -R. The -R options are cumulative.
++    for found_dir in $ltrpathdirs; do
++      LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-R$found_dir"
++    done
++  fi
++  popdef([P_A_C_K])
++  popdef([PACKLIBS])
++  popdef([PACKUP])
++  popdef([PACK])
++  popdef([NAME])
++])
++
++dnl AC_LIB_APPENDTOVAR(VAR, CONTENTS) appends the elements of CONTENTS to VAR,
++dnl unless already present in VAR.
++dnl Works only for CPPFLAGS, not for LIB* variables because that sometimes
++dnl contains two or three consecutive elements that belong together.
++AC_DEFUN([AC_LIB_APPENDTOVAR],
++[
++  for element in [$2]; do
++    haveit=
++    for x in $[$1]; do
++      AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
++      if test "X$x" = "X$element"; then
++        haveit=yes
++        break
++      fi
++    done
++    if test -z "$haveit"; then
++      [$1]="${[$1]}${[$1]:+ }$element"
++    fi
++  done
++])
++
++dnl For those cases where a variable contains several -L and -l options
++dnl referring to unknown libraries and directories, this macro determines the
++dnl necessary additional linker options for the runtime path.
++dnl AC_LIB_LINKFLAGS_FROM_LIBS([LDADDVAR], [LIBSVALUE], [USE-LIBTOOL])
++dnl sets LDADDVAR to linker options needed together with LIBSVALUE.
++dnl If USE-LIBTOOL evaluates to non-empty, linking with libtool is assumed,
++dnl otherwise linking without libtool is assumed.
++AC_DEFUN([AC_LIB_LINKFLAGS_FROM_LIBS],
++[
++  AC_REQUIRE([AC_LIB_RPATH])
++  AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])
++  $1=
++  if test "$enable_rpath" != no; then
++    if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
++      dnl Use an explicit option to hardcode directories into the resulting
++      dnl binary.
++      rpathdirs=
++      next=
++      for opt in $2; do
++        if test -n "$next"; then
++          dir="$next"
++          dnl No need to hardcode the standard /usr/lib.
++          if test "X$dir" != "X/usr/$acl_libdirstem" \
++             && test "X$dir" != "X/usr/$acl_libdirstem2"; then
++            rpathdirs="$rpathdirs $dir"
++          fi
++          next=
++        else
++          case $opt in
++            -L) next=yes ;;
++            -L*) dir=`echo "X$opt" | sed -e 's,^X-L,,'`
++                 dnl No need to hardcode the standard /usr/lib.
++                 if test "X$dir" != "X/usr/$acl_libdirstem" \
++                    && test "X$dir" != "X/usr/$acl_libdirstem2"; then
++                   rpathdirs="$rpathdirs $dir"
++                 fi
++                 next= ;;
++            *) next= ;;
++          esac
++        fi
++      done
++      if test "X$rpathdirs" != "X"; then
++        if test -n ""$3""; then
++          dnl libtool is used for linking. Use -R options.
++          for dir in $rpathdirs; do
++            $1="${$1}${$1:+ }-R$dir"
++          done
++        else
++          dnl The linker is used for linking directly.
++          if test -n "$acl_hardcode_libdir_separator"; then
++            dnl Weird platform: only the last -rpath option counts, the user
++            dnl must pass all path elements in one option.
++            alldirs=
++            for dir in $rpathdirs; do
++              alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$dir"
++            done
++            acl_save_libdir="$libdir"
++            libdir="$alldirs"
++            eval flag=\"$acl_hardcode_libdir_flag_spec\"
++            libdir="$acl_save_libdir"
++            $1="$flag"
++          else
++            dnl The -rpath options are cumulative.
++            for dir in $rpathdirs; do
++              acl_save_libdir="$libdir"
++              libdir="$dir"
++              eval flag=\"$acl_hardcode_libdir_flag_spec\"
++              libdir="$acl_save_libdir"
++              $1="${$1}${$1:+ }$flag"
++            done
++          fi
++        fi
++      fi
++    fi
++  fi
++  AC_SUBST([$1])
++])
 === added file 'm4/lib-prefix.m4'
 --- m4/lib-prefix.m4	1970-01-01 00:00:00 +0000
 +++ m4/lib-prefix.m4	2009-07-16 02:58:56 +0000
@@ -0,0 +1,226 @@
++# lib-prefix.m4 serial 6 (gettext-0.18)
++dnl Copyright (C) 2001-2005, 2008 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl From Bruno Haible.
++
++dnl AC_LIB_ARG_WITH is synonymous to AC_ARG_WITH in autoconf-2.13, and
++dnl similar to AC_ARG_WITH in autoconf 2.52...2.57 except that is doesn't
++dnl require excessive bracketing.
++ifdef([AC_HELP_STRING],
++[AC_DEFUN([AC_LIB_ARG_WITH], [AC_ARG_WITH([$1],[[$2]],[$3],[$4])])],
++[AC_DEFUN([AC_][LIB_ARG_WITH], [AC_ARG_WITH([$1],[$2],[$3],[$4])])])
++
++dnl AC_LIB_PREFIX adds to the CPPFLAGS and LDFLAGS the flags that are needed
++dnl to access previously installed libraries. The basic assumption is that
++dnl a user will want packages to use other packages he previously installed
++dnl with the same --prefix option.
++dnl This macro is not needed if only AC_LIB_LINKFLAGS is used to locate
++dnl libraries, but is otherwise very convenient.
++AC_DEFUN([AC_LIB_PREFIX],
++[
++  AC_BEFORE([$0], [AC_LIB_LINKFLAGS])
++  AC_REQUIRE([AC_PROG_CC])
++  AC_REQUIRE([AC_CANONICAL_HOST])
++  AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])
++  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
++  dnl By default, look in $includedir and $libdir.
++  use_additional=yes
++  AC_LIB_WITH_FINAL_PREFIX([
++    eval additional_includedir=\"$includedir\"
++    eval additional_libdir=\"$libdir\"
++  ])
++  AC_LIB_ARG_WITH([lib-prefix],
++[  --with-lib-prefix[=DIR] search for libraries in DIR/include and DIR/lib
++  --without-lib-prefix    don't search for libraries in includedir and libdir],
++[
++    if test "X$withval" = "Xno"; then
++      use_additional=no
++    else
++      if test "X$withval" = "X"; then
++        AC_LIB_WITH_FINAL_PREFIX([
++          eval additional_includedir=\"$includedir\"
++          eval additional_libdir=\"$libdir\"
++        ])
++      else
++        additional_includedir="$withval/include"
++        additional_libdir="$withval/$acl_libdirstem"
++      fi
++    fi
++])
++  if test $use_additional = yes; then
++    dnl Potentially add $additional_includedir to $CPPFLAGS.
++    dnl But don't add it
++    dnl   1. if it's the standard /usr/include,
++    dnl   2. if it's already present in $CPPFLAGS,
++    dnl   3. if it's /usr/local/include and we are using GCC on Linux,
++    dnl   4. if it doesn't exist as a directory.
++    if test "X$additional_includedir" != "X/usr/include"; then
++      haveit=
++      for x in $CPPFLAGS; do
++        AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
++        if test "X$x" = "X-I$additional_includedir"; then
++          haveit=yes
++          break
++        fi
++      done
++      if test -z "$haveit"; then
++        if test "X$additional_includedir" = "X/usr/local/include"; then
++          if test -n "$GCC"; then
++            case $host_os in
++              linux* | gnu* | k*bsd*-gnu) haveit=yes;;
++            esac
++          fi
++        fi
++        if test -z "$haveit"; then
++          if test -d "$additional_includedir"; then
++            dnl Really add $additional_includedir to $CPPFLAGS.
++            CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }-I$additional_includedir"
++          fi
++        fi
++      fi
++    fi
++    dnl Potentially add $additional_libdir to $LDFLAGS.
++    dnl But don't add it
++    dnl   1. if it's the standard /usr/lib,
++    dnl   2. if it's already present in $LDFLAGS,
++    dnl   3. if it's /usr/local/lib and we are using GCC on Linux,
++    dnl   4. if it doesn't exist as a directory.
++    if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then
++      haveit=
++      for x in $LDFLAGS; do
++        AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
++        if test "X$x" = "X-L$additional_libdir"; then
++          haveit=yes
++          break
++        fi
++      done
++      if test -z "$haveit"; then
++        if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then
++          if test -n "$GCC"; then
++            case $host_os in
++              linux*) haveit=yes;;
++            esac
++          fi
++        fi
++        if test -z "$haveit"; then
++          if test -d "$additional_libdir"; then
++            dnl Really add $additional_libdir to $LDFLAGS.
++            LDFLAGS="${LDFLAGS}${LDFLAGS:+ }-L$additional_libdir"
++          fi
++        fi
++      fi
++    fi
++  fi
++])
++
++dnl AC_LIB_PREPARE_PREFIX creates variables acl_final_prefix,
++dnl acl_final_exec_prefix, containing the values to which $prefix and
++dnl $exec_prefix will expand at the end of the configure script.
++AC_DEFUN([AC_LIB_PREPARE_PREFIX],
++[
++  dnl Unfortunately, prefix and exec_prefix get only finally determined
++  dnl at the end of configure.
++  if test "X$prefix" = "XNONE"; then
++    acl_final_prefix="$ac_default_prefix"
++  else
++    acl_final_prefix="$prefix"
++  fi
++  if test "X$exec_prefix" = "XNONE"; then
++    acl_final_exec_prefix='${prefix}'
++  else
++    acl_final_exec_prefix="$exec_prefix"
++  fi
++  acl_save_prefix="$prefix"
++  prefix="$acl_final_prefix"
++  eval acl_final_exec_prefix=\"$acl_final_exec_prefix\"
++  prefix="$acl_save_prefix"
++])
++
++dnl AC_LIB_WITH_FINAL_PREFIX([statement]) evaluates statement, with the
++dnl variables prefix and exec_prefix bound to the values they will have
++dnl at the end of the configure script.
++AC_DEFUN([AC_LIB_WITH_FINAL_PREFIX],
++[
++  acl_save_prefix="$prefix"
++  prefix="$acl_final_prefix"
++  acl_save_exec_prefix="$exec_prefix"
++  exec_prefix="$acl_final_exec_prefix"
++  $1
++  exec_prefix="$acl_save_exec_prefix"
++  prefix="$acl_save_prefix"
++])
++
++dnl AC_LIB_PREPARE_MULTILIB creates
++dnl - a variable acl_libdirstem, containing the basename of the libdir, either
++dnl   "lib" or "lib64" or "lib/64",
++dnl - a variable acl_libdirstem2, as a secondary possible value for
++dnl   acl_libdirstem, either the same as acl_libdirstem or "lib/sparcv9" or
++dnl   "lib/amd64".
++AC_DEFUN([AC_LIB_PREPARE_MULTILIB],
++[
++  dnl There is no formal standard regarding lib and lib64.
++  dnl On glibc systems, the current practice is that on a system supporting
++  dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under
++  dnl $prefix/lib64 and 32-bit libraries go under $prefix/lib. We determine
++  dnl the compiler's default mode by looking at the compiler's library search
++  dnl path. If at least one of its elements ends in /lib64 or points to a
++  dnl directory whose absolute pathname ends in /lib64, we assume a 64-bit ABI.
++  dnl Otherwise we use the default, namely "lib".
++  dnl On Solaris systems, the current practice is that on a system supporting
++  dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under
++  dnl $prefix/lib/64 (which is a symlink to either $prefix/lib/sparcv9 or
++  dnl $prefix/lib/amd64) and 32-bit libraries go under $prefix/lib.
++  AC_REQUIRE([AC_CANONICAL_HOST])
++  acl_libdirstem=lib
++  acl_libdirstem2=
++  case "$host_os" in
++    solaris*)
++      dnl See Solaris 10 Software Developer Collection > Solaris 64-bit Developer's Guide > The Development Environment
++      dnl <http://docs.sun.com/app/docs/doc/816-5138/dev-env?l=en&a=view>.
++      dnl "Portable Makefiles should refer to any library directories using the 64 symbolic link."
++      dnl But we want to recognize the sparcv9 or amd64 subdirectory also if the
++      dnl symlink is missing, so we set acl_libdirstem2 too.
++      AC_MSG_CHECKING([if buildling 64-bit app])
++      AC_RUN_IFELSE([
++         AC_LANG_PROGRAM([
++         ], [
++           return sizeof(void*) == 8 ? 0 : 1;
++         ])
++      ], [
++         gl_cv_solaris_64bit=yes
++      ], [
++         gl_cv_solaris_64bit=no
++      ])
++      AC_MSG_RESULT([$gl_cv_solaris_64bit])
++      if test $gl_cv_solaris_64bit = yes; then
++        acl_libdirstem=lib/64
++        case "$host_cpu" in
++          sparc*)        acl_libdirstem2=lib/sparcv9 ;;
++          i*86 | x86_64) acl_libdirstem2=lib/amd64 ;;
++        esac
++      fi
++      ;;
++    *)
++      searchpath=`(LC_ALL=C $CC -print-search-dirs) 2>/dev/null | sed -n -e 's,^libraries: ,,p' | sed -e 's,^=,,'`
++      if test -n "$searchpath"; then
++        acl_save_IFS="${IFS= 	}"; IFS=":"
++        for searchdir in $searchpath; do
++          if test -d "$searchdir"; then
++            case "$searchdir" in
++              */lib64/ | */lib64 ) acl_libdirstem=lib64 ;;
++              *) searchdir=`cd "$searchdir" && pwd`
++                 case "$searchdir" in
++                   */lib64 ) acl_libdirstem=lib64 ;;
++                 esac ;;
++            esac
++          fi
++        done
++        IFS="$acl_save_IFS"
++      fi
++      ;;
++  esac
++  test -n "$acl_libdirstem2" || acl_libdirstem2="$acl_libdirstem"
++])
 === modified file 'm4/pandora_canonical.m4'
 --- m4/pandora_canonical.m4	2009-07-14 19:18:55 +0000
 +++ m4/pandora_canonical.m4	2009-07-16 02:28:54 +0000
@@ -4,7 +4,7 @@
  dnl with or without modifications, as long as this notice is preserved.
  dnl Which version of the canonical setup we're using
--AC_DEFUN([PANDORA_CANONICAL_VERSION],[0.13])
++AC_DEFUN([PANDORA_CANONICAL_VERSION],[0.20])
  AC_DEFUN([PANDORA_FORCE_DEPEND_TRACKING],[
    dnl Force dependency tracking on for Sun Studio builds
@@ -70,7 +70,10 @@
    m4_if(PCT_FORCE_GCC42, [yes], [
      AS_IF([test "$GCC" = "yes"], PANDORA_ENSURE_GCC_VERSION)
    ])
--
++
++  AC_CHECK_DECL([__SUNPRO_C], [SUNCC="yes"], [SUNCC="no"])
++  AC_CHECK_DECL([__ICC], [INTELCC="yes"], [INTELCC="no"])
++  AS_IF([test "x$INTELCC" = "xyes"], [enable_rpath=no])
    PANDORA_LIBTOOL
@@ -97,15 +100,10 @@
    AC_C_CONST
    AC_C_INLINE
    AC_C_VOLATILE
++  AC_C_RESTRICT
    AC_HEADER_TIME
    AC_TYPE_SIZE_T
--  AC_FUNC_MALLOC
--  AC_FUNC_REALLOC
--
--
--  AC_CHECK_DECL([__SUNPRO_C], [SUNCC="yes"], [SUNCC="no"])
--
    AC_SYS_LARGEFILE
@@ -127,6 +125,9 @@
    PANDORA_ENABLE_DTRACE
++  AC_LIB_PREFIX
++  PANDORA_HAVE_BETTER_MALLOC
++
    AC_CHECK_PROGS([DOXYGEN], [doxygen])
    AC_CHECK_PROGS([PERL], [perl])
 === added file 'm4/pandora_have_better_malloc.m4'
 --- m4/pandora_have_better_malloc.m4	1970-01-01 00:00:00 +0000
 +++ m4/pandora_have_better_malloc.m4	2009-07-16 02:58:56 +0000
@@ -0,0 +1,54 @@
++dnl  Copyright (C) 2009 Sun Microsystems
++dnl This file is free software; Sun Microsystems
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++AC_DEFUN([PANDORA_HAVE_BETTER_MALLOC],[
++  AC_REQUIRE([AC_FUNC_MALLOC])
++  AC_REQUIRE([AC_FUNC_REALLOC])
++  AC_REQUIRE([AC_LIB_PREFIX])
++
++  AC_ARG_ENABLE([umem],
++    [AS_HELP_STRING([--enable-umem],
++       [Enable linking with libumem @<:@default=off@:>@])],
++    [ac_enable_umem="$enableval"],
++    [ac_enable_umem="no"])
++
++  AC_ARG_ENABLE([tcmalloc],
++    [AS_HELP_STRING([--enable-tcmalloc],
++       [Enable linking with tcmalloc @<:@default=off@:>@])],
++    [ac_enable_tcmalloc="$enableval"],
++    [ac_enable_tcmalloc="no"])
++
++  AC_ARG_ENABLE([mtmalloc],
++    [AS_HELP_STRING([--disable-mtmalloc],
++       [Enable linking with mtmalloc @<:@default=on@:>@])],
++    [ac_enable_mtmalloc="$enableval"],
++    [ac_enable_mtmalloc="yes"])
++
++  save_LIBS="${LIBS}"
++  LIBS=
++  AS_IF([test "x$ac_enable_umem" = "xyes"],[
++    AC_CHECK_LIB(umem,malloc,[],[])
++  ],[
++    case "$target_os" in
++      *linux*)
++        AS_IF([test "x$ac_enable_tcmalloc" != "xno"],[
++          AC_CHECK_LIB(tcmalloc-minimal,malloc,[],[])
++          AS_IF([test "x$ac_cv_lib_tcmalloc_minimal_malloc" != "xyes"],[
++            AC_CHECK_LIB(tcmalloc,malloc,[],[])
++          ])
++        ])
++        ;;
++      *solaris*)
++        AS_IF([test "x$ac_enable_mtmalloc" != "xno"],[
++          AC_CHECK_LIB(mtmalloc,malloc,[],[])
++        ])
++        ;;
++    esac
++  ])
++  BETTER_MALLOC_LIBS="${LIBS}"
++  LIBS="${save_LIBS}"
++  AC_SUBST([BETTER_MALLOC_LIBS])
++
++])
 === added file 'm4/pandora_have_libdrizzle.m4'
 --- m4/pandora_have_libdrizzle.m4	1970-01-01 00:00:00 +0000
 +++ m4/pandora_have_libdrizzle.m4	2009-07-16 02:58:56 +0000
@@ -0,0 +1,46 @@
++dnl  Copyright (C) 2009 Sun Microsystems
++dnl This file is free software; Sun Microsystems
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++AC_DEFUN([_PANDORA_SEARCH_LIBDRIZZLE],[
++  AC_REQUIRE([AC_LIB_PREFIX])
++
++  dnl --------------------------------------------------------------------
++  dnl  Check for libdrizzle
++  dnl --------------------------------------------------------------------
++
++  AC_LIB_HAVE_LINKFLAGS(drizzle,,[
++    #include <libdrizzle/drizzle_client.h>
++  ],[
++    drizzle_st drizzle;
++    drizzle_version();
++  ])
++
++  AM_CONDITIONAL(HAVE_LIBDRIZZLE, [test "x${ac_cv_libdrizzle}" = "xyes"])
++
++])
++
++AC_DEFUN([PANDORA_HAVE_LIBDRIZZLE],[
++  AC_REQUIRE([_PANDORA_SEARCH_LIBDRIZZLE])
++])
++
++AC_DEFUN([PANDORA_REQUIRE_LIBDRIZZLE],[
++  AC_REQUIRE([PANDORA_HAVE_LIBDRIZZLE])
++  AS_IF([test x$ac_cv_libdrizzle = xno],
++      AC_MSG_ERROR([libdrizzle is required for ${PACKAGE}]))
++])
++
++AC_DEFUN([PANDORA_LIBDRIZZLE_NOVCOL],[
++  AC_CACHE_CHECK([if libdrizzle still has virtual columns],
++    [pandora_cv_libdrizzle_vcol],
++    [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
++#include <libdrizzle/drizzle.h>
++int foo= DRIZZLE_COLUMN_TYPE_DRIZZLE_VIRTUAL;
++    ]])],
++    [pandora_cv_libdrizzle_vcol=yes],
++    [pandora_cv_libdrizzle_vcol=no])])
++  AS_IF([test "$pandora_cv_libdrizzle_vcol" = "yes"],[
++    AC_MSG_ERROR([Your version of libdrizzle is too old. ${PACKAGE} requires at least version 0.4])
++  ])
++])
 === added file 'm4/pandora_have_libgearman.m4'
 --- m4/pandora_have_libgearman.m4	1970-01-01 00:00:00 +0000
 +++ m4/pandora_have_libgearman.m4	2009-07-16 02:58:56 +0000
@@ -0,0 +1,31 @@
++dnl  Copyright (C) 2009 Sun Microsystems
++dnl This file is free software; Sun Microsystems
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++AC_DEFUN([_PANDORA_SEARCH_LIBGEARMAN],[
++  AC_REQUIRE([AC_LIB_PREFIX])
++
++  dnl --------------------------------------------------------------------
++  dnl  Check for libgearman
++  dnl --------------------------------------------------------------------
++
++  AC_LIB_HAVE_LINKFLAGS(gearman,,
++    [#include <libgearman/gearman.h>],[
++      gearman_client_st gearman_client;
++      gearman_version();
++    ])
++
++  AM_CONDITIONAL(HAVE_LIBGEARMAN, [test "x${ac_cv_libgearman}" = "xyes"])
++
++])
++
++AC_DEFUN([PANDORA_HAVE_LIBGEARMAN],[
++  AC_REQUIRE([_PANDORA_SEARCH_LIBGEARMAN])
++])
++
++AC_DEFUN([PANDORA_REQUIRE_LIBGEARMAN],[
++  AC_REQUIRE([PANDORA_HAVE_LIBGEARMAN])
++  AS_IF([test x$ac_cv_libgearman = xno],
++      AC_MSG_ERROR([libgearman is required for ${PACKAGE}]))
++])
 === added file 'm4/pandora_have_libmemcached.m4'
 --- m4/pandora_have_libmemcached.m4	1970-01-01 00:00:00 +0000
 +++ m4/pandora_have_libmemcached.m4	2009-07-16 02:58:56 +0000
@@ -0,0 +1,35 @@
++dnl  Copyright (C) 2009 Sun Microsystems
++dnl This file is free software; Sun Microsystems
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++AC_DEFUN([_PANDORA_SEARCH_LIBMEMCACHED],[
++  AC_REQUIRE([AC_LIB_PREFIX])
++
++  dnl --------------------------------------------------------------------
++  dnl  Check for libmemcached
++  dnl --------------------------------------------------------------------
++
++  AC_LIB_HAVE_LINKFLAGS(memcached,,[
++    #include <libmemcached/memcached.h>
++  ], [
++    memcached_st memc;
++    memcached_dump_func *df;
++    memcached_version();
++  ])
++
++  AM_CONDITIONAL(HAVE_LIBMEMCACHED, [test "x${ac_cv_libmemcached}" = "xyes"])
++
++  AS_IF([test "x${ac_cv_libmemcached}" = "xyes"], [ PANDORA_WITH_MEMCACHED ])
++
++])
++
++AC_DEFUN([PANDORA_HAVE_LIBMEMCACHED],[
++  AC_REQUIRE([_PANDORA_SEARCH_LIBMEMCACHED])
++])
++
++AC_DEFUN([PANDORA_REQUIRE_LIBMEMCACHED],[
++  AC_REQUIRE([PANDORA_HAVE_LIBMEMCACHED])
++  AS_IF([test x$ac_cv_libmemcached = xno],
++      AC_MSG_ERROR([libmemcached is required for ${PACKAGE}]))
++])
 === added file 'm4/pandora_have_sqlite.m4'
 --- m4/pandora_have_sqlite.m4	1970-01-01 00:00:00 +0000
 +++ m4/pandora_have_sqlite.m4	2009-07-16 02:58:56 +0000
@@ -0,0 +1,24 @@
++dnl  Copyright (C) 2009 Sun Microsystems
++dnl This file is free software; Sun Microsystems
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++
++AC_DEFUN([_PANDORA_SEARCH_SQLITE],[
++  AC_REQUIRE([AC_LIB_PREFIX])
++
++  AC_LIB_HAVE_LINKFLAGS(sqlite3,,[
++    #include <stdio.h>
++    #include <sqlite3.h>
++  ],[
++    sqlite3 *db;
++    sqlite3_open(NULL, &db);
++  ])
++
++  AM_CONDITIONAL(HAVE_LIBSQLITE3, [test "x${ac_cv_libsqlite3}" = "xyes"])
++
++])
++
++AC_DEFUN([PANDORA_HAVE_SQLITE],[
++  AC_REQUIRE([_PANDORA_SEARCH_SQLITE])
++])
 === modified file 'm4/pandora_optimize.m4'
 --- m4/pandora_optimize.m4	2009-07-14 19:18:55 +0000
 +++ m4/pandora_optimize.m4	2009-07-16 02:28:54 +0000
@@ -6,7 +6,7 @@
  AC_DEFUN([PANDORA_OPTIMIZE],[
    dnl Build optimized or debug version ?
    dnl First check for gcc and g++
--  AS_IF([test "$GCC" = "yes"],[
++  AS_IF([test "$GCC" = "yes" -a "$INTELCC" = "no"],[
      dnl The following is required for portable results of floating point
      dnl calculations on PowerPC. The same must also be done for IA-64, but
@@ -30,6 +30,20 @@
      OPTIMIZE_CFLAGS="-O3"
      OPTIMIZE_CXXFLAGS="-O3"
    ])
++  AS_IF([test "$INTELCC" = "yes"],[
++    dnl Once we can use a modern autoconf, we can replace the std=gnu99 here
++    dnl with using AC_CC_STD_C99 above
++    CC="${CC} -std=c99"
++
++    AM_CPPFLAGS="-g ${AM_CPPFLAGS}"
++
++    DEBUG_CFLAGS="-O0"
++    DEBUG_CXXFLAGS="-O0"
++
++    OPTIMIZE_CFLAGS="-xHOST -O3 -no-prec-div -static"
++    OPTIMIZE_CXXFLAGS="${OPTIMIZE_CFLAGS}"
++
++  ])
    AS_IF([test "$SUNCC" = "yes"],[
      dnl Once we can use a modern autoconf, we can replace the -xc99=all here
      dnl with using AC_CC_STD_C99 above
 === modified file 'm4/pandora_warnings.m4'
 --- m4/pandora_warnings.m4	2009-07-14 19:18:55 +0000
 +++ m4/pandora_warnings.m4	2009-07-16 02:28:54 +0000
@@ -127,78 +127,88 @@
      NO_STRICT_ALIASING="-fno-strict-aliasing -Wno-strict-aliasing"
      NO_SHADOW="-Wno-shadow"
--    m4_if(PW_LESS_WARNINGS,[no],[
--      BASE_WARNINGS_FULL="-Wformat=2 ${W_CONVERSION} -Wstrict-aliasing"
--      CC_WARNINGS_FULL="-Wswitch-default -Wswitch-enum -Wwrite-strings"
--      CXX_WARNINGS_FULL="-Weffc++ -Wold-style-cast"
++    AS_IF([test "$INTELCC" = "yes"],[
++      m4_if(PW_LESS_WARNINGS,[no],[
++        BASE_WARNINGS="-w1 -Wall -Werror -Wcheck -Wformat -Wp64 -Woverloaded-virtual -Wcast-qual"
++      ],[
++        BASE_WARNINGS="-w1 -Wall -Wcheck -Wformat -Wp64 -Woverloaded-virtual -Wcast-qual -diag-disable 981"
++      ])
++      CC_WARNINGS="${BASE_WARNINGS}"
++      CXX_WARNINGS="${BASE_WARNINGS}"
      ],[
--      BASE_WARNINGS_FULL="-Wformat ${NO_STRICT_ALIASING}"
--    ])
--
--    AS_IF([test "${ac_cv_assert}" = "no"],
--          [NO_UNUSED="-Wno-unused-variable -Wno-unused-parameter"])
--
--    BASE_WARNINGS="${W_FAIL} -pedantic -Wall -Wextra -Wundef -Wshadow ${NO_UNUSED} ${F_DIAGNOSTICS_SHOW_OPTION} ${CFLAG_VISIBILITY} ${BASE_WARNINGS_FULL}"
--    CC_WARNINGS="${BASE_WARNINGS} -Wstrict-prototypes -Wmissing-prototypes -Wredundant-decls -Wmissing-declarations -Wcast-align ${CC_WARNINGS_FULL}"
--    CXX_WARNINGS="${BASE_WARNINGS} -Woverloaded-virtual -Wnon-virtual-dtor -Wctor-dtor-privacy -Wno-long-long ${CXX_WARNINGS_FULL}"
--
--    AC_CACHE_CHECK([whether it is safe to use -Wmissing-declarations from C++],
--      [ac_cv_safe_to_use_Wmissing_declarations_],
--      [AC_LANG_PUSH(C++)
--       save_CXXFLAGS="$CXXFLAGS"
--       CXXFLAGS="-Werror -pedantic -Wmissing-declarations ${AM_CXXFLAGS}"
--       AC_COMPILE_IFELSE([
--         AC_LANG_PROGRAM(
--         [[
--#include <stdio.h>
--         ]], [[]])
--      ],
--      [ac_cv_safe_to_use_Wmissing_declarations_=yes],
--      [ac_cv_safe_to_use_Wmissing_declarations_=no])
--      CXXFLAGS="$save_CXXFLAGS"
--      AC_LANG_POP()
--    ])
--    AS_IF([test "$ac_cv_safe_to_use_Wmissing_declarations_" = "yes"],
--          [CXX_WARNINGS="${CXX_WARNINGS} -Wmissing-declarations"])
--
--    AC_CACHE_CHECK([whether it is safe to use -Wlogical-op],
--      [ac_cv_safe_to_use_Wlogical_op_],
--      [save_CFLAGS="$CFLAGS"
--       CFLAGS="${W_FAIL} -pedantic -Wlogical-op ${AM_CFLAGS} ${CFLAGS}"
--       AC_COMPILE_IFELSE([
--         AC_LANG_PROGRAM(
--         [[
--#include <stdio.h>
--         ]], [[]])
--      ],
--      [ac_cv_safe_to_use_Wlogical_op_=yes],
--      [ac_cv_safe_to_use_Wlogical_op_=no])
--    CFLAGS="$save_CFLAGS"])
--    AS_IF([test "$ac_cv_safe_to_use_Wlogical_op_" = "yes"],
--          [CC_WARNINGS="${CC_WARNINGS} -Wlogical-op"])
--
--    AC_CACHE_CHECK([whether it is safe to use -Wredundant-decls from C++],
--      [ac_cv_safe_to_use_Wredundant_decls_],
--      [AC_LANG_PUSH(C++)
--       save_CXXFLAGS="${CXXFLAGS}"
--       CXXFLAGS="${W_FAIL} -pedantic -Wredundant-decls ${AM_CXXFLAGS}"
--       AC_COMPILE_IFELSE(
--         [AC_LANG_PROGRAM([
++      m4_if(PW_LESS_WARNINGS,[no],[
++        BASE_WARNINGS_FULL="-Wformat=2 ${W_CONVERSION} -Wstrict-aliasing"
++        CC_WARNINGS_FULL="-Wswitch-default -Wswitch-enum -Wwrite-strings"
++        CXX_WARNINGS_FULL="-Weffc++ -Wold-style-cast"
++      ],[
++        BASE_WARNINGS_FULL="-Wformat ${NO_STRICT_ALIASING}"
++      ])
++
++      AS_IF([test "${ac_cv_assert}" = "no"],
++            [NO_UNUSED="-Wno-unused-variable -Wno-unused-parameter"])
++
++      BASE_WARNINGS="${W_FAIL} -pedantic -Wall -Wextra -Wundef -Wshadow ${NO_UNUSED} ${F_DIAGNOSTICS_SHOW_OPTION} ${CFLAG_VISIBILITY} ${BASE_WARNINGS_FULL}"
++      CC_WARNINGS="${BASE_WARNINGS} -Wstrict-prototypes -Wmissing-prototypes -Wredundant-decls -Wmissing-declarations -Wcast-align ${CC_WARNINGS_FULL}"
++      CXX_WARNINGS="${BASE_WARNINGS} -Woverloaded-virtual -Wnon-virtual-dtor -Wctor-dtor-privacy -Wno-long-long ${CXX_WARNINGS_FULL}"
++
++      AC_CACHE_CHECK([whether it is safe to use -Wmissing-declarations from C++],
++        [ac_cv_safe_to_use_Wmissing_declarations_],
++        [AC_LANG_PUSH(C++)
++         save_CXXFLAGS="$CXXFLAGS"
++         CXXFLAGS="-Werror -pedantic -Wmissing-declarations ${AM_CXXFLAGS}"
++         AC_COMPILE_IFELSE([
++           AC_LANG_PROGRAM(
++           [[
++#include <stdio.h>
++           ]], [[]])
++        ],
++        [ac_cv_safe_to_use_Wmissing_declarations_=yes],
++        [ac_cv_safe_to_use_Wmissing_declarations_=no])
++        CXXFLAGS="$save_CXXFLAGS"
++        AC_LANG_POP()
++      ])
++      AS_IF([test "$ac_cv_safe_to_use_Wmissing_declarations_" = "yes"],
++            [CXX_WARNINGS="${CXX_WARNINGS} -Wmissing-declarations"])
++
++      AC_CACHE_CHECK([whether it is safe to use -Wlogical-op],
++        [ac_cv_safe_to_use_Wlogical_op_],
++        [save_CFLAGS="$CFLAGS"
++         CFLAGS="${W_FAIL} -pedantic -Wlogical-op ${AM_CFLAGS} ${CFLAGS}"
++         AC_COMPILE_IFELSE([
++           AC_LANG_PROGRAM(
++           [[
++#include <stdio.h>
++           ]], [[]])
++        ],
++        [ac_cv_safe_to_use_Wlogical_op_=yes],
++        [ac_cv_safe_to_use_Wlogical_op_=no])
++      CFLAGS="$save_CFLAGS"])
++      AS_IF([test "$ac_cv_safe_to_use_Wlogical_op_" = "yes"],
++            [CC_WARNINGS="${CC_WARNINGS} -Wlogical-op"])
++
++      AC_CACHE_CHECK([whether it is safe to use -Wredundant-decls from C++],
++        [ac_cv_safe_to_use_Wredundant_decls_],
++        [AC_LANG_PUSH(C++)
++         save_CXXFLAGS="${CXXFLAGS}"
++         CXXFLAGS="${W_FAIL} -pedantic -Wredundant-decls ${AM_CXXFLAGS}"
++         AC_COMPILE_IFELSE(
++           [AC_LANG_PROGRAM([
  template <typename E> struct C { void foo(); };
  template <typename E> void C<E>::foo() { }
  template <> void C<int>::foo();
--          AC_INCLUDES_DEFAULT])],
--          [ac_cv_safe_to_use_Wredundant_decls_=yes],
--          [ac_cv_safe_to_use_Wredundant_decls_=no])
--        CXXFLAGS="${save_CXXFLAGS}"
--        AC_LANG_POP()])
--    AS_IF([test "$ac_cv_safe_to_use_Wredundant_decls_" = "yes"],
--          [CXX_WARNINGS="${CXX_WARNINGS} -Wredundant-decls"],
--          [CXX_WARNINGS="${CXX_WARNINGS} -Wno-redundant-decls"])
--
--    NO_REDUNDANT_DECLS="-Wno-redundant-decls"
--    PROTOSKIP_WARNINGS="-Wno-effc++ -Wno-shadow"
--
++            AC_INCLUDES_DEFAULT])],
++            [ac_cv_safe_to_use_Wredundant_decls_=yes],
++            [ac_cv_safe_to_use_Wredundant_decls_=no])
++          CXXFLAGS="${save_CXXFLAGS}"
++          AC_LANG_POP()])
++      AS_IF([test "$ac_cv_safe_to_use_Wredundant_decls_" = "yes"],
++            [CXX_WARNINGS="${CXX_WARNINGS} -Wredundant-decls"],
++            [CXX_WARNINGS="${CXX_WARNINGS} -Wno-redundant-decls"])
++
++      NO_REDUNDANT_DECLS="-Wno-redundant-decls"
++      PROTOSKIP_WARNINGS="-Wno-effc++ -Wno-shadow"
++
++    ])
    ])
    AS_IF([test "$SUNCC" = "yes"],[
@@ -229,6 +239,7 @@
      m4_if(PW_LESS_WARNINGS, [no],[
        CC_WARNINGS_FULL="-erroff=E_INTEGER_OVERFLOW_DETECTED${W_PASTE_RESULT}"
++      CXX_WARNINGS_FULL="-erroff=inllargeuse"
      ],[
        CC_WARNINGS_FULL="-erroff=E_ATTRIBUTE_NOT_VAR"
        CXX_WARNINGS_FULL="-erroff=attrskipunsup,doubunder,reftotemp,inllargeuse,truncwarn1,signextwarn,inllargeint"
 === added file 'm4/pandora_with_memcached.m4'
 --- m4/pandora_with_memcached.m4	1970-01-01 00:00:00 +0000
 +++ m4/pandora_with_memcached.m4	2009-07-16 02:58:56 +0000
@@ -0,0 +1,33 @@
++dnl  Copyright (C) 2009 Sun Microsystems
++dnl This file is free software; Sun Microsystems
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++AC_DEFUN([PANDORA_WITH_MEMCACHED],[
++
++  AC_ARG_WITH([memcached],
++    [AS_HELP_STRING([--with-memcached],
++      [Memcached binary to use for make test])],
++    [ac_cv_with_memcached="$withval"],
++    [ac_cv_with_memcached=memcached])
++
++  # just ignore the user if --without-memcached is passed.. it is
++  # only used by make test
++  AS_IF([test "x$withval" = "xno"],[
++    ac_cv_with_memcached=memcached
++    MEMCACHED_BINARY=memcached
++  ],[
++    AS_IF([test -f "$withval"],[
++      ac_cv_with_memcached=$withval
++      MEMCACHED_BINARY=$withval
++    ],[
++      AC_PATH_PROG([MEMCACHED_BINARY], [$ac_cv_with_memcached], "no")
++      AS_IF([test "x$MEMCACHED_BINARY" = "xno"],[
++        AC_MSG_ERROR(["could not find memcached binary"])
++      ])
++    ])
++  ])
++  AC_DEFINE_UNQUOTED([MEMCACHED_BINARY], "$MEMCACHED_BINARY",
++            [Name of the memcached binary used in make test])
++
++])
 === modified file 'tests/plus.cpp'
 --- tests/plus.cpp	2009-07-11 19:10:39 +0000
 +++ tests/plus.cpp	2009-07-15 18:45:15 +0000
@@ -21,11 +21,19 @@
  using namespace std;
  extern "C" {
++   test_return basic_test(memcached_st *memc);
++   test_return increment_test(memcached_st *memc);
++   test_return basic_master_key_test(memcached_st *memc);
++   test_return mget_result_function(memcached_st *memc);
++   test_return mget_test(memcached_st *memc);
++   memcached_return callback_counter(memcached_st *,
++                                     memcached_result_st *,
++                                     void *context);
     void *world_create(void);
     void world_destroy(void *p);
+ }
--static test_return basic_test(memcached_st *memc)
++test_return basic_test(memcached_st *memc)
+ {
    Memcached foo(memc);
    const string value_set("This is some data");
@@ -40,7 +48,7 @@
    return TEST_SUCCESS;
+ }
--static test_return increment_test(memcached_st *memc)
++test_return increment_test(memcached_st *memc)
+ {
    Memcached mcach(memc);
    bool rc;
@@ -73,7 +81,7 @@
    return TEST_SUCCESS;
+ }
--static test_return basic_master_key_test(memcached_st *memc)
++test_return basic_master_key_test(memcached_st *memc)
+ {
    Memcached foo(memc);
    const string value_set("Data for server A");
@@ -95,9 +103,9 @@
+ }
  /* Count the results */
--static memcached_return callback_counter(memcached_st *ptr __attribute__((unused)),
--                                     memcached_result_st *result __attribute__((unused)),
--                                     void *context)
++memcached_return callback_counter(memcached_st *,
++                                  memcached_result_st *,
++                                  void *context)
+ {
    unsigned int *counter= static_cast<unsigned int *>(context);
@@ -106,7 +114,7 @@
    return MEMCACHED_SUCCESS;
+ }
--static test_return mget_result_function(memcached_st *memc)
++test_return mget_result_function(memcached_st *memc)
+ {
    Memcached mc(memc);
    bool rc;
@@ -138,7 +146,7 @@
    return TEST_SUCCESS;
+ }
--static test_return mget_test(memcached_st *memc)
++test_return mget_test(memcached_st *memc)
+ {
    Memcached mc(memc);
    bool rc;