/[v1]/trunk/c++/src/build-system/configure.ac

Diff of /trunk/c++/src/build-system/configure.ac

Parent Directory | Revision Log | View Patch Patch

-trunk/c++/configure.ac
revision 12408 by ucko,
Thu Dec  4 13:03:26 2003 UTC
+trunk/c++/src/build-system/configure.ac
revision 45256 by ucko,
Thu Mar 25 16:07:05 2010 UTC
 Line 1
  #############################################################################
- #  $Id: configure.ac,v 1.243 2003/12/04 13:03:26 ucko Exp $
+ #  $Id$
  #  Derived from configure.in version 1.173.
  # ==========================================================================
  #
 Line 32
  #   USAGE:
  #    1) Process this file with "autoconf" to produce a "configure" script.
  #    2) Run the resultant "configure" script to produce:
- #      a) "<builddir>/inc/ncbiconf.h"
+ #      a) "<builddir>/inc/ncbiconf_unix.h"
  #      b) "<builddir>/build/Makefile.mk"
  #      c) other Makefile's and scripts in "<builddir>/build" and below
  #
  #############################################################################
- AC_PREREQ(2.56)
+ AC_PREREQ(2.59)
  dnl Set up lock.  The diversion magic lets this occur before AC_INIT, which
  dnl already interferes with other configure processes.
  AC_DIVERT_PUSH(INIT_PREPARE)
- if $srcdir/scripts/get_lock.sh configure $$; then
+ if $srcdir/scripts/common/impl/get_lock.sh configure $$; then
      ac_clean_files=configure.lock
  else
      exit 1
 Line 52
  cache_file=config.cache
  # reconfigure.sh expects config.cache to exist; unconditionally clobber
  # any command-line setting.
- if test -z "$CONFIG_SITE" -a -r $srcdir/config.site; then
+ if test -z "$CONFIG_SITE" -a -r $srcdir/src/build-system/config.site; then
-     CONFIG_SITE=$srcdir/config.site
+     CONFIG_SITE=$srcdir/src/build-system/config.site
  fi
  AC_DIVERT_POP
  AC_INIT([ncbi-tools++],[0.0],[cpp-core@ncbi.nlm.nih.gov])
- AC_CONFIG_SRCDIR(src/Makefile.mk.in)
+ AC_CONFIG_SRCDIR(src/build-system/Makefile.mk.in)
 Line 82
     [ --without-optimization  turn off optimization flags in non-debug mode])
  AC_ARG_WITH(profiling,
     [ --with-profiling        build profiled versions of libs and apps])
+ AC_ARG_WITH(tcheck,
+    [ --with-tcheck(=DIR)     build for Intel Thread Checker (in DIR)])
  AC_ARG_WITH(dll,
     [ --with-dll              build all libraries as DLLs])
  AC_ARG_WITH(static,
     [ --with-static           build all libraries statically even if --with-dll])
  AC_ARG_WITH(static-exe,
     [ --with-static-exe       build all executables as statically as possible])
+ AC_ARG_WITH(plugin-auto-load,
+    [ --with-plugin-auto-load always enable the plugin manager by default])
+ AC_ARG_WITH(bin-release,
+    [ --with-bin-release      build executables suitable for public release])
  AC_ARG_WITH(mt,
     [ --with-mt               compile in a MultiThread-safe manner])
  AC_ARG_WITH(64,
     [ --with-64               compile to 64-bit code])
+ AC_ARG_WITH(universal,
+    [ --with-universal        build universal binaries on Mac OS X])
+ AC_ARG_WITH(universal2,
+    [ --with-universal=CPUs   build universal binaries targeting the given CPUs])
  AC_ARG_WITH(exe,
     [ --without-exe           do not build executables])
  AC_ARG_WITH(runpath,
-Line 106
+Line 116
     [ --with-autodep          automatic generation of dependencies (GNU make)])
  AC_ARG_WITH(build-root,
     [ --with-build-root=DIR   specify a non-default build directory name])
+ AC_ARG_WITH(fake-root,
+    [ --with-fake-root=DIR    appear to have been built under DIR])
  AC_ARG_WITH(suffix,
     [ --without-suffix        no Release/Debug, MT or DLL sfx in the build dir name])
  AC_ARG_WITH(hostspec,
     [ --with-hostspec         add full host specs to the build dir name])
  AC_ARG_WITH(version,
-    [ --with-version          always include the compiler ver in the b.d. name])
+    [ --without-version       don't always include the cplr ver in the bd name])
+ AC_ARG_WITH(build-root-sfx,
+    [ --with-build-root-sfx=X add a user-specified suffix to the build dir name])
  AC_ARG_WITH(execopy,
     [ --without-execopy       do not copy built executables to the BIN area])
  AC_ARG_WITH(bincopy,
-Line 120
+Line 134
     [ --with-lib-rebuilds     ensure that apps use up-to-date libraries])
  AC_ARG_WITH(lib-rebuilds2,
     [ --with-lib-rebuilds=ask ask whether to update each app's libraries])dnl'
+ AC_ARG_WITH(deactivation,
+    [ --without-deactivation  keep old copies of libraries that no longer build])
+ AC_ARG_WITH(makefile-auto-update,
+    [ --without-makefile-auto-update  do not auto-update generated makefiles])
  AC_ARG_WITH(projects,
     [ --with-projects=FILE    build projects listed in FILE by default])
+ AC_ARG_WITH(flat-makefile,
+    [ --without-flat-makefile do not generate an all-encompassing flat makefile])
+ AC_ARG_WITH(configure-dialog,
+    [ --with-configure-dialog allow interactive flat makefile project selection])
+ AC_ARG_WITH(saved-settings,
+    [ --with-saved-settings=F load configuration settings from the file F])
  AC_ARG_WITH(check,
-    [ --with-check=           run test suite after the build])
+    [ --with-check            run test suite after the build])
+ AC_ARG_WITH(check-tools,
+    [ --with-check-tools=...  use the specified tools for testing])
  AC_ARG_WITH(ncbi-public,
     [ --with-ncbi-public      ensure compatibility for all in-house platforms])
  AC_ARG_WITH(strip,
     [ --with-strip            strip binaries at build time])
+ AC_ARG_WITH(pch,
+    [ --with-pch              use precompiled headers if possible])
+ AC_ARG_WITH(caution,
+    [ --with-caution          cancel configuration unconditionally when in doubt])
+ AC_ARG_WITH(caution2,
+    [ --without-caution       proceed without asking when in doubt])
+ AC_ARG_WITH(ccache,
+    [ --without-ccache        do not automatically use ccache if available])
+ AC_ARG_WITH(distcc,
+    [ --without-distcc        do not automatically use distcc if available])
  ## NCBI packages
  AC_ARG_WITH(ncbi-c,
-Line 138
+Line 174
     [ --without-utils         do not use NCBI SSS UTIL library])
  AC_ARG_WITH(sssdb,
     [ --without-sssdb         do not use NCBI SSS DB library])
- AC_ARG_WITH(geo,
+ AC_ARG_WITH(included-sss,
-    [ --without-geo           do not use NCBI GEO libraries])
+    [ --with-included-sss     use the in-tree copy of SSS])
- AC_ARG_WITH(pubmed,
-    [ --without-pubmed        do not use NCBI PubMed libraries])
  ## Third-party and system packages
+ AC_ARG_WITH(z,
+    [ --with-z=DIR            use zlib installation in DIR])
+ AC_ARG_WITH(z2,
+    [ --without-z             use internal copy of zlib])
+ AC_ARG_WITH(bz2,
+    [ --with-bz2=DIR          use bzlib installation in DIR])
+ AC_ARG_WITH(bz2b,
+    [ --without-bz2           use internal copy of bzlib])
+ AC_ARG_WITH(lzo,
+    [ --with-lzo=DIR          use LZO installation in DIR (requires 2.x or up)])
+ AC_ARG_WITH(lzo_,
+    [ --without-lzo           do not use LZO])
+ AC_ARG_WITH(pcre,
+    [ --with-pcre=DIR         use PCRE installation in DIR])
+ AC_ARG_WITH(pcre2,
+    [ --without-pcre          use internal copy of PCRE])
+ AC_ARG_WITH(gnutls,
+    [ --with-gnutls=DIR       use GNUTLS installation in DIR])
+ AC_ARG_WITH(gnutls2,
+    [ --without-gnutls        do not use GNUTLS])
+ AC_ARG_WITH(openssl,
+    [ --with-openssl=DIR      use OpenSSL installation in DIR])
+ AC_ARG_WITH(openssl2,
+    [ --without-openssl       do not use OpenSSL])
  AC_ARG_WITH(sybase,
     [ --without-sybase        do not use SYBASE libraries])
  AC_ARG_WITH(sybase-local,
-Line 154
+Line 212
     [ --without-ftds          do not use FreeTDS libraries])
  AC_ARG_WITH(ftds2,
     [ --with-ftds=DIR         use FreeTDS installation in DIR])
+ AC_ARG_WITH(ftds-renamed,
+    [ --without-ftds-renamed  do not rename Sybase DBLIB symbols in built-in FTDS])
  AC_ARG_WITH(mysql,
     [ --without-mysql         do not use MySQL])
  AC_ARG_WITH(mysql2,
-Line 175
+Line 235
  AC_ARG_WITH(glut2,
     [ --with-glut=DIR         use GLUT installation in DIR])
  AC_ARG_WITH(wxwin,
-    [ --without-wxwin         do not use wxWindows])
+    [ --without-wxwin         do not use wxWindows (2.4-)])
  AC_ARG_WITH(wxwin2,
     [ --with-wxwin=DIR        use wxWindows installation in DIR])
+ AC_ARG_WITH(wxwidgets,
+    [ --without-wxwidgets     do not use wxWidgets (2.6+)])
+ AC_ARG_WITH(wxwidgets2,
+    [ --with-wxwidgets=DIR    use wxWidgets installation in DIR])
+ AC_ARG_WITH(wxwidgets-ucs,
+    [ --with-wxwidgets-ucs    use Unicode builds of wxWidgets])
+ AC_ARG_WITH(wxwidgets-ucs2,
+    [ --without-wxwidgets-ucs do not use Unicode builds of wxWidgets])
+ AC_ARG_WITH(freetype,
+    [ --without-freetype      do not use FreeType])
+ AC_ARG_WITH(freetype_,
+    [ --with-freetype=DIR     use FreeType installation in DIR])
  AC_ARG_WITH(fastcgi,
     [ --without-fastcgi       do not use Fast-CGI library])
  AC_ARG_WITH(fastcgi2,
-Line 198
+Line 270
     [ --with-orbacus=DIR      use ORBacus installation in DIR])
  AC_ARG_WITH(odbc,
     [ --with-odbc=DIR         use ODBC installation in DIR])
- AC_ARG_WITH(odbc2,
+ AC_ARG_WITH(python,
-    [ --without-odbc          do not use ODBC])
+    [ --with-python=DIR       use Python installation in DIR])
+ AC_ARG_WITH(python2,
+    [ --without-python        do not use Python])
+ AC_ARG_WITH(cppunit,
+    [ --with-cppunit=DIR      use CPPUNIT installation in DIR])
+ AC_ARG_WITH(cppunit2,
+    [ --without-cppunit       do not use CPPUNIT])
+ AC_ARG_WITH(boost,
+    [ --with-boost=DIR        use Boost installation in DIR])
+ AC_ARG_WITH(boost2,
+    [ --without-boost         do not use Boost])
+ AC_ARG_WITH(boost-tag,
+    [ --with-boost-tag=TAG    use TAG as the tag appended to Boost library names])
+ AC_ARG_WITH(boost-tag2,
+    [ --without-boost-tag     use untagged Boost library names])
+ AC_ARG_WITH(sqlite,
+    [ --with-sqlite=DIR       use SQLite (2.x) installation in DIR])
+ AC_ARG_WITH(sqlite2,
+    [ --without-sqlite,       do not use SQLite 2.x])
+ AC_ARG_WITH(sqlite3,
+    [ --with-sqlite3=DIR      use SQLite 3.x installation in DIR])
+ AC_ARG_WITH(sqlite3b,
+    [ --without-sqlite3,      do not use SQLite 3.x])
+ AC_ARG_WITH(icu,
+    [ --with-icu=DIR          use ICU installation in DIR])
+ AC_ARG_WITH(icu2,
+    [ --without-icu,          do not use ICU])
+ AC_ARG_WITH(expat,
+    [ --with-expat=DIR        use Expat installation in DIR])
+ AC_ARG_WITH(expat2,
+    [ --without-expat,        do not use Expat])
+ AC_ARG_WITH(sablot,
+    [ --with-sablot=DIR       use Sablotron installation in DIR])
+ AC_ARG_WITH(sablot2,
+    [ --without-sablot,       do not use Sablotron])
+ AC_ARG_WITH(libxml,
+    [ --with-libxml=DIR       use libxml2 installation in DIR])
+ AC_ARG_WITH(libxml_,
+    [ --without-libxml        do not use libxml2])
+ AC_ARG_WITH(libxslt,
+    [ --with-libxslt=DIR      use libxslt installation in DIR])
+ AC_ARG_WITH(libxslt2,
+    [ --without-libxslt       do not use libxstl])
+ AC_ARG_WITH(xerces,
+    [ --with-xerces=DIR       use Xerces-C++ installation in DIR])
+ AC_ARG_WITH(xerces2,
+    [ --without-xerces,       do not use Xerces-C++])
+ AC_ARG_WITH(xalan,
+    [ --with-xalan=DIR        use Xalan-C++ installation in DIR])
+ AC_ARG_WITH(xalan2,
+    [ --without-xalan,        do not use Xalan-C++])
+ AC_ARG_WITH(oechem,
+    [ --with-oechem=DIR       use OpenEye OEChem installation in DIR])
+ AC_ARG_WITH(oechem2,
+    [ --without-oechem        do not use OEChem])
+ AC_ARG_WITH(sge,
+    [ --with-sge=DIR          use Sun Grid Engine installation in DIR])
+ AC_ARG_WITH(sge2,
+    [ --without-sge           do not use Sun Grid Engine])
+ AC_ARG_WITH(muparser,
+    [ --with-muparser=DIR     use muParser installation in DIR])
+ AC_ARG_WITH(muparser2,
+    [ --without-muparser      do not use muParser])
+ AC_ARG_WITH(hdf5,
+    [ --with-hdf5=DIR         use HDF5 installation in DIR])
+ AC_ARG_WITH(hdf5b,
+    [ --without-hdf5          do not use HDF5])
  AC_ARG_WITH(gif,
     [ --with-gif=DIR          use lib(un)gif installation in DIR])
  AC_ARG_WITH(gif2,
-Line 224
+Line 362
  ## Optional projects
  AC_ARG_WITH(local-lbsm,
     [ --without-local-lbsm    turn off support for IPC with locally running LBSMD])
+ AC_ARG_WITH(ncbi-crypt,
+    [ --without-ncbi-crypt    use a dummy stubbed-out version of ncbi_crypt])
+ AC_ARG_WITH(connext,
+    [ --without-connext       do not build non-public CONNECT library extensions])
  AC_ARG_WITH(serial,
     [ --without-serial        do not build the serialization library and tools])
  AC_ARG_WITH(objects,
-Line 235
+Line 377
  AC_ARG_WITH(ctools,
     [ --without-ctools        do not build NCBI C Toolkit based projects])
  AC_ARG_WITH(gui,
-    [ --without-gui           do not build FLTK-based projects])
+    [ --without-gui           do not build most graphical projects])
  AC_ARG_WITH(algo,
     [ --without-algo          do not build CPU-intensive algorithms])
  AC_ARG_WITH(internal,
     [ --without-internal      do not build internal projects])
+ AC_ARG_WITH(gbench,
+    [ --with-gbench           ensure that Genome Workbench can be built])
+ AC_ARG_WITH(gbench2,
+    [ --without-gbench        do not build Genome Workbench])
  ## Manuals
  AC_ARG_WITH(manuals,
-Line 248
+Line 394
  #### Check the passed arguments against the list of available ones
  x_with_list="\
- debug optimization profiling dll static runpath mt 64 projects ncbi-public \
+ debug optimization profiling tcheck dll static static-exe plugin-auto-load \
- exe autodep suffix hostspec execopy bincopy lib-rebuilds lib-rebuilds=ask \
+ bin-release mt 64 universal exe runpath lfs \
- check static-exe strip version lfs \
+ autodep suffix hostspec version execopy bincopy lib-rebuilds lib-rebuilds=ask \
- ncbi-c wxwin fastcgi sss sssdb sssutils geo sp pubmed sybase sybase-local \
+ deactivation makefile-auto-update projects flat-makefile configure-dialog \
- sybase-new ftds mysql orbacus fltk opengl mesa glut bdb odbc \
+ check ncbi-public strip pch caution ccache distcc \
+ ncbi-c wxwin wxwidgets wxwidgets-ucs fastcgi sss sssdb sssutils included-sss \
+ geo included-geo \
+ z bz2 lzo pcre gnutls openssl sybase sybase-local sybase-new \
+ ftds mysql orbacus freetype fltk \
+ opengl mesa glut bdb python sqlite sqlite3 icu cppunit boost boost-tag \
+ sp expat sablot libxml libxslt xerces xalan oechem sge muparser hdf5 \
  gif jpeg tiff png xpm \
- local-lbsm serial objects dbapi app ctools gui algo internal"
+ local-lbsm ncbi-crypt connext \
+ serial objects dbapi app ctools gui algo internal gbench"
  changequote(, )dnl
  x_with_list=`echo "$x_with_list" | sed 's/\([^ ][^ ]*\)/--with-\1 --without-\1/g'`
-Line 278
+Line 431
     fi
     case "$x_arg" in
-       --with-extra-action= | --exec-prefix= | --with-projects= \
+       --with-extra-action= | --exec-prefix= | --with-projects= | --srcdir= \
-       | --cache-file= | --build= | --host= | --target= | --with-runpath= )
+       | --cache-file= | --build= | --host= | --target= | --with-runpath= \
-       AC_MSG_ERROR(["  $x_arg:  requires value;  use --help to show usage"])
+       | --x-includes= | --x-libraries= )
+       AC_MSG_ERROR([$x_arg:  requires value;  use --help to show usage])
        ;;
-       --with-extra-action=* | --with-build-root=* \
+       --with-extra-action=* | --with-build-root=* | --with-build-root-sfx=* \
-       | --with-projects=* | --with-check=* \
+       | --with-fake-root=* | --with-saved-settings=* \
+       | --with-projects=* | --with-check=* | --with-check-tools=* \
+       | --with-universal=* | --with-tcheck=* \
        | --cache-file=* | --build=* | --host=* | --prefix=* | --exec-prefix=* \
-       | --libdir=* | --bindir=* | --includedir=* \
+       | --libdir=* | --bindir=* | --includedir=* | --srcdir=* \
        | [[A-Z]*=*] \
-       | --with-sybase-local=* | --with-wxwin=* | --with-orbacus=* \
+       | --with-z=* | --with-bz2=* | --with-lzo=* \
+       | --with-pcre=* \
+       | --with-gnutls=* | --with-openssl=* \
+       | --with-sybase-local=* | --with-wxwin=* | --with-wxwidgets=* \
        | --with-ftds=* | --with-mysql=* | --with-fltk=* | --with-fastcgi=* \
-       | --with-bdb=* | --with-odbc=* | --with-gif=* | --with-jpeg=* \
+       | --with-sqlite=* | --with-sqlite3=* | --with-expat=* | --with-sablot=* \
+       | --with-icu=* | --with-xerces=* | --with-xalan=* \
+       | --with-libxml=* | --with-libxslt=* \
+       | --with-bdb=* | --with-odbc | --with-odbc=* \
+       | --with-python=* | --with-freetype=* | --with-gif=* | --with-jpeg=* \
        | --with-png=* | --with-tiff=* | --with-xpm=* | --with-opengl=* \
-       | --with-mesa=* | --with-glut=* \
+       | --with-mesa=* | --with-glut=* | --with-oechem=* | --with-cppunit=* \
+       | --with-boost=* | --with-boost-tag=* | --with-orbacus=* | --with-sge=* \
+       | --with-muparser=* | --with-hdf5=* \
+       | --x-includes=* | --x-libraries=* \
        | --target=* | --with-runpath=* | --no-create | --no-recursion)
        ;;
        * )
-       AC_MSG_ERROR(["  $x_arg:  unknown option;  use --help to show usage"])
+       AC_MSG_ERROR([$x_arg:  unknown option;  use --help to show usage])
        ;;
     esac
  done
+ if test "$with_gbench" = "yes" ; then
+    m4_foreach(OPT, [dll,mt,gui,exe,dbapi,serial,objects,algo,app],
+      [if test "$[with_]OPT" = "no"; then
+          AC_MSG_ERROR([incompatible options: --without-]OPT[ but --with-gbench])
+       else
+          [with_]OPT=yes
+       fi
+      ])
+    : ${with_projects=scripts/projects/ncbi_gbench.lst}
+ fi
+ if test "$with_bin_release" = "yes" ; then
+    # Default some other options accordingly
+    : ${with_ncbi_public=yes}
+    : ${with_dll=no}
+    : ${with_local_lbsm=no}
+    : ${with_ncbi_crypt=no}
+    : ${with_connext=no}
+    AC_DEFINE(NCBI_BIN_RELEASE, 1,
+              [Define to 1 when building binaries for public release.])
+ fi
  #### Check for special options
  if test "$with_extra_action" = "yes" ; then
-    AC_MSG_ERROR(["--with-extra-action must have a value after ="])
+    AC_MSG_ERROR([--with-extra-action must have a value after =])
  fi
  if test "$with_extra_action" = "no" ; then
-    AC_MSG_ERROR(["--without-extra-action is not allowed"])
+    AC_MSG_ERROR([--without-extra-action is not allowed])
+ fi
+ case "$with_projects" in
+  "") if test -r projects; then
+         AC_MSG_NOTICE([using default projects file "projects".])
+         with_projects=projects
+         AC_SUBST(PROJECTS, "\$(top_srcdir)/projects")
+      else
+         AC_SUBST(PROJECTS, "")
+         if test -f projects; then
+            AC_MSG_WARN([default projects file "projects" is unreadable.])
+         elif test -h projects; then
+            AC_MSG_WARN([default projects file "projects" is a dangling link.])
+         fi
  fi
+      ;;
+  no) with_projects="" ;  AC_SUBST(PROJECTS, "") ;;
+  /*) AC_SUBST(PROJECTS, $with_projects) ;;
+  * ) AC_SUBST(PROJECTS, "\$(top_srcdir)/$with_projects") ;;
+ esac
  #### Always define this
-Line 317
+Line 525
  #### Get the running host's properties
+ AC_CONFIG_AUX_DIR(src/build-system)
  AC_CANONICAL_HOST
  AC_DEFINE_UNQUOTED(HOST,        "$host",        [Full GNU-style system type])
  AC_DEFINE_UNQUOTED(HOST_CPU,    "$host_cpu",    [CPU type only])
-Line 335
+Line 544
  #### Detect Insure++, and attempt to find the real compiler.
- case "$CC" in
+ case "$CXX" in
     insure* | */insure*)
-       psrcdump=`echo "$CC" | sed -e 's/insure.*/psrcdump/'`
+       psrcdump=`echo "$CXX" | sed -e 's/insure.*/psrcdump/'`
-       real_CC=`$psrcdump -t insure++ | sed -ne 's/^Compiler \(.*\)/\1/p'`
+       real_CXX=`$psrcdump -t insure++ | sed -ne 's/^Compiler \(.*\)/\1/p'`
        real_dir=`$psrcdump -t insure++ | sed -ne 's/^Compilerinstalldir \(.*\)/\1/p'`
-       test -n "$real_dir" && test -x "$real_dir/$real_CC" && \
+       test -n "$real_dir" && test -x "$real_dir/$real_CXX" && \
-         real_CC="$real_dir/$real_CC"
+         real_CXX="$real_dir/$real_CXX"
-       case "$real_CC" in
+       case "$real_CXX" in
            *gcc* ) LIBS="$LIBS -lstdc++"
        esac
        ;;
     *)
-       real_CC=$CC
+       real_CXX=$CXX
        ;;
  esac
-Line 355
+Line 564
  #### Detect KCC compiler
  if test "$GCC" != "yes" ; then
     touch kcc_test.cpp
-    kcc_ver="`$real_CC -V -c kcc_test.cpp 2>&1 | grep '^KAI '`"
+    kcc_ver="`$real_CXX -V -c kcc_test.cpp 2>&1 | grep '^KAI '`"
-    kcc_license="`$real_CC -V -c kcc_test.cpp 2>&1 | grep -v '^KAI '`"
+    kcc_license="`$real_CXX -V -c kcc_test.cpp 2>&1 | grep -v '^KAI '`"
     rm -f kcc_test.cpp kcc_test.o
     case "$kcc_ver" in
        KAI* )  KCC="yes" ;;
-Line 364
+Line 573
  fi
- #### Detect ICC compiler
+ #### Detect ICC compiler (newer versions of which configure can mis-ID as GCC)
- if test "$GCC" != "yes"  -a  "$KCC" != "yes"; then
+ if test "$KCC" != "yes"; then
-    icc_ver="`$real_CC -V 2>&1 | grep '^Intel(R) C++ Compiler'`"
+    icc_ver="`$real_CXX -V 2>&1 | grep '^Intel(R) C'`"
-    icc_license="`$real_CC -c 2>&1 | grep '^icc: NOTE: The evaluation period for this product ends on '`"
+    icc_license="`$real_CXX -c 2>&1 | grep '^icc: NOTE: The evaluation period for this product ends on '`"
     case "$icc_ver" in
-       Intel*C*Compiler* )  ICC="yes" ;;
+       Intel*C*Compiler* )  ICC="yes"; GCC="no" ;;
     esac
  fi
  #### Detect IBM VisualAge compiler
  if test "$GCC" != "yes"  -a  "$KCC" != "yes"  -a  "$ICC" != "yes"; then
-    # Crude, but there doesn't seem to be a better alternative
+    vac_ver="`$real_CXX -qversion 2>&1`"
-    vac_ver="`$real_CC 2>&1 | grep 'AIX Compiler.*Version'`"
     case "$vac_ver" in
        *AIX* ) VAC="yes" ;;
     esac
-Line 387
+Line 595
  #### Detect Compaq compiler
  if test "$GCC" != "yes"  -a  "$KCC" != "yes"  -a  "$ICC" != "yes" \
    -a  "$VAC" != "yes"; then
-    # Must use CXX rather than real_CC to ensure correct version number.
+    ccc_ver="`$real_CXX -V 2>&1 | grep '^Compaq C++ V'`"
-    ccc_ver="`$CXX -V 2>&1 | grep '^Compaq C++ V'`"
     case "$ccc_ver" in
        *Compaq* ) CCC="yes" ;;
     esac
-Line 396
+Line 603
  #### Detect supported compilers
- changequote(, )dnl
  compiler=
  compiler_ver=
  ncbi_compiler="UNKNOWN"
  ncbi_compiler_ver="0"
  if test "$GCC" = "yes" ; then
-    compiler_ver="`$real_CC -dumpversion 2>&1`"
+    compiler_ver="`$real_CXX -dumpversion 2>&1`"
     case "$compiler_ver" in
-.95* | 2.96* | 3.* )
+.95* | 2.96* | 3.* | 4.* )
         compiler="GCC"
         ncbi_compiler="GCC"
-        ncbi_compiler_ver="$compiler_ver" ;;
+        ncbi_compiler_ver="$compiler_ver"
+        NCBI_FEATURE(GCC)
+        ;;
     esac
  elif test "$KCC" = "yes" ; then
     compiler_ver="$kcc_ver"
     compiler="KCC"
     ncbi_compiler="KCC"
-    ncbi_compiler_ver="`echo $kcc_ver | sed 's%^KAI .*C[+][+] \([0-9.]*\).*%\1%'`"
+    ncbi_compiler_ver="`echo $kcc_ver | sed 's%^KAI .*C[[+]][[+]] \([[0-9.]]*\).*%\1%'`"
+    NCBI_FEATURE(KCC)
  elif test "$ICC" = "yes" ; then
     compiler_ver="$icc_ver"
     compiler="ICC"
     ncbi_compiler="ICC"
-    ncbi_compiler_ver="`echo $icc_ver | sed 's%.*Version \([0-9.]*\).*%\1%'`"
+    ncbi_compiler_ver="`echo $icc_ver | sed 's%.*Version \([[0-9.]]*\).*%\1%'`"
+    NCBI_FEATURE(ICC)
  elif test "$VAC" = "yes" ; then
     compiler_ver="$vac_ver"
     compiler="VisualAge"
     ncbi_compiler="VISUALAGE"
-    ncbi_compiler_ver="`echo $vac_ver | sed 's%.*Version \([0-9.]*\).*%\1%'`"
+    ncbi_compiler_ver="`echo $vac_ver | sed 's%.*[[Vv]]ersion:* 0*\([[0-9.]]*\).*%\1%'`"
+    NCBI_FEATURE(VisualAge)
  elif test "$CCC" = "yes" ; then
     compiler_ver="$ccc_ver"
     compiler=Compaq
     ncbi_compiler="COMPAQ"
-    ncbi_compiler_ver="`echo $ccc_ver | sed 's%.*C[+][+] V\([0-9.]*\).*%\1%'`"
+    ncbi_compiler_ver="`echo $ccc_ver | sed 's%.*C[[+]][[+]] V\([[0-9.]]*\).*%\1%'`"
+    NCBI_FEATURE(CompaqCompiler)
  else
     case "$host_os" in
      solaris* )
-       compiler_ver="`$real_CC -V 2>&1`"
+       compiler_ver="`$real_CXX -V 2>&1`"
        case "$compiler_ver" in
          *WorkShop*Compilers*5\.0 )
            compiler="WorkShop5"
-Line 455
+Line 667
            compiler="WorkShop54"
            ncbi_compiler="WORKSHOP"
            ncbi_compiler_ver="5.4" ;;
-       esac ;;
+         *Sun*C*5\.5* )
+           compiler="WorkShop55"
+           ncbi_compiler="WORKSHOP"
+           ncbi_compiler_ver="5.5" ;;
+         *Sun*C*5\.8* )
+           compiler="WorkShop58"
+           ncbi_compiler="WORKSHOP"
+           ncbi_compiler_ver="5.8" ;;
+         *Sun*C*5\.9* )
+           compiler="WorkShop59"
+           ncbi_compiler="WORKSHOP"
+           ncbi_compiler_ver="5.9" ;;
+         *Sun*C*5\.10* )
+           compiler="WorkShop510"
+           ncbi_compiler="WORKSHOP"
+           ncbi_compiler_ver="5.10" ;;
+       esac
+       NCBI_FEATURE(WorkShop)
+       ;;
      irix* )
-       compiler_ver="`$real_CC -version 2>&1`"
+       compiler_ver="`$real_CXX -version 2>&1`"
        case "$compiler_ver" in
          MIPSpro*Compilers:*Version*7\.3* )
            compiler="MIPSpro73"
            ncbi_compiler="MIPSPRO"
-           ncbi_compiler_ver="7.3" ;;
+           ncbi_compiler_ver="7.3"
-       esac ;;
+           NCBI_FEATURE(MIPSpro)
+           ;;
+       esac
+       ;;
      cygwin* )
-       case "$real_CC" in
+       case "$real_CXX" in
          *cl\.exe* | cl)
            compiler="MSVC"
            ncbi_compiler="MSVC"
-           ncbi_compiler_ver="6.0" ;;
+           ncbi_compiler_ver="6.0"
-       esac ;;
+           NCBI_FEATURE(MSVC)
+           ;;
+       esac
+       ;;
     esac
  fi
- ncbi_compiler_ver="`echo $ncbi_compiler_ver | sed 's%\([0-9]\)\.\([0-9]\)\.\([0-9]\).*%\1\2\3%; s%\([0-9]\)\.\([0-9][0-9]*\).*%\1\2%; s%^\([0-9][0-9]\)$%\10%; s%^\([0-9]\)$%\100%'`"
+ changequote(, )dnl
- compiler_version=$ncbi_compiler_ver
+ #ncbi_compiler_ver="`echo $ncbi_compiler_ver | sed 's%\([0-9]\)\.\([0-9]\)\.\([0-9]\).*%\1\2\3%; s%\([0-9]\)\.\([0-9][0-9]*\).*%\1\2%; s%^\([0-9][0-9]\)$%\10%; s%^\([0-9]\)$%\100%'`"
+ case "$compiler:$ncbi_compiler_ver" in
+     WorkShop*:?.?? )   ncbi_compiler_sed='s/\([0-9]\)\.\([0-9][0-9]\)/\1\20/' ;;
+     WorkShop*:[6-9].?) ncbi_compiler_sed='s/\([0-9]\)\.\([0-9\)/\10\20/' ;;
+     ICC:??.? )  ncbi_compiler_sed='s/\([0-9][0-9]\)\.\([0-9]\)/\1\20/' ;;
+     *:?.?.?)    ncbi_compiler_sed='s/\([0-9]\)\.\([0-9]\)\.\([0-9]\)/\1\2\3/' ;;
+     *:?.??*)    ncbi_compiler_sed='s/\([0-9]\)\.\([0-9][0-9]\).*/\1\2/' ;;
+     *:?.?)      ncbi_compiler_sed='s/\([0-9]\).\([0-9]\)/\1\20/' ;;
+     *:?)        ncbi_compiler_sed='s/\([0-9]\)/\100/' ;;
+ esac
  changequote([, ])dnl
+ ncbi_compiler_ver=`echo $ncbi_compiler_ver | sed "$ncbi_compiler_sed"`
+ compiler_version=$ncbi_compiler_ver
  # Possible values of NCBI_COMPILER_$ncbi_compiler, since acconfig.h is obsolete
  if false; then
-Line 493
+Line 740
     AC_DEFINE(NCBI_COMPILER_UNKNOWN,   1, [Compiler name])
  fi
+ AC_DEFINE_UNQUOTED(NCBI_COMPILER, "$ncbi_compiler", [Compiler name])
  AC_DEFINE_UNQUOTED(NCBI_COMPILER_$ncbi_compiler, 1, [Compiler name])
  AC_DEFINE_UNQUOTED(NCBI_COMPILER_VERSION, $ncbi_compiler_ver,
                     [Compiler version as three-digit integer])
-Line 505
+Line 753
         echo
         echo "Compiler \"${compiler}\" requires a special tuning, so you"
         echo "better use a special shell script located in \"compilers/*.sh\"!"
- changequote(, )dnl
+        NCBI_CAUTION([Do you still want to proceed (at your own risk)?])
-        echo "Do you still want to proceed (at your own risk)? [n/y]"
- changequote([, ])dnl
-        read answer
-        case "$answer" in
-          y )  AC_MSG_WARN([Proceeding at your own risk...]) ; echo ;;
-          * )  AC_MSG_WARN([Configuration has been canceled by user.]) ; exit 1;;
-        esac
         echo
      fi ;;
  esac
-Line 550
+Line 791
  x_CXX=
  if test "$with_static_exe" = "yes"; then
-    C_LINK='$(top_srcdir)/scripts/favor-static $(CC)'
+    C_LINK='$(top_srcdir)/scripts/common/impl/favor-static $(CC)'
-    LINK='$(top_srcdir)/scripts/favor-static $(CXX)'
+    LINK='$(top_srcdir)/scripts/common/impl/favor-static $(CXX)'
  else
     C_LINK='$(CC)'
     LINK='$(CXX)'
-Line 568
+Line 809
  with_mt=${with_mt:="no"}
  if test "$with_mt" = "yes" ; then
     case "$host_os:$compiler" in
-     solaris*:WorkShop*              )  MT_FLAG=${MT_FLAG:="-mt"} ;;
+     darwin* | irix* | cygwin*)  ;;
-     *:KCC                           )  MT_FLAG=${MT_FLAG:="--thread_safe"} ;;
+     solaris*:WorkShop*       )  : ${MT_FLAG:="-mt"} ;;
-     *:Compaq | freebsd*:GCC         )  MT_FLAG=${MT_FLAG:="-pthread"} ;;
+     solaris*:GCC             )  : ${MT_FLAG:="-pthreads"} ;;
-     *:GCC | *:ICC | irix*:MIPSpro73 )  ;;
+     *:KCC                    )  : ${MT_FLAG:="--thread_safe"} ;;
-     * )   AC_MSG_ERROR(["Do not know how to build MT-safe with compiler $CXX $compiler_ver"]) ;;
+     *:Compaq | *:GCC | *:ICC )  : ${MT_FLAG:="-pthread"} ;;
+     *:VisualAge              )  : ${MT_FLAG:="-qthreaded"} ;;
+     * )   AC_MSG_ERROR([Do not know how to build MT-safe with compiler $CXX $compiler_ver]) ;;
     esac
     CPPFLAGS="$CPPFLAGS -D_MT -D_REENTRANT -D_THREAD_SAFE"
-    case "$host_os" in
+    case "$host_os:$compiler" in
-      solaris* )  THREAD_LIBS=${THREAD_LIBS:="-lpthread -lposix4"} ;;
+      solaris2.10:GCC ) : ${THREAD_LIBS:="-lposix4"} ;;
+      solaris*        ) : ${THREAD_LIBS:="-lpthread -lposix4"} ;;
       freebsd* )  ;; # -pthread already substitutes libc_r for libc
-      *        )  THREAD_LIBS=${THREAD_LIBS:="-lpthread"} ;;
+      *               ) : ${THREAD_LIBS:="-lpthread"} ;;
     esac
     LIBS="$LIBS $THREAD_LIBS"
+    case "$host_os:$compiler" in
+      solaris2.??:* | solaris*:GCC | *:Compaq | irix* | aix* | darwin* | cygwin*)
+         NCBIATOMIC_LIB=
+         ;;
+      *:GCC | *:ICC | linux*:KCC )
+         case "$host_cpu" in
+            i?86 | powerpc* | ppc* | x86_64 | sparc* ) NCBIATOMIC_LIB= ;;
+            * ) NCBIATOMIC_LIB=xncbi ;;
+         esac
+         ;;
+      *:WorkShop* | solaris*:KCC )
+         NCBIATOMIC_LIB=xncbi
+         ncbicntr="ncbicntr_workshop ncbiatomic_workshop"
+         ;;
+      * ) NCBIATOMIC_LIB=xncbi ;;
+    esac
     mt_sfx="MT"
-    WithFeatures="$WithFeatures MT"
+    NCBI_FEATURE(MT)
  else
+    CPPFLAGS="$CPPFLAGS -DNCBI_WITHOUT_MT"
     MT_FLAG=
     THREAD_LIBS=
+    NCBIATOMIC_LIB=
     mt_sfx=""
  fi
  MT_SFX="${mt_sfx}"
-Line 595
+Line 857
  CXXFLAGS="$MT_FLAG $CXXFLAGS"
  LDFLAGS="$MT_FLAG $LDFLAGS"
+ APP_LDFLAGS=
+ DLL_LDFLAGS=
+ case "$compiler" in
+    GCC | ICC )
+       AC_CACHE_CHECK([whether $CC supports -Wl,-E], ncbi_cv_prog_cc_wl_e,
+          [orig_LDFLAGS=$LDFLAGS
+           LDFLAGS="-Wl,-E $LDFLAGS"
+           AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
+              [ncbi_cv_prog_cc_wl_e=yes], [ncbi_cv_prog_cc_wl_e=no])
+           LDFLAGS=$orig_LDFLAGS])
+       test "$ncbi_cv_prog_cc_wl_e" = no  ||  APP_LDFLAGS="-Wl,-E $APP_LDFLAGS"
+       ;;
+ esac
  #### Provide default environment setup for known platforms/compilers
  DEPFLAGS="-M"
-Line 606
+Line 882
     ;;
   solaris*:GCC )
+    CPPFLAGS="-D_XOPEN_SOURCE=500 $CPPFLAGS"
     STRIP="@:"
     ;;
-  linux*:GCC )
-    LDFLAGS="-Wl,-E $LDFLAGS"
-    # May be needed for pthread_{set,get}concurrency
-    CPPFLAGS="-D_GNU_SOURCE $CPPFLAGS"
-    ;;
   linux*:ICC )
     # "incomplete type is not allowed" should be an error, not a warning!
     CFLAGS="-we70 $CFLAGS"
     CXXFLAGS="-we70 $CXXFLAGS"
-    # May be needed for pthread_{set,get}concurrency
-    CPPFLAGS="-D_GNU_SOURCE $CPPFLAGS"
-    ;;
-  linux*)
-    # May be needed for pthread_{set,get}concurrency
-    CPPFLAGS="-D_GNU_SOURCE $CPPFLAGS"
-    ;;
-  osf*:GCC )
     ;;
   irix*:GCC )
-Line 638
+Line 899
     ;;
   solaris*:WorkShop* )
+    CPPFLAGS="-D__EXTENSIONS__ $CPPFLAGS"
     CXXFLAGS="+w +w2 $CXXFLAGS"
     DEPFLAGS="-xM1"
     LDFLAGS="-xildoff $LDFLAGS"
     AR=${AR:="$CXX $MT_FLAG -xar -o"}
     STRIP="@:"
-    if test "$with_debug" = "no" -a "$with_profiling" != "yes" ; then
+    if test "$with_debug" = "no" -a "$with_profiling" != "yes" \
+       -a "$with_strip" = "yes" ; then
        LDFLAGS="-s $LDFLAGS"
     fi
-    RANLIB=":"
+    # Recent versions default to DWARF, yielding much larger executables in
-    CXX_FILTER="2>&1 | \$(top_srcdir)/compilers/cxx_filter.$compiler.sh"
+    # debug configurations; insist on STABS when the choice exists, even for
+    # versions that already default to it.
+    case "$with_debug:$compiler" in
+       no:* | *:WorkShop5[[0-4]] ) ;;
+       * )
+          CFLAGS="-xdebugformat=stabs $CFLAGS"
+          CXXFLAGS="-xdebugformat=stabs $CXXFLAGS"
+          ;;
+    esac
+    CXX_FILTER="2>&1 | \$(top_srcdir)/compilers/unix/cxx_filter.WorkShop.sh"
     LINK_FILTER="$CXX_FILTER"
     AR_FILTER="$CXX_FILTER"
     serial_ws50_rtti_kludge="rtti"
-    ncbicntr="ncbicntr_workshop"
     ;;
   irix*:MIPSpro73 )
-Line 665
+Line 936
     # 1460: Function %n is redeclared "inline" after being called.
     # 1521: A nonstandard preprocessing directive is used.
     CFLAGS="$COMMON_FLAGS -woff 1209 $CFLAGS"
-    CXXFLAGS="$COMMON_FLAGS -ansiW -ptused -LANG:std -LANG:ansi-for-init-scope -woff 1460,1521,1429,1169,1209,1107,1424 $CXXFLAGS"
+    CXXFLAGS="$COMMON_FLAGS -ansiW -ptused -FE:eliminate_duplicate_inline_copies -FE:template_in_elf_section -no_auto_include -LANG:std -LANG:ansi-for-init-scope -woff 1460,1521,1429,1169,1209,1107,1424 $CXXFLAGS"
-    CXXCPP=${CXXCPP:="$CXX -E -LANG:std"}
+    : ${CXXCPP:="$CXX -E -LANG:std"}
-    LDFLAGS="-LANG:std $LDFLAGS"
+    LDFLAGS="-LANG:std -G0 -FE:eliminate_duplicate_inline_copies -FE:template_in_elf_section $LDFLAGS"
     CPPFLAGS="-D__LONGLONG $CPPFLAGS"
-    CXX_FILTER="2>&1 | \$(top_srcdir)/compilers/cxx_filter.$compiler.sh"
+    CXX_FILTER="2>&1 | \$(top_srcdir)/compilers/unix/cxx_filter.$compiler.sh"
     ;;
   cygwin*:GCC )
     with_dll="no"
-    NETWORK_LIBS=${NETWORK_LIBS:="-lwsock32"}
+    : ${NETWORK_LIBS:="-lws2_32"}
     CONF_exe_ext=".exe"
     ;;
-Line 703
+Line 974
     make_shell=""
     ;;
-  aix*:VisualAge)
+  *:VisualAge)
-    CXXFLAGS="-qrtti=all $CXXFLAGS"
+    # 1506-1108 (I) The use of keyword '__attribute__' is non-portable.
+    CFLAGS="-qlanglvl=extc99 -qsuppress=1506-1108 $CFLAGS"
+    # 1540-1663 (W) Incorrect assignment of a restrict qualified pointer.
+    CXXFLAGS="-qrtti=all -qsuppress=1540-1663 $CXXFLAGS"
     DEPFLAGS="-E -M"
     DEPFLAGS_POST='>/dev/null 2>&1; (cat $*.u; rm -f $*.u)'
     ;;
-Line 712
+Line 986
   *:Compaq)
     CPPFLAGS="-D__USE_STD_IOSTREAM $CPPFLAGS"
     CXXFLAGS="-tweak -nocompress -distinguish_nested_enums $CXXFLAGS"
+    DEPFLAGS="$DEPFLAGS -distinguish_nested_enums"
     case "$host_os" in
        osf*)
          # Suppress link warnings; otherwise, we get "weak symbol multiply
-Line 730
+Line 1005
     CONF_dll_ext=".dylib"
     CONF_loadable_ext=".so"
     if $CXX -v 2>&1 | grep -q Apple; then
-       # Suppress warnings about potential changes in the size of long double;
+       CFLAGS="-fpascal-strings $CFLAGS"
-       # our ABI isn't too stable yet anyway.
+       CXXFLAGS="-fno-permissive -fpascal-strings $CXXFLAGS"
-       # -fno-common is only necessary when building shared libraries,
+       # -flat_namespace is necessary for proper handling of shared libraries
-       # but sometimes they include static libs....
+       # that don't themselves link against all their dependencies.
-       CFLAGS="-Wno-long-double -fno-common $CFLAGS"
+       LDFLAGS="-flat_namespace $LD_FLAGS"
-       CXXFLAGS="-Wno-long-double -fno-common $CXXFLAGS"
+       if test "$with_ncbi_public" = yes; then
+          CC="$CC -mmacosx-version-min=10.4"
+          CXX="$CXX -mmacosx-version-min=10.4"
+       fi
+    else
+       LDFLAGS="-Wl,-flat_namespace $LD_FLAGS"
+    fi
+    if test -f /usr/include/dlfcn.h; then
+       # may be able to do without /sw, so ignore it by default
+       :
+    elif test -f /sw/include/dlfcn.h; then
+       CPPFLAGS="-I/sw/include $CPPFLAGS"
+       LDFLAGS="-L/sw/lib $LDFLAGS"
+    else
+       AC_MSG_WARN([No dlfcn.h in /usr/include or /sw/include.])
+    fi
+    case "$CPPFLAGS $LIBS" in
+       *sw/*) ;;
+       *)
+          if test -d "$NCBI/safe-sw"; then
+              CPPFLAGS="-I$NCBI/safe-sw/include $CPPFLAGS"
+              LDFLAGS="-L$NCBI/safe-sw/lib $LDFLAGS"
     fi
-    CPPFLAGS="-F/System/Library/Frameworks/CoreServices.framework/Frameworks -I/sw/include $CPPFLAGS"
+          ;;
-    LIBS="-Wl,-framework,ApplicationServices -L/sw/lib $LIBS"
+    esac
+    CPPFLAGS="-F/System/Library/Frameworks/CoreServices.framework/Frameworks $CPPFLAGS"
+    LIBS="-Wl,-framework,ApplicationServices $LIBS"
     ;;
  esac
-Line 752
+Line 1052
  #### Check if the compiler matches one of supported compilers on this platform
  if test -z "$compiler" ; then
- changequote(, )dnl
     cat <<EOF
    Compiler $CXX $compiler_ver is not fully supported.
-   Consult doc/config.html#ref_Compilers for the list of
+   Consult doc/config.html\#ref_Compilers for the list of
    fully supported platforms/compilers.
-   Do you still want to proceed (at your own risk)? [n/y]
  EOF
- changequote([, ])dnl
+    NCBI_CAUTION([Do you still want to proceed (at your own risk)?])
-    read answer
+    echo
-    case "$answer" in
-       y )  AC_MSG_WARN([Proceeding at your own risk...]) ; echo ;;
-       * )  AC_MSG_WARN([Configuration has been canceled by user.]) ; exit 1 ;;
-    esac
     compiler="UNKNOWN"
  fi
-Line 774
+Line 1068
  case "$host_os:$compiler" in
     *:GCC | *:KCC | *:ICC )
        compiler_pfx="${compiler}-"
-       compiler_vpfx=`echo "${compiler}${compiler_ver}-" | \
+       compiler_vpfx="${compiler}${compiler_version}-"
-          sed -e 's/\.//g; s/[\([0-9][0-9][0-9]\)[0-9]*]/\1/'`
        ;;
  esac
-Line 783
+Line 1076
  C_LIBS=$LIBS
- #### 32/64-bit compilation, and extra C++ LIBS
+ #### architecture settings, and extra C++ LIBS
- : ${with_64:="no"}
+ if test "${with_universal-no}" != "no" ; then
- if test "$with_64" = "yes" ; then
+    bit64_sfx= #"Univ"
+    case "$host" in
+     *-*-darwin[[89]].* | *-*-darwin[[1-9]][[0-9]]* )
+       case "$with_universal" in
+        yes )
+           case "$with_64:$host_os" in
+            yes:darwin8.* )
+              AC_MSG_ERROR([Unable to build 64-bit universal binaries on $host])
+              ;;
+            yes:* )
+              ARCH_CFLAGS="-arch ppc64 -arch x86_64"
+              ;;
+            * )
+              ARCH_CFLAGS="-arch ppc -arch i386"
+              ;;
+           esac
+           ;;
+        * )
+          ARCH_CFLAGS="-arch `echo $with_universal | sed -e 's/,/ -arch /g'`"
+          ;;
+       esac
+       case "$host" in
+        p*pc*-*-darwin8.*)
+          # Must specify -isysroot ..., but only once; anyway, the preprocessor
+          # needs to see it, and naturally can't cope with multiple -arch flags.
+          # The -mmacosx-version-min flag avoids link errors under OS 10.5
+          # (Darwin 9), which otherwise tries to use crt1.10.5.o despite the
+          # request for a sysroot lacking that file.
+          SYSROOT="-isysroot /Developer/SDKs/MacOSX10.4u.sdk -mmacosx-version-min=10.4"
+          #ARCH_CFLAGS="$SYSROOT $ARCH_CFLAGS"
+          CC="$CC $SYSROOT"
+          CXX="$CXX $SYSROOT"
+          ;;
+       esac
+       ;;
+     * ) AC_MSG_ERROR([Do not know how to build universal binaries on $host]) ;;
+    esac
+    AC_DEFINE(NCBI_UNIVERSAL_BUILD, 1,
+              [Define to 1 if building universal (multi-architecture) binaries.])
+    with_distcc=no
+ elif test "$with_64" = "yes" ; then
     bit64_sfx="64"
     case "$host:$compiler" in
      sparc-sun-solaris*:WorkShop5 | sparc-sun-solaris*:KCC )
-Line 793
+Line 1126
        ;;
      sparc-sun-solaris*:WorkShop51 )
        ARCH_CFLAGS="-xtarget=ultra -xarch=v9"
-       LIBS="-Bstatic -L$CXX_PATH/../lib -lCstd -lCrun -Bdynamic $LIBS"
+       LIBS="-Bstatic -L$CXX_PATH/../lib -lCstd -lCrun -Bdynamic $LIBS -lc"
+       ;;
+     *solaris*:WorkShop59 | *solaris*:WorkShop51? )
+       ARCH_CFLAGS="-m64"
+       LIBS="-lCstd -lCrun $LIBS -lc"
        ;;
  changequote(, )dnl
-     sparc-sun-solaris*:WorkShop5[234] )
+     *solaris*:WorkShop5* )
-       ARCH_CFLAGS="-xtarget=ultra -xarch=v9"
+       ARCH_CFLAGS="-xtarget=generic64"
        # Redundant for programs, but necessary for dlopen-able shared libs,
        # at least in the x86 ReleaseMT configuration.
-       LIBS="-lCstd $LIBS"
+       LIBS="-lCstd -lCrun $LIBS -lc"
        ;;
  changequote([, ])dnl
-     sparc-*:GCC )
+     mips*:GCC )
+       ARCH_CFLAGS="-mips64"
+       ;;
+     *:GCC )
        # May not work prior to GCC 3.1.
        ARCH_CFLAGS="-m64"
        ;;
-Line 817
+Line 1157
        ARCH_CFLAGS="-64"
        ;;
      * )
-       AC_MSG_ERROR(["Do not know how to compile 64-bit with compiler $CXX $compiler_ver $host:$compiler"])
+       AC_MSG_ERROR([Do not know how to compile 64-bit with compiler $CXX $compiler_ver $host:$compiler])
        ;;
     esac
  else
     bit64_sfx=
     ARCH_CFLAGS=
-    case "$host_os:$compiler" in
+    if test "$with_64" = "no" ; then
-     solaris*:WorkShop5 )
+       case "$host:$compiler" in
+        *solaris*:WorkShop* | *solaris*:KCC )
+          ARCH_CFLAGS="-xtarget=generic"
+          ;;
+        mips*:GCC )
+          ARCH_CFLAGS="-mipsn32"
+          ;;
+        *:GCC )
+          # May not work prior to GCC 3.1.
+          ARCH_CFLAGS="-m32"
+          ;;
+        mips-sgi-irix*:MIPSpro73 )
+          ARCH_CFLAGS="-n32"
+          CPPFLAGS="$ARCH_CFLAGS $CPPFLAGS"
+          AR=${AR:="$CXX $ARCH_CFLAGS -ar -WR,-v -o"}
+          ;;
+        mips-sgi-irix*:KCC )
+          ARCH_CFLAGS="-n32"
+          ;;
+        * )
+          # Just a warning, since 32-bit mode is typically the default anyway...
+          AC_MSG_WARN([Do not know how to compile 32-bit with compiler $CXX $compiler_ver $host:$compiler])
+          ;;
+       esac
+    fi
+    case "$host:$compiler" in
+     *solaris*:WorkShop5 )
        LIBS="-Bstatic -L$CXX_PATH/../SC5.0/lib -lm -Bdynamic $LIBS"
        MATH_LIBS=" "
        ;;
-     solaris*:WorkShop51 )
+     *solaris*:WorkShop51 )
-       LIBS="-Bstatic -L$CXX_PATH/../lib -lCstd -lCrun -lm -Bdynamic $LIBS"
+       LIBS="-Bstatic -L$CXX_PATH/../lib -lCstd -lCrun -lm -Bdynamic $LIBS -lc"
        MATH_LIBS=" "
        ;;
+     sparc-sun-solaris*:WorkShop54 )
+       # Using this (still very conservative) non-generic XARCH flavor allows
+       # compiler to use the extended instruction set which reportedly speeds
+       # up the locking of at least some STL classes by allowing them to use
+       # atomic increment instead of mutex;  also seems to fix something that
+       # caused misterios basic_string<> related crashes in the
+       # WorkShop54 -xarch=v8 -mt configuration).
+       ARCH_CFLAGS="-xarch=v8plus"
+       LIBS="-lCstd $LIBS -lCrun -lc"
+       ;;
  changequote(, )dnl
-     solaris*:WorkShop5[234] )
+     *solaris*:WorkShop5* )
        # MATH_LIBS=" "
        # Redundant for programs, but necessary for dlopen-able shared libs,
        # at least in the x86 ReleaseMT configuration.
-       LIBS="-lCstd $LIBS"
+       LIBS="-lCstd $LIBS -lCrun -lc"
        ;;
  changequote([, ])dnl
-     irix*:MIPSpro73 | irix*:KCC )
+     *irix*:MIPSpro73 | *irix*:KCC )
        ARCH_CFLAGS="-n32"
        ;;
     esac
  fi
+ case "$host_os:$host_cpu" in
+    linux*:alpha*)
+       ARCH_CFLAGS="-mieee $ARCH_CFLAGS"
+       ;;
+ esac
  CFLAGS="$ARCH_CFLAGS $CFLAGS"
  CXXFLAGS="$ARCH_CFLAGS $CXXFLAGS"
  LDFLAGS="$ARCH_CFLAGS $LDFLAGS"
+ : ${MATH_LIBS:="-lm"}
+ ### Math lib to be always linked in
+ LIBS="$MATH_LIBS $LIBS"
+ C_LIBS="$MATH_LIBS $C_LIBS"
+ if test -n "$with_64"; then
+    AC_CACHE_CHECK([whether this system supports --with(out)-64],
+       ncbi_cv_sys_with64_ok,
+       [AC_LINK_IFELSE([
+           AC_LANG_PROGRAM([#include <string>],
+                           [std::string* sp = new std::string("foo");])],
+           ncbi_cv_sys_with64_ok=yes, ncbi_cv_sys_with64_ok=no)])
+    if test "$ncbi_cv_sys_with64_ok" = no; then
+       AC_MSG_ERROR([cannot continue; please try different options])
+    fi
+ fi
  ### large file support (switch to AC_SYS_LARGEFILE?)
+ case "$host_os:$compiler:$compiler_version" in
+     *:GCC:3[[4-9]]* | *:GCC:[[4-9]]* | *:ICC:[[91]]* ) : ${with_lfs=yes} ;;
+ esac
  if test "$with_lfs" = "yes" ; then
     LFSFLAGS="-D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64"
     CPPFLAGS="$LFSFLAGS $CPPFLAGS"
-Line 860
+Line 1264
  #### Flags to enable (potentially unsafe) extra optimization.
  if test -z "$DEF_FAST_FLAGS"  -o  -z "$FAST_CXXFLAGS" ; then
-    case "$compiler" in
+    case "$compiler:$compiler_version" in
-       GCC )
+       GCC:2* | GCC:344 )
+         # GCC 2.9x sometimes experiences internal errors at high optimization;
+         # GCC 3.4.4 (at least on FreeBSD) meanwhile generates crashprone code.
+         DEF_FAST_FLAGS="-O2"
+         ;;
+       GCC:* )
          DEF_FAST_FLAGS="-O9 -finline-functions -ffast-math -fstrict-aliasing"
          if test "$with_profiling" != "yes"; then
             # incompatible with -pg
             DEF_FAST_FLAGS="$DEF_FAST_FLAGS -fomit-frame-pointer"
          fi
          ;;
+       WorkShop5[[89]]* | WorkShop510 )
+         # Limit optimization to -xO2 (-O now maps to -xO3) due to compiler bugs.
+         subst='s/[[     ]]-x*O[[1-9]]*//g'
+         CFLAGS="`  echo \" $CFLAGS\"   | sed -e \"$subst\"` -xO2"
+         CXXFLAGS="`echo \" $CXXFLAGS\" | sed -e \"$subst\"` -xO2"
+         LDFLAGS="` echo \" $LDFLAGS\"  | sed -e \"$subst\"` -xO2"
+         DEF_FAST_FLAGS="-xO2"
+         ;;
        WorkShop* )
-         # (Re)include ARCH_CFLAGS here because -fast implies -xtarget=native.
+         DEF_FAST_FLAGS="-fast"
-         DEF_FAST_FLAGS="-fast $ARCH_CFLAGS"
+         case "$with_ncbi_public:$host_cpu" in
-         case "$host_cpu" in
+            yes:sparc* )
+               DEF_FAST_FLAGS="$DEF_FAST_FLAGS -xtarget=ultra"
+               ;;
+            *:i?86)
+               case "$compiler_ver" in
+                 *5.[[0-4]]*)
             # Work around a WorkShop standard library bug.
-            i?86) DEF_FAST_FLAGS="$DEF_FAST_FLAGS -D_RWSTD_NO_TEST_AND_SET" ;;
+                   DEF_FAST_FLAGS="$DEF_FAST_FLAGS -D_RWSTD_NO_TEST_AND_SET"
+                   ;;
          esac
          ;;
-       KCC )
+         esac
+         # (Re)include ARCH_CFLAGS here because -fast implies -xtarget=native.
+         DEF_FAST_FLAGS="$DEF_FAST_FLAGS $ARCH_CFLAGS"
+         ;;
+       KCC:* )
          DEF_FAST_FLAGS="+K3"
          case "$host_os" in
             solaris* )  DEF_FAST_FLAGS="$DEF_FAST_FLAGS -fast $ARCH_CFLAGS" ;;
          esac
          ;;
-       ICC )
+       ICC:* )
-         if test "$with_mt" = "yes"; then
+         if test "$with_mt" = "yes" -a "$compiler_version" -lt 800; then
             DEF_FAST_FLAGS="-O3 -ip"
+         elif test "$compiler_version" -ge 800 -a "$compiler_version" -lt 900; then
+            DEF_FAST_FLAGS="-O2"
          else
             DEF_FAST_FLAGS="-O3 -axW -ip"
          fi
          ;;
        MIPSpro* )
-         DEF_FAST_FLAGS="-O3 -Ofast"
+         # -Ofast would be preferable, but runs into resource limits when
+         # building libxblast.so. :-/
+         DEF_FAST_FLAGS="-O2"
          ;;
-       Compaq )
+       Compaq:* )
          DEF_FAST_FLAGS="-fast"
          ;;
        * )
-Line 914
+Line 1345
  if test -z "$CFLAGS_DLL"  -a  -z "$CXXFLAGS_DLL" ; then
     case "$host_os:$compiler" in
      darwin*:GCC )
-       # Moved to regular flags, due to some cases of inclusion.
+       CFLAGS_DLL="-fno-common"
-       # CFLAGS_DLL="-fno-common"
+       CXXFLAGS_DLL="-fno-common"
-       # CXXFLAGS_DLL="-fno-common"
        ;;
-     *:GCC | linux*:KCC )
+     *:GCC | linux* )
        CFLAGS_DLL="-fPIC"
        CXXFLAGS_DLL="-fPIC"
        ;;
      solaris*:WorkShop* | irix*:MIPSpro73 | \
-     solaris*:KCC | irix*:KCC | linux*:ICC)
+     solaris*:KCC | irix*:KCC )
        CFLAGS_DLL="-KPIC"
        CXXFLAGS_DLL="-KPIC"
        ;;
-Line 951
+Line 1381
        ;;
     esac
  fi
+ case "$host_os" in
+     linux*|solaris* ) RUNPATH_ORIGIN="$CONF_f_runpath'\$\$ORIGIN'" ;;
+     * )               RUNPATH_ORIGIN="-DNCBI_RPO_SUFFIX_EATER=" ;;
+ esac
- case "$compiler:$compiler_version" in
+ case "$compiler:$compiler_version:$with_bin_release" in
-   GCC:3* )
+   GCC:*:yes )
+     libstdcxx=`$CXX $LDFLAGS -print-file-name=libstdc++.a`
+     case "$libstdcxx" in
+        /*)
+           LIBS="$libstdcxx $LIBS"
+           LINK=$C_LINK
+           ;;
+        *)
+           AC_MSG_WARN([Unable to find static libstdc++ requested by --with-bin-release.])
+           ;;
+     esac
+     ;;
+   GCC:* )
      # Need to specify runpath for compiler-provided libraries
      case $compiler_version in
 * ) major=3 ;;
 * ) major=4 ;;
-         *   ) major=5 ;; # ABI theoretically stable from 3.2 on
+[[23]]*) major=5 ;;
+         *       ) major=6 ;;
      esac
      found=false
      for f in libstdc++.so.$major libgcc_s.so.1 libstdc++.a; do
-Line 966
+Line 1413
          dir=`dirname "$path"`
          abs_dir=`cd "$dir" && pwd`
          case "$dir:$abs_dir" in
-             *:/lib | *:/usr/lib ) break ;; # no rpath needed
+             *:/lib | *:/usr/lib | *:/usr/lib32 | *:/usr/lib64 )
-             /*                  ) found=true; break ;;
+                # no rpath needed
+                break
+                ;;
+             /* )
+                found=true
+                break
+                ;;
          esac
      done
      if test "$found" = "true" -a -n "$CONF_f_runpath"; then
-Line 989
+Line 1442
      # (Undocumented, and unavailable at all in older versions. :-/)
      LDFLAGS="-static-libcxa $LDFLAGS"
      ;;
+   ICC:8* )
+     # In principle, these settings should work, and avoid the need to
+     # depend on Intel's libraries at runtime.
+     #  APP_LDFLAGS="-static-libcxa $APP_LDFLAGS"
+     #  DLL_LDFLAGS="-nodefaultlibs $DLL_LDFLAGS"
+     # In practice, they can break applications that use plugins. :-/
+     LDFLAGS="$CONF_f_runpath$compiler_root/lib $LDFLAGS"
+     ;;
+   ICC:9* )
+     # -i-static moved from common LDFLAGS to accommodate those few
+     # DLLs (plugins for external programs such as Python) that need to
+     # link ICC's libraries dynamically.
+     APP_LDFLAGS="-i-static $APP_LDFLAGS"
+     DLL_LDFLAGS="-i-static -nodefaultlibs $DLL_LDFLAGS"
+     # Running icpc on a bunch of object files doesn't always ensure that
+     # the C++ standard library is actually linked in, and we shouldn't
+     # rely on help from wrapper scripts.
+     LINK="$LINK -Kc++"
+     ;;
+   ICC:1???:* )
+     APP_LDFLAGS="-i-static $APP_LDFLAGS"
+     DLL_LDFLAGS="-i-static -nodefaultlibs $DLL_LDFLAGS"
+     # Redundant for apps, but necessary for plugins to be adequately
+     # self-contained, at least on 32-bit Linux.
+     LIBS="$LIBS -lstdc++"
+     LINK="$LINK -Kc++"
+     # Defining _GCC_NEXT_LIMITS_H ensures that <limits.h> chaining doesn't
+     # stop short, as can otherwise happen. :-/
+     CPPFLAGS="$CPPFLAGS -D_GCC_NEXT_LIMITS_H"
+     ;;
  esac
  # DLLs and profiling don't mix on all platforms
-Line 1010
+Line 1493
  if test "$with_dll" = "yes" ; then
     case "$host_os:$compiler" in
      linux*:GCC | irix*:* | solaris*:WorkShop* | *:KCC | linux*:ICC \
-     | solaris*:GCC | osf*:* )
+     | solaris*:GCC | osf*:* | darwin*:GCC | freebsd*:GCC )
        ;;
      * )
        echo
        echo "DLLs may not be buildable by $CXX $compiler_ver on $host!"
- changequote(, )dnl
+       NCBI_CAUTION([Do you still want to try build DLLs (at your own risk)?])
-       echo "Do you still want to try build DLLs (at your own risk)? [y/n]"
- changequote([, ])dnl
-       read answer
-       case "$answer" in
-          y | Y | yes | YES ) ;;
-          * )  AC_MSG_WARN([Configuration has been canceled by user.]) ; exit 1 ;;
-       esac
        echo
        ;;
     esac
-Line 1035
+Line 1511
     *)       LIB_OR_DLL="lib";  dll_sfx=""  ;;
  esac
- if test "$with_dll" = "no"; then # no DLLs whatsoever!
+ DLL=
-    FORCE_STATIC_LIB="LIB_OR_DLL = lib"
+ DLL_LIB_SETTING='$(DLL_DLIB)'
- else
+ IF_WITH_DLL=
-    FORCE_STATIC_LIB=
+ UNLESS_WITH_DLL='# '
- fi
- if test "$LIB_OR_DLL" = "both"; then
     STATIC="-static"
- else
+ USUAL_AND_DLL=both
+ USUAL_AND_LIB=both
+ case "$LIB_OR_DLL" in
+    dll)
     STATIC=
- fi
+        USUAL_AND_DLL=dll
+        ;;
+    lib)
+        DLL=-dll
+        DLL_LIB_SETTING='$(DLL_LIB)'
+        IF_WITH_DLL='# '
+        UNLESS_WITH_DLL=
+        USUAL_AND_LIB=lib
+        ;;
+ esac
+ AC_SUBST(DLL)
+ AC_SUBST(DLL_LIB_SETTING)
+ AC_SUBST(IF_WITH_DLL)
+ AC_SUBST(UNLESS_WITH_DLL)
  AC_SUBST(STATIC)
+ AC_SUBST(USUAL_AND_DLL)
+ AC_SUBST(USUAL_AND_LIB)
  #### GNU compiler::  common flags and definitions
-Line 1084
+Line 1577
     case "$host_os" in
        solaris* )  CPPFLAGS="-D__EXTENSIONS__ -D__STDC__=0 $CPPFLAGS" ;;
     esac
-    # Often hangs for no good reason :-/; limit time to ~17 minutes per instance
-    if test -x compilers/wrapper.KCC.sh; then
-       wrap="compilers/wrapper.KCC.sh"
-       CC_WRAPPER="$CC_WRAPPER $wrap"
-       CXX_WRAPPER="$CXX_WRAPPER $wrap"
-       AR_WRAPPER="$AR_WRAPPER $wrap"
-       CXXCPP="$CXX -E" # Don't double-wrap...
-    fi
-    if test -n "$kcc_license" ; then
-       kcc_CC="$CC"
-       kcc_CXX="$CXX"
-       CC="./compilers/cxx_filter.KCC.sh $CC"
-       CXX="./compilers/cxx_filter.KCC.sh $CXX"
-    fi
  fi
-Line 1106
+Line 1585
     if test -n "$icc_license" ; then
        icc_CC="$CC"
        icc_CXX="$CXX"
-       CC="./compilers/cxx_filter.ICC.sh $CC"
+       CC="./compilers/unix/cxx_filter.ICC.sh $CC"
-       CXX="./compilers/cxx_filter.ICC.sh $CXX"
+       CXX="./compilers/unix/cxx_filter.ICC.sh $CXX"
     fi
  fi
-Line 1121
+Line 1600
     Rules="rules_with_autodep"
  elif test "$with_autodep" = "no" ; then
     Rules="rules"
- elif make --version 2>/dev/null | grep 'GNU Make' ; then
+ elif make --version 2>/dev/null | grep 'GNU Make' >/dev/null ; then
     Rules="rules_with_autodep"
  else
     Rules="rules"
  fi
+ ### Support for precompiled headers
+ GCCPCH="#"
+ if test "$compiler" = GCC -a "$with_pch" = "yes" \
+      -a "${with_universal-no}" = "no"; then
+    AC_CACHE_CHECK([whether $CXX supports precompiled headers], ncbi_cv_cxx_pch,
+       [echo '#include <iostream>' > conftest.hpp
+        echo $CXX $CPPFLAGS $CXXFLAGS -xc++-header -c conftest.hpp >&AS_MESSAGE_LOG_FD
+        if $CXX $CPPFLAGS $CXXFLAGS -xc++-header -c conftest.hpp >&AS_MESSAGE_LOG_FD 2>&1 \
+          &&  test -f conftest.hpp.gch; then
+           ncbi_cv_cxx_pch=yes
+        else
+           ncbi_cv_cxx_pch=no
+        fi])
+    if test "$ncbi_cv_cxx_pch" = "yes"; then
+       if test "$Rules" = "rules"; then
+          AC_MSG_WARN([Your version of make does not fully support PCH-related dependencies.])
+       fi
+       CXXFLAGS="-DNCBI_USE_PCH $CXXFLAGS"
+       GCCPCH=""
+    fi
+ fi
  #### Tools
  AC_PROG_LN_S
  AC_PROG_RANLIB
  AC_CHECK_PROG(AR, ar, ar cr, ErrorCannotFind_AR)
+ if test "x$RANLIB" != "x:"; then
+    AC_CACHE_CHECK([ranlib's effectiveness], ncbi_cv_prog_ranlib_effect,
+       [AC_LANG_CONFTEST([AC_LANG_SOURCE([[int libfunc(void) { return 0; }]])])
+        echo $CXX $CPPFLAGS $CXXFLAGS -c conftest.$ac_ext >&AS_MESSAGE_LOG_FD
+        $CXX $CPPFLAGS $CXXFLAGS -c conftest.$ac_ext >&AS_MESSAGE_LOG_FD 2>&1
+        echo $AR conftest.a conftest.o >&AS_MESSAGE_LOG_FD
+        $AR conftest.a conftest.o >&AS_MESSAGE_LOG_FD 2>&1
+        save_LIBS=$LIBS
+        LIBS="conftest.a $LIBS"
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([[extern int libfunc(void);]],
+                                        [[return libfunc();]])],
+                       [ok_without=true], [ok_without=false])
+        echo $RANLIB conftest.a >&AS_MESSAGE_LOG_FD
+        $RANLIB conftest.a >&AS_MESSAGE_LOG_FD
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([[extern int libfunc(void);]],
+                                        [[return libfunc();]])],
+                       [ok_with=true], [ok_with=false])
+        LIBS=$save_LIBS
+        case $ok_with:$ok_without in
+           true:false)  ncbi_cv_prog_ranlib_effect=positive ;;
+           false:true)  ncbi_cv_prog_ranlib_effect=negative ;;
+           true:true)   ncbi_cv_prog_ranlib_effect=neutral  ;;
+           false:false) ncbi_cv_prog_ranlib_effect=unknown  ;;
+        esac
+       ])
+    case "$ncbi_cv_prog_ranlib_effect" in
+       negative) RANLIB=: ;;
+       unknown)
+         AC_MSG_WARN([Failed to make a working library with or without ranlib.])
+         ;;
+    esac
+ fi
  if test "$with_strip" = yes; then
     AC_CHECK_PROG(STRIP, strip, strip, @:)
+    AC_CACHE_CHECK([whether strip loses runtime type information],
+       ncbi_cv_strip_loses_rtti,
+       [if test "$cross_compiling" = yes; then
+           case "$host_os" in
+              darwin* ) ncbi_cv_strip_loses_rtti=yes ;;
+              # No problems observed elsewhere so far.
+              *       ) ncbi_cv_strip_loses_rtti=no  ;;
+           esac
+        else
+           AC_LANG_CONFTEST([AC_LANG_PROGRAM(
+                                [[#include <iostream>
+                                  #include <typeinfo>
+                                  struct SomeStruct { };]],
+                                [[std::cout << typeid(SomeStruct).name();]])])
+           echo $CXX $CPPFLAGS $CXXFLAGS $LDFLAGS -o conftest$ac_exeext \
+              conftest.$ac_ext >&AS_MESSAGE_LOG_FD
+           $CXX $CPPFLAGS $CXXFLAGS $LDFLAGS -o conftest$ac_exeext \
+              conftest.$ac_ext >&AS_MESSAGE_LOG_FD 2>&1
+           $STRIP conftest$ac_exeext
+           if (ulimit -c 0; ./conftest$ac_exeext) >/dev/null 2>&1; then
+              ncbi_cv_strip_loses_rtti=no
+           else
+              ncbi_cv_strip_loses_rtti=yes
+           fi
+           rm -rf conftest*
+        fi])
+    if test "$ncbi_cv_strip_loses_rtti" = "yes"; then
+       NCBI_CAUTION([Do you still want to proceed (at your own risk)?])
+    fi
  else
     STRIP=@:
  fi
  case "$host_os" in
-    irix* )
+    irix* | aix5.[2-9]* )
       # lorder and tsort exist but don't work.
       LORDER=echo
       TSORT=cat
-Line 1154
+Line 1717
       ;;
  esac
+ # When using ccache and distcc together, ccache needs to be primary,
+ # so look for distcc(.sh) first.
+ if test -x $NCBI/bin/distcc.sh ; then
+    : ${DISTCC=$NCBI/bin/distcc.sh}
+    : ${with_distcc=yes}
+ fi
+ if test "$with_distcc" = "yes" ; then
+    AC_CHECK_PROG(DISTCC, distcc, distcc, [])
+    if test -n "$DISTCC" ; then
+       # Test distcc reasonably thoroughly to avoid possible gotchas.
+       cat > distcctest.c << EOF
+ #include <stddef.h>
+ #if !defined(__GNUC__)  &&  !defined(offsetof)
+ #  define offsetof(T, F) ((size_t)((char*) &(((T*) 0)->F) - (char*) 0))
+ #endif
+ struct S { int x; };
+ int f() { return offsetof(struct S, x); }
+ EOF
+       DISTCC_FALLBACK=0
+       export DISTCC_FALLBACK
+       AC_CACHE_CHECK([whether any distcc servers are available],
+          ncbi_cv_prog_distcc_servers,
+          [if test -x /usr/bin/cc; then testcc=/usr/bin/cc; else testcc=$CC; fi
+           if $DISTCC $testcc -c distcctest.c \
+>&AS_MESSAGE_LOG_FD ; then
+              ncbi_cv_prog_distcc_servers=yes
+           else
+              ncbi_cv_prog_distcc_servers=no
+           fi])
+       if test "$ncbi_cv_prog_distcc_servers" = no; then
+          AS_UNSET(DISTCC)
+       fi
+       if test -n "$DISTCC" ; then
+          AC_CACHE_CHECK([whether $DISTCC is compatible with $CC],
+             ncbi_cv_prog_distcc_vs_cc,
+             [if $DISTCC $CC -c distcctest.c 2>&AS_MESSAGE_LOG_FD ; then
+                 ncbi_cv_prog_distcc_vs_cc=yes
+              else
+                 ncbi_cv_prog_distcc_vs_cc=no
+              fi])
+          if test "$ncbi_cv_prog_distcc_vs_cc" = yes; then
+             CC_WRAPPER="$DISTCC $CC_WRAPPER"
+          else
+             AS_UNSET(DISTCC)
+          fi
+       fi
+       if test -n "$DISTCC" ; then
+          AC_CACHE_CHECK([whether $DISTCC is compatible with $CXX],
+             ncbi_cv_prog_distcc_vs_cxx,
+             [mv distcctest.c distcctest.cpp
+              if $DISTCC $CXX -c distcctest.cpp 2>&AS_MESSAGE_LOG_FD ; then
+                 ncbi_cv_prog_distcc_vs_cxx=yes
+              else
+                 ncbi_cv_prog_distcc_vs_cxx=no
+              fi])
+          if test "$ncbi_cv_prog_distcc_vs_cxx" = yes; then
+             CXX_WRAPPER="$DISTCC $CXX_WRAPPER"
+          else
+             AS_UNSET(DISTCC)
+          fi
+       fi
+       rm -f distcctest.*
+    elif test "$with_distcc" = "yes" ; then
+       AC_MSG_WARN([distcc explicitly requested, but not found in PATH.])
+    fi
+ fi
+ if test -z "$with_ccache"  -a  -n "$DISTCC"  -a  -z "$CCACHE_DIR" ; then
+    # Using CCACHE together with DISTCC causes problems when the involved DISTCC
+    # servers share the same home dir, as in that case the caches from
+    # different servers can mix up rather badly, corrupting each other.
+    # On the other hand, most NCBI accounts have $CCACHE_DIR automatically set
+    # to a non-shared, per-machine location (such as "/tmp/.ccache-username").
+    with_ccache="no"
+ fi
+ if test "$with_ccache" != "no"; then
  AC_CHECK_PROG(CCACHE, ccache, ccache, [])
  if test -n "$CCACHE" ; then
-    CC_WRAPPER="$CC_WRAPPER $CCACHE"
+       if test -n "$CC_WRAPPER"; then
-    CXX_WRAPPER="$CXX_WRAPPER $CCACHE"
+          CC_WRAPPER="CCACHE_PREFIX=$CC_WRAPPER $CCACHE"
+       else
+          CC_WRAPPER=$CCACHE
+       fi
+       if test -n "$CXX_WRAPPER"; then
+          CXX_WRAPPER="CCACHE_PREFIX=$CXX_WRAPPER $CCACHE"
+       else
+          CXX_WRAPPER=$CCACHE
+       fi
+    elif test "$with_ccache" = "yes"; then
+       AC_MSG_WARN([ccache explicitly requested, but not found in PATH.])
+    fi
  fi
+ # Note the path, since syntax is version-specific....
+ AC_PATH_PROG(TAIL, tail)
+ AC_MSG_CHECKING([whether $TAIL accepts modern syntax (-n N)])
+ if $TAIL -n 1 config.log >/dev/null 2>&1; then
+    TAIL_N="$TAIL -n "
+    AC_MSG_RESULT(yes)
+ else
+    TAIL_N="$TAIL -"
+    AC_MSG_RESULT(no)
+ fi
+ AC_PROG_EGREP
+ AC_MSG_CHECKING([how to run $EGREP quietly])
+ if test -z "`echo foo | $EGREP -q fo+ 2>>config.log || echo $?`"; then
+    EGREP_Q="$EGREP -q"
+ elif test -z "`echo foo | $EGREP -s fo+ 2>>config.log || echo $?`"; then
+    EGREP_Q="$EGREP -s"
+ else
+    EGREP_Q=">/dev/null $EGREP"
+ fi
+ AC_MSG_RESULT($EGREP_Q)
+ AC_CHECK_PROG(VALGRIND_PATH, valgrind, valgrind)
  #### Check if "${build_root}" is defined;  provide a default one
  if test -n "${with_build_root}" ; then
     build_root=${with_build_root}
  fi
+ ### Possibly add the version to the build directory name, but preseve
+ ### the original default when reconfiguring.
+ if test -z "${with_version}" -a -n "${ac_cv_header_stdc}"; then
+    with_version=${ncbi_cv_with_version:-no}
+ fi
  if test -z "${build_root}" ; then
     build_root="${srcdir}/${compiler}"
     case "$compiler:$with_version" in
-       *[[0-9]]:*) ;;
+       *[[0-9]]:* | *:no) ;;
-       *:yes) build_root=${build_root}${compiler_version} ;;
+       *) build_root=${build_root}${compiler_version} ;;
     esac
+    ncbi_cv_with_version=${with_version:-yes}
  else
     : ${with_suffix:="no"}
  fi
  #### Release/Debug
- if test "$with_debug" = "no" ; then
+ case "${with_debug}:${with_optimization}" in
-    release_debug="Release"
+    no:*)
+       release_debug=Release
+       DEBUG_SFX=Release
     D_SFX=
- else
+       ;;
-    release_debug="Debug"
+    yes:yes | :yes)
+       release_debug=DebugOpt
+       DEBUG_SFX=Debug
     D_SFX=d
- fi
+       ;;
- DEBUG_SFX=${release_debug}
+    *)
+       release_debug=Debug
+       DEBUG_SFX=Debug
+       D_SFX=d
+       ;;
+ esac
  #### Profiling; try to turn on both function weight and basic-block counting
-Line 1193
+Line 1886
     prof_sfx="Prof"
     case "$compiler" in
        Compaq)    PFFLAGS="-pg" ;;
-       GCC)       PFFLAGS="-pg -fprofile-arcs" ;;
+       GCC)       PFFLAGS="-pg" ;;
        ICC)       PFFLAGS="-p" ;;
        KCC)       PFFLAGS="-pg" ;;
        MIPSpro73) PFFLAGS="" ;; # pixie(1) adds info at runtime
-Line 1211
+Line 1904
  fi
+ ### Should go before any test compiler runs
+ AC_GNU_SOURCE
+ #### Determine whether this is implicitly a 64-bit platform
+ AC_TYPE_SIZE_T
+ if test "${with_universal-no}" = "no"; then
+    AC_CHECK_SIZEOF(size_t)
+    NCBI_PLATFORM_BITS=`expr 8 \* $ac_cv_sizeof_size_t`
+    AC_DEFINE_UNQUOTED(NCBI_PLATFORM_BITS, $NCBI_PLATFORM_BITS,
+                       [Define to the architecture size.])
+    if test $NCBI_PLATFORM_BITS -eq 64; then
+       bit64_sfx=64
+    fi
+ fi
+ ### Intel Thread Checker
+ if test "${with_tcheck-no}" != "no" ; then
+    if test "${release_debug}${mt_sfx}" != "DebugMT" ; then
+       AC_MSG_WARN([--with-tcheck is most likely to be effective in DebugMT builds.])
+    fi
+    if test "$compiler" = "ICC"; then
+       case "$bit64_sfx" in
+) tcbin=bin/32e ;;
+         * ) tcbin=bin/32  ;;
+       esac
+       if test "$with_tcheck" != yes; then
+          TCHECK_BIN=$with_tcheck/$tcbin
+       fi
+       AC_PATH_PROG(TCHECK_CL, tcheck_cl, [], $TCHECK_BIN:$PATH:/opt/intel/itt/$tcbin:/usr/local/intel/itt-3.1/tcheck/$tcbin)
+       if test -n "$TCHECK_CL"; then
+          CFLAGS="$CFLAGS -tcheck -O0"
+          CXXFLAGS="$CXXFLAGS -tcheck -O0"
+          LDFLAGS="$LDFLAGS -tcheck -O0 -L`dirname $TCHECK_CL`"
+       fi
+    fi
+    CPPFLAGS="$CPPFLAGS -DNCBI_TCHECK"
+ fi
  #### Add "Release"/"Debug", "MT", "DLL", "64", "_p" suffixes to "${build_root}"
  if test "$with_suffix" != "no" ; then
     build_root="${build_root}-${release_debug}${mt_sfx}${dll_sfx}${bit64_sfx}${prof_sfx}"
-Line 1222
+Line 1955
     build_root="${build_root}--${host}"
  fi
+ if test -n "$with_build_root_sfx" ; then
+    build_root=$build_root$with_build_root_sfx
+ fi
+ case "$host_os" in
+    linux*)
+       kver=`uname -r | sed -e 's/-.*//'`
+       libcver=`ldd --version | awk 'NR == 1 { print $NF }'`
+       verbose_host=$host_cpu-$host_vendor-linux$kver-gnu$libcver
+       ;;
+    *) verbose_host=$host ;;
+ esac
  #### Overall configuration mode summary
- signature="${compiler}_${compiler_version}-${release_debug}${mt_sfx}${dll_sfx}${bit64_sfx}${prof_sfx}--${host}-`(hostname || uname -n) 2>/dev/null | sed 1q`"
+ signature="${compiler}_${compiler_version}-${release_debug}${mt_sfx}${dll_sfx}${bit64_sfx}${prof_sfx}--${verbose_host}-`(hostname || uname -n) 2>/dev/null | sed 1q`"
+ AC_DEFINE_UNQUOTED(NCBI_SIGNATURE, "$signature",
+    [Build signature: compiler-name '_' compiler-version '-' configuration
+    '--' platform-name '-' hostname])
  #### Check if there is "${build_root}" dir
  test -d "${build_root}"  ||  mkdir -p "${build_root}"
+ test -d "${build_root}"  ||  AC_MSG_ERROR([Couldn't create ${build_root}])
+ #### Try to find a version of pwd that yields /net paths.
+ AC_PATH_PROG(AMQ, amq, [], $PATH:/usr/sbin:/sbin)
+ case "$AMQ" in
+    */amq)
+       AC_CACHE_CHECK([whether $AMQ -w works], ncbi_cv_prog_amq_w,
+       [if $AMQ -w >/dev/null 2>&1; then
+           ncbi_cv_prog_amq_w=yes
+        else
+           ncbi_cv_prog_amq_w=no
+        fi])
+       if test "$ncbi_cv_prog_amq_w" = yes; then
+          smart_pwd="$AMQ -w"
+       else
+          smart_pwd=pwd
+       fi
+       ;;
+    *)
+       smart_pwd=pwd
+       ;;
+ esac
  #### Make "build_root" absolute
  case "${build_root}" in
-Line 1240
+Line 2009
        then
           build_root="$PWD"
        else
-          build_root="`(cd ${build_root}; pwd)`"
+          NCBI_FIX_DIR(build_root)
        fi
     ;;
-    *  ) build_root="`(cd ${build_root}; pwd)`" ;;
+    *  ) NCBI_FIX_DIR(build_root) ;;
  esac
+ if test -n "$with_fake_root"; then
+    build_root=$with_fake_root/`basename $build_root`
+ fi
  #### Set runpath (may depend on build root)
-Line 1265
+Line 2037
     pure_runpath=
  elif test -n "$with_runpath"  -a  "$with_runpath" != "yes" ; then
     root_base=`basename $build_root`
-    pure_runpath=`echo ${with_runpath} | sed s/{}/$root_base/`
+    pure_runpath=`echo ${with_runpath} | sed s/{}/$root_base/g`
     runpath="${CONF_f_runpath}${pure_runpath}"
     case "$host_os:$compiler" in
      darwin* )
-Line 1273
+Line 2045
        # harmless elsewhere, since it only affects projects that indirectly
        # need one of these libraries.  (There seems to be no general
        # equivalent of -rpath-link.)
-       for l in dbapi_driver gui_utils; do
+       for l in dbapi_driver gui_utils ncbi_xloader_genbank ncbi_xreader \
+                ncbi_xreader_id1 ncbi_xreader_pubseqos; do
           ll=lib$l.dylib
           LDFLAGS="$LDFLAGS -dylib_file ${pure_runpath}/$ll:\$(libdir)/$ll"
        done
-Line 1283
+Line 2056
           runpath="$runpath -Wl,-rpath-link,\$(libdir)"
        fi
        ;;
+     *:ICC )
+       runpath="$runpath -Xlinker -rpath-link -Xlinker \$(libdir)"
+       ;;
     esac
  elif test "$with_runpath" = "yes"  -o  "$with_dll" != "no" ; then
     runpath="${CONF_f_runpath}\$(libdir)"
-Line 1300
+Line 2076
  #### Linker command-line to build DLL (may depend on runpath)
  has_dll_loadable="@# "
+ ALLOW_UNDEF=
+ FORBID_UNDEF=
  case "$compiler" in
-  GCC | MIPSpro73 | ICC | Compaq )
+  GCC | ICC )
+    LINK_DLL="$LINK $ARCH_CFLAGS -shared -o" # possibly overridden below
     case "$host_os" in
        solaris* )
          # See http://realm.progsoc.uts.edu.au/~subtle/solaris28_link.html
          LINK_DLL="$LINK $ARCH_CFLAGS -shared -mimpure-text -o"
+         FORBID_UNDEF="-Wl,-z,defs"
          ;;
        darwin* )
          # There is a distinction between shared libraries (dylibs)
-Line 1313
+Line 2093
          # See <http://fink.sourceforge.net/doc/porting/shared.php>.
          has_dll_loadable=""
          if $CXX -v 2>&1 | grep -q Apple; then
-            LINK_DLL="$LINK $ARCH_CFLAGS -dynamiclib -flat_namespace -undefined suppress -install_name ${pure_runpath%%:*}/\$(XDLL) -o"
+            LINK_DLL="$LINK $ARCH_CFLAGS -dynamiclib -install_name ${pure_runpath%%:*}/\$(XDLL) -o"
-            LINK_LOADABLE="$LINK $ARCH_CFLAGS -bundle -flat_namespace -undefined suppress -o"
+            LINK_LOADABLE="$LINK $ARCH_CFLAGS -bundle -o"
-         else
+            ALLOW_UNDEF='-undefined suppress'
-            LINK_DLL="$CC $ARCH_CFLAGS -nostartfiles -Wl,-dynamic -Wl,-flat_namespace -Wl,-undefined,suppress -install_name ${pure_runpath%%:*}/\$(XDLL) -o"
+            FORBID_UNDEF='-undefined error'
-            LINK_LOADABLE="$CC $ARCH_CFLAGS -nostartfiles -Wl,-dynamic -Wl,-bundle -Wl,-flat_namespace -Wl,-undefined,suppress -Wl,-read_only_relocs,warning -lbundle1.o -o"
+         else
+            LINK_DLL="$CC $ARCH_CFLAGS -nostartfiles -Wl,-dynamic -install_name ${pure_runpath%%:*}/\$(XDLL) -o"
+            LINK_LOADABLE="$CC $ARCH_CFLAGS -nostartfiles -Wl,-dynamic -Wl,-bundle -Wl,-read_only_relocs,warning -lbundle1.o -o"
+            ALLOW_UNDEF='-Wl,-undefined,suppress'
+            FORBID_UNDEF='-Wl,-undefined,error'
          fi
          ;;
+       linux* | *gnu* ) # | *bsd*
+         case "$compiler:$compiler_version" in
+            ICC:9* | ICC:1??? )
+              ncbi_cv_prog_cc_wl_no_asu=no
+              LIBS="$LIBS -lc"
+              C_LIBS="$C_LIBS -lc"
+              ;;
+            ICC:* )
+              ;;
        * )
-         LINK_DLL="$LINK $ARCH_CFLAGS -shared -o"
+              FORBID_UNDEF='-Wl,--no-undefined'
          ;;
     esac
     ;;
+       irix* )
+         FORBID_UNDEF='-Wl,-no_unresolved'
+         ;;
+       osf* )
+         ALLOW_UNDEF='-Wl,-expect_unresolved,\*'
+         FORBID_UNDEF='-Wl,-error_unresolved'
+         ;;
+    esac
+    AC_CACHE_CHECK([whether $CC supports -Wl,--no-allow-shlib-undefined],
+       ncbi_cv_prog_cc_wl_no_asu,
+       [orig_LDFLAGS=$LDFLAGS
+        LDFLAGS="$CXXFLAGS_DLL -shared -Wl,--no-allow-shlib-undefined $LDFLAGS"
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
+           [ncbi_cv_prog_cc_wl_no_asu=yes], [ncbi_cv_prog_cc_wl_no_asu=no])
+        LDFLAGS=$orig_LDFLAGS])
+    if test "$ncbi_cv_prog_cc_wl_no_asu" = yes; then
+       FORBID_UNDEF="$FORBID_UNDEF -Wl,--no-allow-shlib-undefined"
+    fi
+   ;;
+  MIPSpro73 )
+    LINK_DLL="$LINK $ARCH_CFLAGS -shared -o"
+    FORBID_UNDEF="-no_unresolved"
+    ;;
+  Compaq )
+    LINK_DLL="$LINK $ARCH_CFLAGS -shared -o"
+    ALLOW_UNDEF='-expect_unresolved \*'
+    FORBID_UNDEF='-error_unresolved'
+    ;;
   WorkShop* )
-    LINK_DLL="$LINK $ARCH_CFLAGS $MT_FLAG -G -h \$@ -o"
+    LINK_DLL="$LINK $ARCH_CFLAGS $MT_FLAG -G -h \$(XDLL) -o"
+    FORBID_UNDEF="-z defs"
     ;;
   KCC )
-    LINK_DLL="$LINK $ARCH_CFLAGS $MT_FLAG --soname \$@ -o"
+    LINK_DLL="$LINK $ARCH_CFLAGS $MT_FLAG --soname \$(XDLL) -o"
+    FORBID_UNDEF="-z defs"
+    ;;
+  VisualAge )
+    # NOTE: --without-dll still recommended, as the linker doesn't seem
+    # to support building shared libraries with undefined symbols.
+    LINK_DLL="$LINK $ARCH_CFLAGS $MT_FLAG -qmkshrobj -o"
+    # ALLOW_UNDEF="???"
     ;;
   * )
     if test "$with_dll" = "yes"  &&  test -z "$LINK_DLL" ; then
-       AC_MSG_ERROR(["Do not know how to build DLLs with compiler $CXX $compiler_ver"])
+       AC_MSG_ERROR([Do not know how to build DLLs with compiler $CXX $compiler_ver])
+    elif test -z "$LINK_DLL"; then
+       with_dll=no
     fi
     ;;
  esac
+ if test "$with_dll" = "no"; then # no DLLs whatsoever!
+    DLL=
+    FORCE_STATIC_LIB="LIB_OR_DLL = lib"
+    APP_LIB_SETTING='$(STATIC_LIB)'
+    APP_LIBS_SETTING='$(STATIC_LIBS)'
+ else
+    FORCE_STATIC_LIB=
+    APP_LIB_SETTING='$(LIB)'
+    APP_LIBS_SETTING='$(LIBS)'
+    NCBI_FEATURE(DLL)
+    # Some shared libraries end up containing static libraries, so make
+    # sure to use DLL flags for both on platforms where such inclusion
+    # would otherwise be illegal....
+    case "$host_os:$host_cpu:$bit64_sfx" in
+       # linux*:*86:*) ;;
+       linux* | darwin* | solaris*:64 )
+         CFLAGS="$CFLAGS $CFLAGS_DLL"
+         CFLAGS_DLL=
+         CXXFLAGS="$CXXFLAGS $CXXFLAGS_DLL"
+         CXXFLAGS_DLL=
+         ;;
+    esac
+    AC_DEFINE(NCBI_DLL_SUPPORT, 1,
+      [Define to 1 if building dynamic libraries at all
+       (albeit not necessarily by default).])
+    if test "$with_dll" = "yes"; then
+       NCBI_FEATURE(DLL_BUILD)
+       AC_DEFINE(NCBI_DLL_BUILD, 1,
+                 [Define to 1 if building dynamic libraries by default.])
+       : ${with_plugin_auto_load=yes}
+    fi
+ fi
+ if test "$with_plugin_auto_load" = yes; then
+    AC_DEFINE(NCBI_PLUGIN_AUTO_LOAD, 1,
+              [Define to 1 if the plugin manager should load DLLs by default.])
+ fi
+ # Make sure we have commands for both C and C++ preprocessors
+ AC_PROG_CPP
+ dnl AC_PROG_CXXCPP
  #### Make "srcdir" absolute
  case "${srcdir}" in
-Line 1348
+Line 2221
        then
          srcdir="$PWD"
        else
-         srcdir="`(cd ${srcdir}; pwd)`"
+         NCBI_FIX_DIR(srcdir)
        fi
     ;;
-    * ) srcdir="`(cd ${srcdir}; pwd)`" ;;
+    * ) NCBI_FIX_DIR(srcdir) ;;
  esac
+ real_srcdir=$srcdir
+ if test -n "$with_fake_root"; then
+    srcdir=$build_root/..
+ fi
+ #### Ensure that all explicitly requested subtrees actually exist
+ NCBI_CHECK_SUBTREE(algo)
+ dnl NCBI_CHECK_SUBTREE(app)
+ if test "$with_app" = "no" ; then
+    NoConfProjects="$NoConfProjects app"
+ fi
+ if test ! -f ${real_srcdir}/src/app/Makefile.in ; then
+    if test "${with_app-no}" != "no" ; then
+       AC_MSG_ERROR([--with-app:  APP sources are missing])
+    fi
+    with_app="no"
+ fi
+ dnl NCBI_CHECK_SUBTREE(bdb) # deferred until end, as --with-bdb does double duty
+ dnl NCBI_CHECK_SUBTREE(cgi) # --without-cgi deliberately unavailable for now
+ if test -f ${real_srcdir}/src/cgi/Makefile.in  -a \
+         -d ${real_srcdir}/include/cgi; then
+    NCBI_PROJECT(cgi)
+ else
+    AC_MSG_WARN([CGI tree missing; some projects may fail to build.])
+ fi
+ NCBI_CHECK_SUBTREE(ctools)
+ NCBI_CHECK_SUBTREE(dbapi)
+ NCBI_CHECK_SUBTREE(gui)
+ NCBI_CHECK_SUBTREE(objects)
+ NCBI_CHECK_SUBTREE(serial)
  #### Source, include, and build directories
- ncbiconf="$build_root/inc/ncbiconf.h"
+ ncbiconf="$build_root/inc/ncbiconf_unix.h"
+ ncbiconf_old="$build_root/inc/ncbiconf.h"
+ if test -f "$ncbiconf_old" -a ! -f "$ncbiconf"; then
+    mv "$ncbiconf_old" "$ncbiconf"
+ fi
  if test "$build_root" = "$srcdir" ; then
     builddir="$srcdir/src"
  else
-Line 1373
+Line 2284
  if test "$no_create" != "yes"  -a  -f "${ncbiconf}" ; then
     echo
     echo "There is already a built \"${ncbiconf}\"!"
- changequote(, )dnl
+    NCBI_CAUTION([Do you want to re-configure in \"${builddir}\"?])
-    echo "Do you want to re-configure in \"${builddir}\"? [y/n]"
- changequote([, ])dnl
-    read answer
-    case "$answer" in
-       y | Y | yes | YES ) ;;
-       * )  AC_MSG_ERROR([Re-configuration has been canceled by user.]) ;;
-    esac
     echo
  fi
-Line 1409
+Line 2313
  if test "$CONF_f_outexe"  = " " ;  then f_outexe="" ; else f_outexe="${CONF_f_outexe:=-o }" ; fi
- BINCOPY="${CONFIG_SHELL} \$(top_srcdir)/scripts/if_diff.sh \"cp -p\""
+ BINCOPY="cp -p"
- if test "$OSTYPE" = "darwin" -a -x /Developer/Tools/CpMac; then
+ MAC_BINCOPY="/Developer/Tools/CpMac -p"
-    BINCOPY="${CONFIG_SHELL} \$(top_srcdir)/scripts/if_diff.sh \"/Developer/Tools/CpMac -p\""
+ if test "$with_bincopy" != "yes"; then
- elif test "$with_bincopy" != "yes"; then
     AC_CACHE_CHECK([whether cross-directory hard links work],
        ncbi_cv_sys_xdir_ln,
        [mkdir conftestdir
-Line 1424
+Line 2327
         fi
         rm -rf conftestdir conftestfile])
     if test "$ncbi_cv_sys_xdir_ln" = "yes"; then
-       BINCOPY="${CONFIG_SHELL} \$(top_srcdir)/scripts/if_diff.sh \"ln -f\""
+       BINCOPY="ln -f"
+       MAC_BINCOPY="\$(top_srcdir)/scripts/common/impl/ln_mac.sh"
     fi
  fi
+ ifdiff="${CONFIG_SHELL} \$(top_srcdir)/scripts/common/impl/if_diff.sh"
+ if test "$OSTYPE" = "darwin" -a -x /Developer/Tools/CpMac; then
+    BINCOPY="$ifdiff \"$MAC_BINCOPY\""
+ else
+    BINCOPY="$ifdiff \"$BINCOPY\""
+ fi
  #### Manage the debug-vs.-optimization flags ("--*-debug", "--*-optimization")
-Line 1437
+Line 2347
        CFLAGS=`  echo " $CFLAGS"   | sed 's/[    ]-g[0-9]*//g'`
        CXXFLAGS=`echo " $CXXFLAGS" | sed 's/[    ]-g[0-9]*//g'`
        LDFLAGS=` echo " $LDFLAGS"  | sed 's/[    ]-g[0-9]*//g'`
+       CPPFLAGS="-DNDEBUG $CPPFLAGS"
     else
        with_optimization=${with_optimization:="no"}
        if echo " $CFLAGS"   |grep -v >/dev/null '[       ]-g[0-9]*' ; then
           CFLAGS="$CFLAGS -g"     ; fi
        if echo " $CXXFLAGS" |grep -v >/dev/null '[       ]-g[0-9]*' ; then
           CXXFLAGS="$CXXFLAGS -g" ; fi
-       if test "$with_optimization" = "no" ; then
+       if test "${with_tcheck=no}" = "no" ; then
-          CPPFLAGS="-D_DEBUG $CPPFLAGS" ; fi
+          CPPFLAGS="-D_DEBUG $CPPFLAGS"
+       else
+          CPPFLAGS="-DNDEBUG $CPPFLAGS"
+       fi
        if echo " $LDFLAGS"  |grep -v >/dev/null '[       ]-g[0-9]*' ;
           then LDFLAGS="$LDFLAGS -g" ; fi
        STRIP="@:"
     fi
-    NOPT_CFLAGS=`  echo " $CFLAGS"    | sed 's/[         ]-O[0-9]*//g'`
+    NOPT_CFLAGS=`  echo " $CFLAGS"    | sed 's/[         ]-x*O[0-9]*//g'`
-    NOPT_CXXFLAGS=`echo " $CXXFLAGS"  | sed 's/[         ]-O[0-9]*//g'`
+    NOPT_CXXFLAGS=`echo " $CXXFLAGS"  | sed 's/[         ]-x*O[0-9]*//g'`
-    NOPT_LDFLAGS=` echo " $LDFLAGS"   | sed 's/[         ]-O[0-9]*//g'`
+    NOPT_LDFLAGS=` echo " $LDFLAGS"   | sed 's/[         ]-x*O[0-9]*//g'`
+    if test "${with_tcheck-no}" != "no"; then
+       # Suppress warnings when building with ICC.
+       NOPT_CFLAGS="$NOPT_CFLAGS -O0"
+       NOPT_CXXFLAGS="$NOPT_CXXFLAGS -O0"
+       NOPT_LDFLAGS="$NOPT_LDFLAGS -O0"
+    fi
     if test "$with_optimization" = "no" ; then
        CFLAGS="$NOPT_CFLAGS"
        CXXFLAGS="$NOPT_CXXFLAGS"
-       LDFLAGS=` echo " $LDFLAGS"   | sed 's/[   ]-O[0-9]*//g'`
+       LDFLAGS="$NOPT_LDFLAGS"
        FAST_CFLAGS="$CFLAGS"
        FAST_CXXFLAGS="$CXXFLAGS"
        FAST_LDFLAGS="$LDFLAGS"
     else
-       if echo " $CFLAGS"   |grep -v >/dev/null '[       ]-O[0-9]*' ; then
+       if echo " $CFLAGS"   |grep -v >/dev/null '[       ]-x*O[0-9]*' ; then
           CFLAGS="$CFLAGS -O" ; fi
-       if echo " $CXXFLAGS" |grep -v >/dev/null '[       ]-O[0-9]*' ; then
+       if echo " $CXXFLAGS" |grep -v >/dev/null '[       ]-x*O[0-9]*' ; then
           CXXFLAGS="$CXXFLAGS -O" ; fi
-       CPPFLAGS="-DNDEBUG $CPPFLAGS"
+       if echo " $LDFLAGS"  |grep -v >/dev/null '[       ]-x*O[0-9]*' ; then
-       if echo " $LDFLAGS"  |grep -v >/dev/null '[       ]-O[0-9]*' ; then
           LDFLAGS="$LDFLAGS -O" ; fi
        FAST_CFLAGS="$NOPT_CFLAGS $FAST_CFLAGS"
        FAST_CXXFLAGS="$NOPT_CXXFLAGS $FAST_CXXFLAGS"
        FAST_LDFLAGS="$NOPT_LDFLAGS $FAST_LDFLAGS"
     fi
-    if test "$with_debug" = "no"  -a  "$with_optimization" = "no" ; then
-       CPPFLAGS="-DNDEBUG $CPPFLAGS"
-    fi
  fi
  changequote([, ])dnl
-Line 1489
+Line 2404
  AC_CHECK_HEADERS(fstream   fstream.h)
  AC_CHECK_HEADERS(strstream strstream.h strstrea.h)
- AC_CHECK_HEADERS(limits)
+ AC_CHECK_HEADERS(inttypes.h limits)
  ### Check for the platform (very roughly)
  AC_CHECK_HEADERS(unistd.h,  x_have_unistd="yes")
-Line 1498
+Line 2413
  if test "$x_have_windows" = "yes" -a "x$host_os" != "xcygwin32" -a "x$host_os" != "xcygwin"; then
     AC_DEFINE(NCBI_OS_MSWIN, 1, [Define to 1 on Windows.])
     AC_DEFINE(NCBI_OS, "MSWIN", [Operating system name])
+    NCBI_FEATURE(MSWin)
  elif test "$x_have_unistd" = "yes" ; then
     AC_DEFINE(NCBI_OS_UNIX, 1,  [Define to 1 on Unix.])
     AC_DEFINE(NCBI_OS, "UNIX",  [Operating system name])
     UNIX_SRC='$(UNIX_SRC)'
     UNIX_USR_PROJ='$(UNIX_USR_PROJ)'
-    WithFeatures="$WithFeatures unix"
+    NCBI_FEATURE(unix)
+    NCBI_FEATURE(WinMain) # to accommodate a PTB-specific (ab)use of REQUIRES
     # Extra defines for variants we care about
     case "$OSTYPE" in
-      aix)     AC_DEFINE(NCBI_OS_AIX,     1, [Define to 1 on AIX.])          ;;
+      aix)
-      *bsd)    AC_DEFINE(NCBI_OS_BSD,     1, [Define to 1 on *BSD.])         ;;
+         AC_DEFINE(NCBI_OS_AIX,     1, [Define to 1 on AIX.])
-      cygwin)  AC_DEFINE(NCBI_OS_CYGWIN,  1, [Define to 1 on Cygwin.])       ;;
+         NCBI_FEATURE(AIX)
-      darwin)  AC_DEFINE(NCBI_OS_DARWIN,  1, [Define to 1 on Mac OS X.])     ;;
+         ;;
-      irix)    AC_DEFINE(NCBI_OS_IRIX,    1, [Define to 1 on IRIX.])         ;;
+      *bsd)
-      linux)   AC_DEFINE(NCBI_OS_LINUX,   1, [Define to 1 on Linux.])        ;;
+         AC_DEFINE(NCBI_OS_BSD,     1, [Define to 1 on *BSD.])
-      osf)     AC_DEFINE(NCBI_OS_OSF1,    1, [Define to 1 on Tru64 Unix.])   ;;
+         NCBI_FEATURE(BSD)
-      solaris) AC_DEFINE(NCBI_OS_SOLARIS, 1, [Define to 1 on Solaris.])      ;;
+         ;;
+      cygwin)
+         AC_DEFINE(NCBI_OS_CYGWIN,  1, [Define to 1 on Cygwin.])
+         NCBI_FEATURE(Cygwin)
+         if test "$with_mt" = yes; then NCBI_FEATURE(CygwinMT); fi
+         ;;
+      darwin)
+         AC_DEFINE(NCBI_OS_DARWIN,  1, [Define to 1 on Mac OS X.])
+         NCBI_FEATURE(Darwin)
+         if false; then NCBI_FEATURE(XCODE); fi
+         ;;
+      irix)
+         AC_DEFINE(NCBI_OS_IRIX,    1, [Define to 1 on IRIX.])
+         NCBI_FEATURE(IRIX)
+         ;;
+      linux)
+         AC_DEFINE(NCBI_OS_LINUX,   1, [Define to 1 on Linux.])
+         NCBI_FEATURE(Linux)
+         ;;
+      osf)
+         AC_DEFINE(NCBI_OS_OSF1,    1, [Define to 1 on Tru64 Unix.])
+         NCBI_FEATURE(OSF)
+         ;;
+      solaris)
+         AC_DEFINE(NCBI_OS_SOLARIS, 1, [Define to 1 on Solaris.])
+         NCBI_FEATURE(Solaris)
+         ;;
     esac
  else
-    AC_DEFINE(NCBI_OS_MAC, 1, [Define to 1 on MacOS.])
+ dnl Classic Mac OS, no longer supported; the following line is
+ dnl commented out to avoid cluttering config.h.in.
+ dnl AC_DEFINE(NCBI_OS_MAC, 1, [Define to 1 on MacOS.])
     AC_DEFINE(NCBI_OS, "MAC", [Operating system name])
+    NCBI_FEATURE(MacOS)
  fi
+ case "$host_os" in
+    cygwin* | osf* )
+       AC_DEFINE(NETDB_REENTRANT, 1,
+                 [Define to 1 if the BSD-style netdb interface is reentrant.])
+       ;;
+ esac
  # AC_CHECK_TYPES is insufficient, as linking may still fail :-/
  AC_CACHE_CHECK([for wstring], ac_cv_type_wstring_linkable,
     [AC_LINK_IFELSE([AC_LANG_PROGRAM(
-Line 1536
+Line 2489
  AC_CHECK_TYPES(socklen_t,,,[#include <sys/types.h>
  #include <sys/socket.h>])
- AC_CHECK_HEADERS(dlfcn.h sys/sockio.h sys/sysinfo.h)
+ AC_CHECK_HEADERS(atomic.h dlfcn.h ieeefp.h poll.h sys/mount.h sys/sockio.h \
- # for FreeTDS 0.60
+                  sys/statvfs.h sys/sysinfo.h sys/vfs.h)
- AC_CHECK_HEADERS(arpa/inet.h malloc.h netinet/in.h sys/socket.h)
+ # for FreeTDS 0.6x
+ AC_CHECK_HEADERS(arpa/inet.h errno.h malloc.h netdb.h \
+                  netinet/in.h netinet/tcp.h paths.h signal.h \
+                  sys/ioctl.h sys/select.h sys/socket.h sys/time.h wchar.h)
+ AC_HEADER_TIME
- ### Check for some reentrant library functions (only needed in MT mode)
+ ## gethostbyname_r() -- 2 different variants: 5-arg (Solaris), 6-arg (Linux).
- if test "$with_mt" = "yes" ; then
- ## gethostbyname_r() -- 3 different variants: 5-arg (Solaris), 6-arg (Linux),
- ## 3-arg (OSF/1 cruft)
  AC_CACHE_CHECK([for gethostbyname_r], ncbi_cv_func_gethostbyname_r,
     [ncbi_cv_func_gethostbyname_r="no"
-Line 1576
+Line 2528
           ncbi_cv_func_gethostbyname_r="6"
         ]
      )
-     fi
-     if test "$ncbi_cv_func_gethostbyname_r" = "no" ; then
-     AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
-        [[#include <netdb.h>]],
-        [[
-          void*                dummy = (void*) &gethostbyname_r;
-          int                  err;
-          struct hostent*      hp = 0;
-          struct hostent_data* hdp = 0;
-          err = gethostbyname_r("", hp, hdp);
-        ]])],
-        [
-          ncbi_cv_func_gethostbyname_r="3"
-        ]
-     )
      fi])
  if test "$ncbi_cv_func_gethostbyname_r" != "no" ; then
     AC_DEFINE_UNQUOTED(HAVE_GETHOSTBYNAME_R, $ncbi_cv_func_gethostbyname_r,
      [If you have the `gethostbyname_r' function, define to the number of
-      arguments it takes (normally 3, 5 or 6).])
+      arguments it takes (normally 5 or 6).])
  fi
- ## gethostbyaddr_r() -- 3 different variants: 7-arg (Solaris), 8-arg (Linux),
+ ## gethostbyaddr_r() -- 2 different variants: 7-arg (Solaris), 8-arg (Linux).
- ## 5-arg (OSF/1 cruft)
  AC_CACHE_CHECK([for gethostbyaddr_r], ncbi_cv_func_gethostbyaddr_r,
     [ncbi_cv_func_gethostbyaddr_r="no"
-Line 1644
+Line 2580
           ncbi_cv_func_gethostbyaddr_r="8"
         ]
      )
-     fi
-     if test "$ncbi_cv_func_gethostbyaddr_r" = "no" ; then
-     AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
-        [[
-          #include <netdb.h>
-          #include <sys/types.h>
-          #include <sys/socket.h>
-        ]],
-        [[
-          void* dummy = (void*) &gethostbyaddr_r;
-          int                  err;
-          unsigned int         host;
-          struct hostent*      hp = 0;
-          struct hostent_data* hdp = 0;
-          int res = gethostbyaddr_r((char *) &host, sizeof(host), AF_INET,
-                                    hp, hdp);
-        ]])],
-        [
-          ncbi_cv_func_gethostbyaddr_r="5"
-        ]
-     )
      fi])
  if test "$ncbi_cv_func_gethostbyaddr_r" != "no" ; then
     AC_DEFINE_UNQUOTED(HAVE_GETHOSTBYADDR_R, $ncbi_cv_func_gethostbyaddr_r,
      [If you have the `gethostbyaddr_r' function, define to the number of
-      arguments it takes (normally 5, 7 or 8).])
+      arguments it takes (normally 7 or 8).])
  fi
- ## getservbyname_r() -- 3 different variants: 5-arg (Solaris), 6-arg (Linux),
+ ## getservbyname_r() -- 2 different variants: 5-arg (Solaris), 6-arg (Linux).
- ## 4-arg (OSF/1 cruft)
  AC_CACHE_CHECK([for getservbyname_r], ncbi_cv_func_getservbyname_r,
     [ncbi_cv_func_getservbyname_r="no"
-Line 1706
+Line 2620
           ncbi_cv_func_getservbyname_r="6"
         ]
      )
-     fi
-     if test "$ncbi_cv_func_getservbyname_r" = "no" ; then
-     AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
-        [[#include <netdb.h>]],
-        [[
-          void*                dummy = (void*) &getservbyname_r;
-          int                  err;
-          struct servent*      sp = 0;
-          struct servent_data* sdp = 0;
-          err = getservbyname_r("", "", sp, sdp);
-        ]])],
-        [
-          ncbi_cv_func_getservbyname_r="4"
-        ]
-     )
      fi])
  if test "$ncbi_cv_func_getservbyname_r" != "no" ; then
     AC_DEFINE_UNQUOTED(HAVE_GETSERVBYNAME_R, $ncbi_cv_func_getservbyname_r,
      [If you have the `getservbyname_r' function, define to the number of
-      arguments it takes (normally 4, 5 or 6).])
+      arguments it takes (normally 5 or 6).])
  fi
+ ## getpwuid_r() -- 2 major variants: 4-arg, 5-arg (POSIX).
+ ## (Alternate 4-arg interface ignored due to rarity.)
- AC_CHECK_FUNCS(localtime_r pthread_setconcurrency pthread_atfork)
+ AC_CACHE_CHECK([for getpwuid_r], ncbi_cv_func_getpwuid_r,
+    [ncbi_cv_func_getpwuid_r="no"
+     AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+        [[#include <unistd.h>
+          #include <pwd.h>]],
+        [[struct passwd bpw;
+          char buf[1024];
+          char *dir = getpwuid_r(getuid(), &bpw, buf, sizeof(buf))->pw_dir;
+        ]])],
+        [ncbi_cv_func_getpwuid_r=4])
+     if test "$ncbi_cv_func_getpwuid_r" = "no" ; then
+     AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+        [[#include <unistd.h>
+          #include <pwd.h>]],
+        [[struct passwd *pw, bpw;
+          char buf[1024];
+          getpwuid_r(getuid(), &bpw, buf, sizeof(buf), &pw);
+        ]])],
+        [ncbi_cv_func_getpwuid_r=5])
+     fi])
- AC_SEARCH_LIBS(sched_yield, rt,
+ if test "$ncbi_cv_func_getpwuid_r" != "no" ; then
-     AC_DEFINE(HAVE_SCHED_YIELD, 1,
+    AC_DEFINE_UNQUOTED(NCBI_HAVE_GETPWUID_R, $ncbi_cv_func_getpwuid_r,
-               [Define to 1 if you have the `sched_yield' function.])
+     [If you have the `getpwuid_r' function, define to the number of
- )
+      arguments it takes (normally 4 or 5).])
+ fi
+ # Perform a full-fledged check in C++ to be sure of an actual declaration.
+ # Accommodate the old Solaris interface that returns char* rather than int. :-/
+ AC_CACHE_CHECK([for getlogin_r], ncbi_cv_func_getlogin_r,
+    [ncbi_cv_func_getlogin_r="no"
+     AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+        [[#include <unistd.h>]],
+        [[char buf[64]; /* return */ getlogin_r(buf, 64);]])],
+        [ncbi_cv_func_getlogin_r=yes], [ncbi_cv_func_getlogin_r=no])])
+ if test $ncbi_cv_func_getlogin_r = yes; then
+    AC_DEFINE(HAVE_GETLOGIN_R, 1,
+       [Define to 1 if you have the `getlogin_r' function])
+ fi
+ AC_LANG_PUSH(C)
+ # some of these can lose in C++ due to the way autoconf works
+ AC_CHECK_FUNCS(localtime_r pthread_setconcurrency pthread_atfork)
+ if test "$ac_cv_func_localtime_r" = "yes" ; then
+    AC_CACHE_CHECK(return type of localtime_r, ac_cv_func_which_localtime_r,
+       [AC_COMPILE_IFELSE(
+           [AC_LANG_PROGRAM(
+              [[#include <unistd.h>
+                #include <time.h>]],
+              [[struct tm mytm;
+                time_t t;
+                int y = localtime_r(&t, &mytm)->tm_year;]])],
+           ac_cv_func_which_localtime_r=struct,
+           ac_cv_func_which_localtime_r=int)])
+    if test $ac_cv_func_which_localtime_r = struct; then
+       AC_DEFINE(HAVE_FUNC_LOCALTIME_R_TM, 1,
+          [Define to 1 if your localtime_r returns a struct tm*.])
+    else
+      AC_DEFINE(HAVE_FUNC_LOCALTIME_R_INT, 1,
+         [Define to 1 if your localtime_r returns a int.])
+    fi
+ fi
+ AC_CACHE_CHECK([whether pthread mutexes are available],
+    ncbi_cv_func_pthread_mutex,
+    [AC_LINK_IFELSE([AC_LANG_PROGRAM(
+        [[#include <pthread.h>
+          pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;]],
+        [[pthread_mutex_lock(&mutex); pthread_mutex_unlock(&mutex);]])],
+       [ncbi_cv_func_pthread_mutex=yes], [ncbi_cv_func_pthread_mutex=no])])
+ if test $ncbi_cv_func_pthread_mutex=yes; then
+    AC_DEFINE(HAVE_PTHREAD_MUTEX, 1,
+       [Define to 1 if pthread mutexes are available.])
  fi
- ### ...reentrant versions of some standard library functions, MT functions
  ### Check for other standard library functions
- AC_LANG_PUSH(C)
+ AC_FUNC_VPRINTF
- # some of these can lose in C++ due to the way autoconf works
+ AC_CHECK_FUNCS(euidaccess atoll basename lchown fseeko getpagesize \
- AC_CHECK_FUNCS(strcasecmp strdup sysmp timegm atoll vasprintf getpagesize)
+                getpass getpassphrase getpwuid getrusage gettimeofday \
+                getuid readpassphrase readv usleep \
+                asprintf vasprintf vsnprintf select statfs statvfs \
+                strcasecmp strlcat strlcpy strdup strndup strtok_r \
+                sysmp timegm utimes lutimes writev)
  AC_LANG_POP(C)
+ AC_TYPE_SIGNAL
+ test "$ac_cv_func_select" = yes  ||  ncbi_cv_func_select_updates_timeout=no
+ AC_CACHE_CHECK([whether select updates the timeout when interrupted],
+                ncbi_cv_func_select_updates_timeout,
+    [AC_RUN_IFELSE([AC_LANG_PROGRAM(
+        [[#include <signal.h>
+          #include <sys/types.h>
+          #ifdef HAVE_SYS_SELECT_H
+          #  include <sys/select.h>
+          #endif
+          #ifdef HAVE_SYS_TIME_H
+          #  include <sys/time.h>
+          #endif
+          #ifdef HAVE_UNISTD_H
+          #  include <unistd.h>
+          #endif
+          RETSIGTYPE handler(int sig) { }]],
+        [[struct timeval timeout = { 5, 0 };
+          signal(SIGALRM, &handler);
+          alarm(1);
+          select(0, NULL, NULL, NULL, &timeout);
+          return timeout.tv_sec == 5;]])],
+        [ncbi_cv_func_select_updates_timeout=yes],
+        [ncbi_cv_func_select_updates_timeout=no],
+        [case "$host_os" in
+           linux) ncbi_cv_func_select_updates_timeout=yes ;;
+           *) ncbi_cv_func_select_updates_timeout=no ;;
+         esac])])
+ if test "$ncbi_cv_func_select_updates_timeout" = yes; then
+    AC_DEFINE(SELECT_UPDATES_TIMEOUT, 1,
+       [Define to 1 if the `select' function updates its timeout when
+        interrupted by a signal.])
+ fi
+ # We want the program to return 0, which is *false* in C.  Also, since
+ # use of lowercase seems to be customary if not universal, the default
+ # is yes when cross-compiling; anyone cross-compiling for exceptional
+ # platforms can set ncbi_cv_func_strcasecmp_lc=no in config.site.
+ if test "$ac_cv_func_strcasecmp" = yes; then
+    AC_CACHE_CHECK([whether strcasecmp treats letters as lowercase],
+                   ncbi_cv_func_strcasecmp_lc,
+       [AC_RUN_IFELSE([AC_LANG_PROGRAM(
+           [[#include <string.h>]],
+           [[return strcasecmp("A", "_") <= 0;]])],
+           [ncbi_cv_func_strcasecmp_lc=yes], [ncbi_cv_func_strcasecmp_lc=no],
+           [ncbi_cv_func_strcasecmp_lc=yes])])
+    if test "$ncbi_cv_func_strcasecmp_lc" = yes; then
+       AC_DEFINE(HAVE_STRCASECMP_LC, 1,
+                 [Define to 1 if strcasecmp treats letters as lowercase.])
+    fi
+ fi
  AC_CACHE_CHECK([for Linux-like sysinfo with 1 arg], ncbi_cv_func_sysinfo_1,
     [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
         [[#include <sys/sysinfo.h>]],
-Line 1766
+Line 2788
  dnl AC_FUNC_GETLOADAVG
  AC_CHECK_FUNCS(getloadavg)
+ ## readdir_r() -- 2 different variants: 2-arg (trad. Solaris), 3-arg (POSIX).
+ AC_CACHE_CHECK([for readdir_r], ncbi_cv_func_readdir_r,
+    [ncbi_cv_func_readdir_r="no"
+     AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+        [[#include <dirent.h>]],
+        [[DIR* dir; struct dirent* entry; readdir_r(dir, entry, &entry);]])],
+        [ncbi_cv_func_readdir_r=3])
+     if test "$ncbi_cv_func_readdir_r" = "no" ; then
+     AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+        [[#include <dirent.h>]],
+        [[DIR* dir; struct dirent* entry; readdir_r(dir, entry);]])],
+        [ncbi_cv_func_readdir_r=2])
+     fi])
+ if test "$ncbi_cv_func_readdir_r" != "no" ; then
+    AC_DEFINE_UNQUOTED(NCBI_HAVE_READDIR_R, $ncbi_cv_func_readdir_r,
+     [If you have the `readdir_r' function, define to the number of
+      arguments it takes (normally 2 or 3).])
+ fi
  ### Check for typedefs, structures, and compiler features.
  AC_C_CONST
- AC_TYPE_SIZE_T
  ### Check for C standard types and sizes
+ if test "${with_universal-no}" = "no"; then
  AC_C_BIGENDIAN
  AC_C_CHAR_UNSIGNED
- AC_CHECK_SIZEOF(void*)
  AC_CHECK_SIZEOF(char)
- AC_CHECK_SIZEOF(short)
+    AC_CHECK_SIZEOF(double)
+    AC_CHECK_SIZEOF(float)
  AC_CHECK_SIZEOF(int)
  AC_CHECK_SIZEOF(long)
+    AC_CHECK_SIZEOF(long double)
  AC_CHECK_SIZEOF(long long)
+    AC_CHECK_SIZEOF(short)
+    AC_CHECK_SIZEOF(void*)
  AC_CHECK_SIZEOF(__int64)
- AC_CHECK_SIZEOF(float)
+ fi
- AC_CHECK_SIZEOF(double)
+ AC_CHECK_TYPES([intptr_t, uintptr_t])
- AC_CHECK_SIZEOF(long double)
- AC_CHECK_SIZEOF(size_t)
- NCBI_PLATFORM_BITS=`expr 8 \* $ac_cv_sizeof_size_t`
- AC_DEFINE_UNQUOTED(NCBI_PLATFORM_BITS, $NCBI_PLATFORM_BITS,
-                    [Define to the architecture size.])
  AC_CHECK_MEMBER(struct sockaddr_in.sin_len,
     [AC_DEFINE(HAVE_SIN_LEN, 1,
-Line 1794
+Line 2835
     [], [#include <sys/types.h>
          #include <netinet/in.h>])
+ AC_CHECK_MEMBERS([struct tm.tm_zone, struct tm.__tm_zone], [], [],
+    [#include <time.h>])
  AC_CACHE_CHECK([whether function prototypes can use throw(...)],
     ncbi_cv_cxx_throw_spec,
-Line 1865
+Line 2909
  fi
- AC_CACHE_CHECK([for ios(_base)::xalloc and related functions],
+ AC_CACHE_CHECK([for ios(_base)::register_callback],
-    ncbi_cv_func_ios_xalloc,
+    ncbi_cv_func_ios_register_callback,
     [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
         [[#include <iostream>]],
-        [[std::cout.pword(std::ios::xalloc());
+        [[std::cout.register_callback(0, std::ios::erase_event);]])],
-          std::cout.register_callback(0, std::ios::erase_event);]])],
+        [ncbi_cv_func_ios_register_callback=yes],
-        [ncbi_cv_func_ios_xalloc=yes], [ncbi_cv_func_ios_xalloc=no])])
+        [ncbi_cv_func_ios_register_callback=no])])
- if test "$ncbi_cv_func_ios_xalloc" = yes; then
+ if test "$ncbi_cv_func_ios_register_callback" = yes; then
-    AC_DEFINE(HAVE_IOS_XALLOC, 1,
+    AC_DEFINE(HAVE_IOS_REGISTER_CALLBACK, 1,
-              [Define to 1 if ios(_base)::xalloc et al. exist.])
+              [Define to 1 if you have `ios(_base)::register_callback'.])
  fi
-Line 1922
+Line 2966
  fi
+ AC_CACHE_CHECK([for std::is_sorted<> in <algorithm>], ncbi_cv_func_is_sorted,
+    [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+        [[#include <algorithm>]],
+        [[int a[2]; return std::is_sorted(a, a+2) ? 0 : 1;]])],
+        [ncbi_cv_func_is_sorted=yes], [ncbi_cv_func_is_sorted=no])])
+ if test "$ncbi_cv_func_is_sorted" = yes; then
+    AC_DEFINE(HAVE_IS_SORTED, 1,
+              [Define to 1 if <algorithm> supplies `std::is_sorted<>'.])
+ fi
+ AC_CACHE_CHECK([for SysV semaphores], ncbi_cv_sys_semaphores,
+    AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>
+ #include <sys/sem.h>],
+       [struct sembuf buf; int id = semget(0x1234, 0, IPC_CREAT);
+        buf.sem_op = SEM_UNDO;])],
+       [ncbi_cv_sys_semaphores=yes], [ncbi_cv_sys_semaphores=no]))
+ if test "$ncbi_cv_sys_semaphores" = yes; then
+    AC_DEFINE(HAVE_SYSV_SEMAPHORES, 1,
+              [Define to 1 if you have SysV semaphores.])
+ fi
  AC_CHECK_TYPE([union semun],
     AC_DEFINE(HAVE_SEMUN, 1, [Define to 1 if you have `union semun'.]),
-    [], [#include <sys/sem.h>])
+    [], [#include <sys/types.h>
+ #include <sys/sem.h>])
  AC_CACHE_CHECK([which way the stack grows], ncbi_cv_sys_stack_dir,
-Line 1938
+Line 3006
   down) AC_DEFINE(STACK_GROWS_DOWN, 1, [Define to 1 if the stack grows down.]);;
  esac
+ AC_LANG_PUSH(C)
  AC_CACHE_CHECK([whether the preprocessor supports C99-style variadic macros],
     ncbi_cv_cpp_std_varargs,
-    [AC_PREPROC_IFELSE(
+    [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
         [[#define foo(...) 1
           #if foo(x,y,z) != 1
           #error failed
-          #endif]],
+          #endif]], [])],
         [ncbi_cv_cpp_std_varargs=yes], [ncbi_cv_cpp_std_varargs=no])])
  if test "$ncbi_cv_cpp_std_varargs" = yes; then
     AC_DEFINE(HAVE_CPP_STD_VARARGS, 1,
-Line 1954
+Line 3023
  AC_CACHE_CHECK([whether the preprocessor supports GNU-style variadic macros],
     ncbi_cv_cpp_gnu_varargs,
-    [AC_PREPROC_IFELSE(
+    [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
         [[#define foo(args...) 1
           #if foo(x,y,z) != 1
           #error failed
-          #endif]],
+          #endif]], [])],
         [ncbi_cv_cpp_gnu_varargs=yes], [ncbi_cv_cpp_gnu_varargs=no])])
  if test "$ncbi_cv_cpp_gnu_varargs" = yes; then
     AC_DEFINE(HAVE_CPP_GNU_VARARGS, 1,
        [Define to 1 if the preprocessor supports GNU-style variadic macros.])
  fi
+ AC_LANG_POP(C)
+ # Avoid using unsupported (and noisily ignored) attributes.
+ case "$compiler:$compiler_version" in
+    GCC:2* | GCC:3[[01]]* | WorkShop* )
+       ncbi_cv_c_deprecation_syntax=none
+       ncbi_cv_c_forceinline=inline
+       ;;
+    VisualAge:* )
+       ncbi_cv_c_forceinline=inline
+       ;;
+ esac
+ AC_CACHE_CHECK([syntax for marking deprecated functions],
+    ncbi_cv_c_deprecation_syntax,
+    [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+        [[void f(void) __attribute__((__deprecated__)); void f(void) { }]],
+        [[f();]])],
+       [ncbi_cv_c_deprecation_syntax='__attribute__((__deprecated__))'],
+       [ncbi_cv_c_deprecation_syntax=none])])
+ depr=$ncbi_cv_c_deprecation_syntax
+ test "$depr" = "none"  &&  depr=""
+ AC_DEFINE_UNQUOTED(NCBI_DEPRECATED, $depr,
+    [Define to whatever syntax, if any, your compiler supports for marking
+     functions as deprecated.])
+ AC_LANG_PUSH(C)
+ AC_CACHE_CHECK([how to force inlining],
+    ncbi_cv_c_forceinline,
+    [ncbi_cv_c_forceinline=no
+     for fi in forceinline __forceinline__ __forceinline __always_inline \
+       "inline __attribute__((always_inline))" inline __inline__; do
+        test "$ncbi_cv_c_forceinline" = "no" || break
+        AC_COMPILE_IFELSE([AC_LANG_SOURCE([$fi int f(void) { return 0; }])],
+           [ncbi_cv_c_forceinline=$fi], [])
+     done])
+ forceinline=$ncbi_cv_c_forceinline
+ test "$forceinline" = "no"  &&  forceinline=""
+ AC_DEFINE_UNQUOTED(NCBI_FORCEINLINE, $forceinline,
+    [Define to whatever syntax your compiler supports for marking functions
+     as to be inlined even if they might not otherwise be.])
+ AC_CACHE_CHECK([whether the C compiler supports __attribute__((destructor))],
+    ncbi_cv_c_attribute_destructor,
+    [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+        [[void f(void) __attribute__((destructor)); void f(void) { }]],
+        [[f();]])],
+       [ncbi_cv_c_attribute_destructor=yes],
+       [ncbi_cv_c_attribute_destructor=no])])
+ if test $ncbi_cv_c_attribute_destructor = yes; then
+    AC_DEFINE(HAVE_ATTRIBUTE_DESTRUCTOR, 1,
+       [Define to 1 if your C compiler supports __attribute__((destructor))])
+ fi
+ case "$compiler:$compiler_version $CFLAGS $CXXFLAGS" in
+    GCC:[[4-9]]??\ *\ -fvisibility*|ICC:*\ -fvisibility* ) ;;
+    * ) ncbi_cv_c_attribute_visibility_default=unnecessary ;;
+ esac
+ AC_CACHE_CHECK([whether $CC supports __attribute__((visibility("default")))],
+    ncbi_cv_c_attribute_visibility_default,
+    [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+        [[__attribute__((visibility("default"))) void f(void); void f(void) {}]],
+        [[f();]])],
+       [ncbi_cv_c_attribute_visibility_default=yes],
+       [ncbi_cv_c_attribute_visibility_default=no])])
+ if test $ncbi_cv_c_attribute_visibility_default = yes; then
+    AC_DEFINE(HAVE_ATTRIBUTE_VISIBILITY_DEFAULT, 1,
+       [Define to 1 if your compiler supports __attribute__((visibility("default")))])
+ fi
+ AC_CACHE_CHECK([whether the C compiler supports C99 restrict],
+    ncbi_cv_c_restrict,
+    [ncbi_cv_c_restrict=no
+     for restrict in restrict __restrict__ __restrict; do
+        test "$ncbi_cv_c_restrict" = "no" || break
+        AC_COMPILE_IFELSE([AC_LANG_SOURCE([void f(int * $restrict p);])],
+           [ncbi_cv_c_restrict=$restrict], [])
+     done])
+ restrict=$ncbi_cv_c_restrict
+ test "$restrict" = "no"  &&  restrict=""
+ AC_DEFINE_UNQUOTED(NCBI_RESTRICT_C, $restrict,
+    [Define to whatever syntax, if any, your C compiler supports for marking
+     pointers as restricted in the C99 sense.])
+ if test -n "$restrict"; then
+    AC_DEFINE(HAVE_RESTRICT_C, 1,
+       [Define to 1 if your C compiler supports some variant of the C99
+        `restrict' keyword.])
+ fi
+ AC_LANG_POP(C)
+ AC_CACHE_CHECK([whether the C++ compiler supports C99 restrict],
+    ncbi_cv_cxx_restrict,
+    [ncbi_cv_cxx_restrict=no
+     for restrict in restrict __restrict__ __restrict; do
+        test "$ncbi_cv_cxx_restrict" = "no" || break
+        AC_COMPILE_IFELSE([AC_LANG_SOURCE([void f(int * $restrict p);])],
+           [ncbi_cv_cxx_restrict=$restrict], [])
+     done])
+ restrict=$ncbi_cv_cxx_restrict
+ test "$restrict" = "no"  &&  restrict=""
+ AC_DEFINE_UNQUOTED(NCBI_RESTRICT_CXX, $restrict,
+    [Define to whatever syntax, if any, your C++ compiler supports for marking
+     pointers as restricted in the C99 sense.])
+ if test -n "$restrict"; then
+    AC_DEFINE(HAVE_RESTRICT_CXX, 1,
+       [Define to 1 if your C++ compiler supports some variant of the C99
+        `restrict' keyword.])
+ fi
  # for FreeTDS
  AC_CACHE_CHECK([whether FIONBIO requires BSD_COMP to be defined],
-Line 2009
+Line 3187
               [Define to 0xffffffff if your operating system doesn't.])
  fi
+ AC_CACHE_CHECK([whether unaligned reads are permissible],
+                ncbi_cv_sys_unaligned_reads,
+    [AC_RUN_IFELSE([AC_LANG_PROGRAM([[ #include <stdio.h> ]],
+        [[ unsigned int a[2] = { 0x01234567, 0x89abcdef };
+           fprintf(stderr, "%x\n", *(unsigned int*)((char*)a + 1)); ]])],
+        [ncbi_cv_sys_unaligned_reads=yes],
+        [ncbi_cv_sys_unaligned_reads=no],
+        [case "$host_cpu" in
+           i?86|x86_64|powerpc*|ppc*) ncbi_cv_sys_unaligned_reads=yes ;;
+           *)                         ncbi_cv_sys_unaligned_reads=no  ;;
+         esac])])
+ if test "$ncbi_cv_sys_unaligned_reads" = yes; then
+    AC_DEFINE(HAVE_UNALIGNED_READS, 1,
+              [Define to 1 if your system permits reading integers from
+               unaligned addresses.])
+ fi
  ### Check for the availability of other packages
  ### --------------------------------------------
+ AC_MSG_CHECKING([whether in-house NCBI resources are available])
+ if test -n "$NCBI" -a -f "$NCBI/.ncbirc" -a -d /am/coremake_builds/test_data; \
+ then
+    NCBI_FEATURE(in-house-resources)
+    AC_MSG_RESULT(yes)
+ else
+    AC_MSG_RESULT(no)
+ fi
  ### Common-use system and miscellaneous libs
  if test -z "${NETWORK_LIBS+set}"; then
     AC_CHECK_LIB(nsl, gethostbyname, [libnsl=-lnsl], [libnsl=])
     AC_CHECK_LIB(socket, connect, [NETWORK_LIBS="-lsocket $libnsl"],
        [NETWORK_LIBS=$libnsl])
  fi
- AC_CHECK_LIB(resolv, res_search, [RESOLVER_LIBS="-lresolv"], [RESOLVER_LIBS=])
+ AC_CACHE_CHECK([for res_search in -lresolv], ac_cv_lib_resolv_res_search,
+    [orig_LIBS=$LIBS
- if test "$with_ncbi_public" = "yes"  -a  "$OSTYPE" = "solaris"; then
+     LIBS="-lresolv $NETWORK_LIBS $orig_LIBS"
-    AC_MSG_NOTICE([Skipping checks for get{addr,name}info (new in Solaris 8).])
+     AC_LINK_IFELSE([AC_LANG_PROGRAM(
+        [[#include <resolv.h>]],
+        [[unsigned char ans[256];
+          int st = res_search("foo.bar", 1, 1, ans, sizeof(ans));]])],
+        [ac_cv_lib_resolv_res_search=yes], [ac_cv_lib_resolv_res_search=no])
+     LIBS=$orig_LIBS])
+ if test "$ac_cv_lib_resolv_res_search" = "yes"; then
+    RESOLVER_LIBS=-lresolv
  else
+    RESOLVER_LIBS=
+ fi
     orig_LIBS=$LIBS
     LIBS="$NETWORK_LIBS $orig_LIBS"
-    AC_CHECK_FUNCS(getaddrinfo getnameinfo)
+ AC_CHECK_FUNCS(inet_ntoa_r)
-    LIBS=$orig_LIBS
+ if test "$with_ncbi_public" = "yes"  -a  "$OSTYPE" = "solaris"; then
+    AC_MSG_NOTICE([Skipping checks for network functions new to Solaris 8.])
+ else
+    AC_CACHE_CHECK([for getaddrinfo], ac_cv_func_getaddrinfo,
+       [AC_LINK_IFELSE([AC_LANG_PROGRAM(
+           [[#include <netdb.h>]],
+           [[struct addrinfo *p; getaddrinfo("foo", "bar", p, &p);]])],
+           [ac_cv_func_getaddrinfo=yes], [ac_cv_func_getaddrinfo=no])])
+    test "$ac_cv_func_getaddrinfo" = "yes" && \
+      AC_DEFINE(HAVE_GETADDRINFO, 1,
+                [Define to 1 if you have the `getaddrinfo' function.])
+    AC_CACHE_CHECK([for getnameinfo], ac_cv_func_getnameinfo,
+       [AC_LINK_IFELSE([AC_LANG_PROGRAM(
+           [[#include <netdb.h>
+             #include <sys/types.h>
+             #include <sys/socket.h>]],
+           [[struct sockaddr p; char buf[256], buf2[256];
+             getnameinfo(&p, sizeof(p), buf, 256, buf2, 256, 0);]])],
+           [ac_cv_func_getnameinfo=yes], [ac_cv_func_getnameinfo=no])])
+    test "$ac_cv_func_getnameinfo" = "yes" && \
+      AC_DEFINE(HAVE_GETNAMEINFO, 1,
+                [Define to 1 if you have the `getnameinfo' function.])
+    AC_CHECK_FUNCS(freehostent gethostent_r getipnodebyaddr getipnodebyname \
+                   inet_ntop)
  fi
+ LIBS=$orig_LIBS
- MATH_LIBS=${MATH_LIBS:="-lm"}
- ### Math lib to be always linked in
- LIBS="$MATH_LIBS $LIBS"
- C_LIBS="$MATH_LIBS $C_LIBS"
  ### Save original compiler/linker flags
-Line 2044
+Line 3275
  orig_LIBS="$LIBS"
+ ### Check for math functions that aren't always available
+ AC_CHECK_FUNCS(erf)
  NCBI_CHECK_LIBS(KSTAT, kstat, kstat_open)
  NCBI_CHECK_LIBS(RPCSVC, rpcsvc, rstat)
  AC_LANG_PUSH(C)
-Line 2053
+Line 3287
  AC_LANG_POP(C)
  case "$host_os:$compiler" in
       solaris*:GCC ) ac_cv_search_dlopen="-ldl" ;;
+      darwin*      ) ac_cv_search_iconv="-liconv" ;;
  esac
  NCBI_CHECK_LIBS(DL, dl, dlopen)
- # Normally redundant, but needed --with-static-exe.
+ # libc's stubs aren't always sufficient...
- # (Too bad there's no libdl.a.)
  case "$host_os:$libnsl" in
+      solaris2.[[89]]:* ) orig_LIBS="$DL_LIBS $orig_LIBS" ;;
       solaris*:-lnsl ) NETWORK_LIBS="$NETWORK_LIBS $DL_LIBS" ;;
  esac
+ dnl NCBI_CHECK_LIBS(UUID, uuid, uuid_generate)
+ AC_SEARCH_LIBS(uuid_generate, uuid,
+    [NCBI_PACKAGE(UUID)
+     test "x$ac_cv_search_uuid_generate" = "xnone required" || \
+        UUID_LIBS=$ac_cv_search_uuid_generate])
+ dnl NCBI_CHECK_LIBS(FUSE, fuse, fuse_loop)
+ AC_SEARCH_LIBS(fuse_loop, fuse, [NCBI_PACKAGE(FUSE)])
  NCBI_CHECK_LIBS(RT, rt posix4, clock_gettime)
- # For FreeTDS, which normally uses a somewhat more elaborate test
+ NCBI_CHECK_LIBS(DEMANGLE, demangle, cplus_demangle)
- NCBI_CHECK_LIBS(ICONV, iconv, iconv)
+ # Add to (orig_)LIBS if present for the sake of corelib and the
+ # following call to AC_CHECK_FUNCS.
+ if test -n "$DEMANGLE_LIBS$RT_LIBS"; then
+     LIBS="$DEMANGLE_LIBS $RT_LIBS $LIBS"
+     orig_LIBS="$DEMANGLE_LIBS $RT_LIBS $orig_LIBS"
+ fi
+ AC_CHECK_FUNCS([nanosleep sched_yield])
+ dnl NCBI_CHECK_LIBS(ICONV, iconv, iconv)
+ # We need to include <iconv.h>, since some implementations rename the symbols.
+ # This logic adapted from Bruno Haible's iconv.m4.
+ AC_CACHE_CHECK(for library containing iconv, ac_cv_search_iconv, [
+    ac_cv_search_iconv=no
+    AC_LINK_IFELSE(
+       [AC_LANG_PROGRAM(
+          [[#include <stdlib.h>
+            #include <iconv.h>]],
+          [[iconv_t cd = iconv_open("","");
+            iconv(cd,NULL,NULL,NULL,NULL);
+            iconv_close(cd);]])],
+       [ac_cv_search_iconv="none required"])
+    if test "$ac_cv_search_iconv" != "none required"; then
+       for l in iconv; do
+          LIBS="-l$l $orig_LIBS"
+          AC_LINK_IFELSE(
+             [AC_LANG_PROGRAM(
+                 [[#include <stdlib.h>
+                   #include <iconv.h>]],
+                 [[iconv_t cd = iconv_open("","");
+                   iconv(cd,NULL,NULL,NULL,NULL);
+                   iconv_close(cd);]])],
+             [ac_cv_search_iconv=-l$l])
+          LIBS="$orig_LIBS"
+       done
+    fi])
+ if test "x$ac_cv_search_iconv" != xno; then
+    AC_DEFINE(HAVE_LIBICONV, 1,
+    [Define to 1 if ICONV is available, either in its own library or as part
+     of the standard libraries.])
+    AC_MSG_CHECKING([for iconv declaration])
+    AC_CACHE_VAL(am_cv_proto_iconv, [
+       AC_COMPILE_IFELSE([[
+ #include <stdlib.h>
+ #include <iconv.h>
+ extern
+ #ifdef __cplusplus
+ "C"
+ #endif
+ #if defined(__STDC__) || defined(__cplusplus)
+ size_t iconv (iconv_t cd, char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);
+ #else
+ size_t iconv();
+ #endif
+ ]], am_cv_proto_iconv_arg1="", am_cv_proto_iconv_arg1="const")
+       am_cv_proto_iconv="extern size_t iconv (iconv_t cd, $am_cv_proto_iconv_arg1 char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);"])
+    am_cv_proto_iconv=`echo "[$]am_cv_proto_iconv" | tr -s ' ' | sed -e 's/( /(/'`
+    AC_MSG_RESULT([$]{ac_t:-
+        }[$]am_cv_proto_iconv)
+    AC_DEFINE_UNQUOTED(ICONV_CONST, $am_cv_proto_iconv_arg1,
+      [Define as const if the declaration of iconv() needs const.])
+    if test "x$ac_cv_search_iconv" != "xnone required"; then
+       ICONV_LIBS=$ac_cv_search_iconv
+    fi
+ fi
+ ### Third-party libraries
+ if test "$OSTYPE" = linux  -a  -d "$NCBI"; then
+    ncbi_rpath_sed="s,$NCBI/\\(.*\\),/opt/ncbi/$NCBI_PLATFORM_BITS/\\1:&,"
+ else
+    ncbi_rpath_sed=
+ fi
+ no_usr_lib='s,-L/usr/lib[[^/ ]]* ,,g; s,-L/lib[[^/ ]]* ,,g'
+ NCBI_CHECK_THIRD_PARTY_LIB(z,
+  [[AC_LANG_PROGRAM([#include <zlib.h>],
+       [[gzFile fp; char buf[1024]; int n = gzread(fp, buf, sizeof(buf))]])]])
+ if test -z "$Z_LIBS"; then
+    zlocal=util/compress/zlib
+    AC_MSG_NOTICE([using local zlib copy in $zlocal])
+    Z_PATH="<$zlocal>"
+    Z_INCLUDE="-I\$(includedir)/$zlocal -I\$(includedir0)/$zlocal"
+    # Z_LIBS="-lz"
+    Z_LIB="z"
+    # AC_DEFINE(USE_LOCAL_ZLIB, 1, [Define to 1 if using a local copy of zlib.])
+    NCBI_PACKAGE(Z)
+    NCBI_PACKAGE(LocalZ)
+ fi
+ NCBI_CHECK_THIRD_PARTY_LIB(bz2,
+  [[AC_LANG_PROGRAM([#include <bzlib.h>],
+       [[BZFILE* fp; char buf[1024]; int err;
+         int n = BZ2_bzRead(&err, fp, buf, sizeof(buf))]])]])
+ if test -z "$BZ2_LIBS"; then
+    bzlocal=util/compress/bzip2
+    AC_MSG_NOTICE([using local bzlib copy in $bzlocal])
+    BZ2_PATH="<$bzlocal>"
+    BZ2_INCLUDE="-I\$(includedir)/$bzlocal -I\$(includedir0)/$bzlocal"
+    # BZ2_LIBS="-lbz2"
+    BZ2_LIB="bz2"
+    AC_DEFINE(USE_LOCAL_BZLIB, 1, [Define to 1 if using a local copy of bzlib.])
+    NCBI_PACKAGE(BZ2)
+    NCBI_PACKAGE(LocalBZ2)
+ fi
+ : ${LZO_PATH=$NCBI/lzo2}
+ if test -d "$LZO_PATH"; then
+    NCBI_FIX_DIR(LZO_PATH)
+ fi
+ NCBI_CHECK_THIRD_PARTY_LIB_EX(lzo, LZO, lzo2,
+  [[AC_LANG_PROGRAM([#include <lzo/lzo1x.h>],
+       [[lzo_uint32 c = lzo_crc32(0, (const unsigned char*)"foo", 3);]])]])
+ if test -z "$PCRE_PATH"  &&  pcre-config --version >/dev/null 2>&1; then
+     p=`pcre-config --prefix`
+     test "x$p" = "x/usr"  ||  PCRE_PATH=$p
+ fi
+ NCBI_CHECK_THIRD_PARTY_LIB(pcre,
+  [[AC_LANG_PROGRAM([#include <pcre.h>],
+    [[const char*s[]={"x"}; pcre* p; pcre_extra* x = pcre_study(p, 1, s);]])]])
+ if test -z "$PCRE_LIBS"; then
+    pcrelocal=util/regexp
+    AC_MSG_NOTICE([using local PCRE copy in $pcrelocal])
+    PCRE_PATH="<$pcrelocal>"
+    PCRE_INCLUDE="-I\$(includedir)/$pcrelocal -I\$(includedir0)/$pcrelocal"
+    # PCRE_LIBS="-lregexp"
+    # PCREPOSIX_LIBS="-lregexp"
+    PCRE_LIB="regexp"
+    AC_DEFINE(USE_LOCAL_PCRE, 1, [Define to 1 if using a local copy of PCRE.])
+    NCBI_PACKAGE(PCRE)
+    NCBI_PACKAGE(LocalPCRE)
+ else
+    PCREPOSIX_LIBS=`echo "$PCRE_LIBS" | sed -e 's/-lpcre/-lpcreposix -lpcre/'`
+ fi
+ ## SSL/TLS libraries
+ case "$with_gnutls" in
+    no )       ac_cv_path_LIBGNUTLS_CONFIG=no ;;
+    yes | '' ) : ${GNUTLS_PATH=$NCBI/gnutls}  ;;
+    * )        GNUTLS_PATH=$with_gnutls       ;;
+ esac
+ if test -d "$GNUTLS_PATH"; then
+    NCBI_FIX_DIR(GNUTLS_PATH)
+ fi
+ AC_PATH_PROG(LIBGNUTLS_CONFIG, libgnutls-config, [], [${GNUTLS_BIN-$GNUTLS_PATH/${compiler_vpfx}${DEBUG_SFX}${mt_sfx}${bit64_sfx}/bin}:$GNUTLS_PATH/bin${bit64_sfx}:$GNUTLS_PATH/bin:$PATH])
+ if test "x$with_gnutls" != xno -a -x "$LIBGNUTLS_CONFIG"; then
+    if test -z "$GNUTLS_PATH"; then
+       p=`libgnutls-config --prefix`
+       test "x$p" = "x/usr"  ||  GNUTLS_PATH=$p
+    fi
+    GNUTLS_INCLUDE=`$LIBGNUTLS_CONFIG --cflags`
+    NCBI_RPATHIFY_OUTPUT(GNUTLS_LIBPATH, [$LIBGNUTLS_CONFIG --exec-prefix],
+       [s,^,-L,; s,$,/lib,;])
+    GNUTLS_CONFIG_LIBS="`$LIBGNUTLS_CONFIG --libs` $Z_LIBS"
+ else
+    AS_UNSET(GNUTLS_CONFIG_LIBS)
+ fi
+ NCBI_CHECK_THIRD_PARTY_LIB(gnutls,
+  [[AC_LANG_PROGRAM([[#include <gnutls/gnutls.h>]],
+    [[gnutls_session s; gnutls_init(&s, GNUTLS_CLIENT);]])]],
+  $GNUTLS_CONFIG_LIBS)
+ if test -n "$GNUTLS_CONFIG_LIBS"; then
+    NCBI_RPATHIFY_OUTPUT(GNUTLS_LIBS, [echo $GNUTLS_CONFIG_LIBS], [$no_usr_lib])
+ fi
+ NCBI_CHECK_THIRD_PARTY_LIB_EX(openssl, OPENSSL, ssl,
+  [[AC_LANG_PROGRAM([[#include <openssl/ssl.h>]],
+    [[SSL_library_init();]])]],
+  -lcrypto)
+ OPENSSL_STATIC_LIBS=$OPENSSL_LIBS
+ for d in `echo " $OPENSSL_LIBS" | fmt -w 1 | sed -ne 's/^ *-L//p'` \
+    /usr/local/lib${bit64_sfx} /usr/local/lib /usr/lib${bit64_sfx} /usr/lib; do
+    if test -f $d/libssl.a -a -f $d/libcrypto.a; then
+       OPENSSL_STATIC_LIBS="$d/libssl.a $d/libcrypto.a"
+       break
+    elif test -f $d/libssl.so -o -f $d/libssl.dylib; then
+       break
+    fi
+ done
+ if test -n "$GNUTLS_LIBS"; then
+    TLS_INCLUDE=$GNUTLS_INCLUDE
+    TLS_LIBS=$GNUTLS_LIBS
+ else
+    TLS_INCLUDE=$OPENSSL_INCLUDE
+    TLS_LIBS=$OPENSSL_LIBS
+ fi
  ## SYBASE libraries
  NETWORK_PURE_LIBS="$NETWORK_LIBS"
+ ncbi_xreader_pubseqos=
+ UNLESS_PUBSEQOS=
  if test "$with_sybase" != "no" ; then
     net_sybase_root="/netopt/Sybase/clients"
     local_sybase_root="/export/home/sybase/clients"
-    default_local_sybase="$local_sybase_root/current"
     sybase_lib=lib$bit64_sfx
-    : ${with_sybase_local:="no"}
+    resolve_sybase=true
+    default_pointer=default-${NCBI_PLATFORM_BITS}bit
     : ${with_sybase_new:="no"}
+    case "$host_os" in
+       linux* )
+          : ${with_sybase_local:=yes}
+          ;;
+       * )
+          if test -d "$net_sybase_root" ; then
+             : ${with_sybase_local:=no}
+          else
+             : ${with_sybase_local:=yes}
+          fi
+          ;;
+    esac
     if test "$with_sybase_local" != "no" ; then
        if test "$with_sybase_local" = "yes" ; then
-          with_sybase_local=${SYBASE_PATH:-$default_local_sybase}
+          if test -n "$SYBASE_PATH" ; then
-       fi
+             with_sybase_local=$SYBASE_PATH
-       AC_CACHE_CHECK([for local Sybase install in $with_sybase_local],
-          ncbi_cv_path_sybase_local,
-          [if test -d "$with_sybase_local"; then
-              ncbi_cv_path_sybase_local=yes
            else
-              ncbi_cv_path_sybase_local=no
+             if test "$with_sybase_new" = "yes" ; then
-           fi])
+                with_sybase_local=$local_sybase_root/new
-       if test "$ncbi_cv_path_sybase_local" = yes; then
+             elif test -f "$local_sybase_root/$default_pointer" ; then
+                with_sybase_local=`cat $local_sybase_root/$default_pointer`
+                resolve_sybase=false
+             else
+                with_sybase_local=$local_sybase_root/current
+             fi
+             if test -d "$with_sybase_local$NCBI_PLATFORM_BITS" ; then
+                with_sybase_local=$with_sybase_local$NCBI_PLATFORM_BITS
+             fi
+          fi # default paths
+       fi # no command-line path
+       if test -d "$with_sybase_local" ; then
           SYBASE_PATH=$with_sybase_local
+          SYBASE_LCL_PATH=
        else
           with_sybase_local=no
        fi
     fi
     if test "$with_sybase_local" = "no" ; then
        if test "$with_sybase_new" = "yes" ; then
-          case "$host_os:$bit64_sfx" in
+          if test -d "$net_sybase_root/new$NCBI_PLATFORM_BITS" ; then
-             linux*     ) new_version=12.5.0.1; net_suffix="" ;;
+             SYBASE_LCL_PATH=$local_sybase_root/new$NCBI_PLATFORM_BITS
-             solaris*:64) new_version=12.5.64;  net_suffix="-EBF9728" ;;
+             SYBASE_PATH=$net_sybase_root/new$NCBI_PLATFORM_BITS
-             solaris*   ) new_version=12.5;     net_suffix="-EBF9723" ;;
+          elif test -d "$net_sybase_root/new" ; then
-             *          ) new_version="";
+             SYBASE_LCL_PATH=$local_sybase_root/new
-                          AC_MSG_WARN([--with-sybase-new is unsupported on this platform; ignoring it.]) ;;
+             SYBASE_PATH=$net_sybase_root/new
-          esac
-          if test -n "$new_version"; then
-             new_sybase_path=$net_sybase_root/$new_version-$net_suffix
-             new_sybase_local=$local_sybase_root/$new_version
-             AC_CACHE_CHECK([for new Sybase install in $new_sybase_local:$new_sybase_path],
-                ncbi_cv_path_sybase_new,
-                [if test -d $new_sybase_path; then
-                    if test -d $new_sybase_local; then
-                       ncbi_cv_path_sybase_new=yes
-                    else
-                       ncbi_cv_path_sybase_new=net-only
-                    fi
                  else
-                    ncbi_cv_path_sybase_new=no
-                 fi])
-             if test "$ncbi_cv_path_sybase_new" = no; then
                 with_sybase_new=no
-             else
-                SYBASE_PATH=$new_sybase_path
-                sybase_lib=lib
-                if "$ncbi_cv_path_sybase_new" = yes; then
-                   SYBASE_LCL_PATH=$new_sybase_local
                 fi
              fi
-          fi # New Sybase potentially available?
-       fi # New Sybase requested?
+       if test -z "$SYBASE_PATH" ; then
-       if test "$with_sybase_new" = "no" ; then
+          if test -f "$net_sybase_root/$default_pointer" ; then
-          : ${SYBASE_PATH:="$net_sybase_root/current"}
+             SYBASE_LCL_PATH=
-          : ${SYBASE_LCL_PATH:="$local_sybase_root/current"}
+             SYBASE_PATH=`cat $local_sybase_root/$default_pointer`
+             resolve_sybase=false
+          elif test -d "$net_sybase_root/current$NCBI_PLATFORM_BITS" ; then
+             SYBASE_LCL_PATH=$local_sybase_root/current$NCBI_PLATFORM_BITS
+             SYBASE_PATH=$net_sybase_root/current$NCBI_PLATFORM_BITS
+          elif test -d "$net_sybase_root/current" ; then
+             SYBASE_LCL_PATH=$local_sybase_root/current
+             SYBASE_PATH=$net_sybase_root/current
+          else
+             SYBASE_LCL_PATH=
+             SYBASE_PATH=$SYBASE
+          fi
+       fi
+    fi
+    # Lock in the version we found, ignoring symlinks further up
+    case "$SYBASE_PATH" in
+       */[[1-9]]* ) resolve_sybase=false ;;
+    esac
+    if test -d "$SYBASE_PATH"  &&  $resolve_sybase; then
+       # SYBASE_PATH_=`cd $SYBASE_PATH && /bin/pwd`
+       SYBASE_PATH_=`ls -ld $SYBASE_PATH | sed -ne 's/.* -> //p'`
+       case "$SYBASE_PATH_" in
+          '' ) ;;
+          /* )
+             SYBASE_VERSION=`basename $SYBASE_PATH_`
+             SYBASE_PATH=`dirname $SYBASE_PATH`/$SYBASE_VERSION
+             test -d "$SYBASE_PATH"  ||  SYBASE_PATH=$SYBASE_PATH_
+             ;;
+          * )
+             orig_parent=`dirname $SYBASE_PATH`
+             SYBASE_VERSION=`basename $SYBASE_PATH_`
+             SYBASE_PATH=$orig_parent/$SYBASE_VERSION
+             test -d "$SYBASE_PATH"  ||  SYBASE_PATH=$orig_parent/$SYBASE_PATH_
+             ;;
+       esac
+    fi
+    if test -d "$SYBASE_LCL_PATH"  &&  $resolve_sybase ; then
+       # SYBASE_LCL_PATH_=`cd $SYBASE_LCL_PATH && /bin/pwd`
+       SYBASE_LCL_PATH_=`ls -ld $SYBASE_LCL_PATH | sed -ne 's/.* -> //p'`
+       case "$SYBASE_LCL_PATH_" in
+          '' ) ;;
+          /* )
+             SYBASE_LCL_VERSION=`basename $SYBASE_LCL_PATH_`
+             SYBASE_LCL_PATH=`dirname $SYBASE_LCL_PATH`/$SYBASE_LCL_VERSION
+             test -d "$SYBASE_LCL_PATH"  ||  SYBASE_LCL_PATH=$SYBASE_LCL_PATH_
+             ;;
+          * )
+             orig_parent=`dirname $SYBASE_LCL_PATH`
+             SYBASE_LCL_VERSION=`basename $SYBASE_LCL_PATH_`
+             SYBASE_LCL_PATH=$orig_parent/$SYBASE_LCL_VERSION
+             test -d "$SYBASE_LCL_PATH"  || \
+                SYBASE_LCL_PATH=$orig_parent/$SYBASE_LCL_PATH_
+             ;;
+       esac
+    elif test -n "$SYBASE_LCL_PATH" ; then
+       SYBASE_LCL_PATH=`dirname $SYBASE_LCL_PATH`/$SYBASE_VERSION
+    fi
+    if test -n "$SYBASE_VERSION" -a -n "$SYBASE_LCL_VERSION" \
+         -a "$SYBASE_VERSION" != "$SYBASE_LCL_VERSION" ; then
+       AC_MSG_WARN([ignoring inconsistent local Sybase symlink: $SYBASE_LCL_VERSION vs. $SYBASE_VERSION])
+       SYBASE_LCL_PATH=`dirname $SYBASE_LCL_PATH`/$SYBASE_VERSION
+    fi
+    if test -n "$SYBASE" ; then
+       if test -d "$net_sybase_root" -o -d "$local_sybase_root" ; then
+          case $SYBASE in
+             $net_sybase_root/* | $local_sybase_root/* ) ;;
+             * ) AC_MSG_WARN([ignoring non-standard SYBASE setting: $SYBASE]) ;;
+             # Ignored regardless, but standard values are not so concerning.
+          esac
+       fi
        fi
-    fi # No local Sybase (requested)?
     SYBASE_LIBPATH="$SYBASE_PATH/${sybase_lib}"
     syb_sfx=$bit64_sfx
     if test "$with_mt" = "yes" ; then
        AC_CACHE_CHECK([for reentrant Sybase libraries], ncbi_cv_lib_sybase_r,
-          [if test -f "$SYBASE_LIBPATH/libct_r$bit64_sfx.a"; then
+          [if test -f "$SYBASE_LIBPATH/libct_r$bit64_sfx.so"; then
               ncbi_cv_lib_sybase_r=yes
            else
               ncbi_cv_lib_sybase_r=no
-Line 2150
+Line 3655
        linux*) sybtcl=-lsybtcl$syb_sfx; sybtli="" ;;
        *)      sybtcl=-ltcl$syb_sfx;    sybtli=-ltli$syb_sfx ;;
     esac
+    test -f "$SYBASE_LIBPATH/libtli.so" || sybtli=
     # quick-patch for the bad "tli" lib (Solaris8/Intel specific)
     case "$host_os:$host_vendor" in
-Line 2170
+Line 3676
     # deduce conf.macro: SYBASE_INCLUDE, SYBASE_LIBS, SYBASE_DLLS, SYBASE_DBLIBS
     SYBASE_INCLUDE="-I$SYBASE_PATH/include $SYBASE_INCLUDE"
     if test -z "$SYBASE_LCL_PATH" ; then
-       SYBASE_LPATH="-L$SYBASE_LIBPATH ${CONF_f_runpath}$SYBASE_LIBPATH"
+       NCBI_RPATHIFY(SYBASE_LPATH, $SYBASE_LIBPATH)
     else
        SYBASE_LCL_LIBPATH="$SYBASE_LCL_PATH/${sybase_lib}"
-       SYBASE_LPATH="-L$SYBASE_LCL_LIBPATH -L$SYBASE_LIBPATH ${CONF_f_runpath}$SYBASE_LCL_LIBPATH:$SYBASE_LIBPATH"
+       NCBI_RPATHIFY(SYBASE_LPATH, $SYBASE_LCL_LIBPATH $SYBASE_LIBPATH)
        SYBASE_INCLUDE="-I$SYBASE_LCL_PATH/include $SYBASE_INCLUDE"
     fi
     SYBASE_LIBS="$SYBASE_LPATH $SYBASE_LIBLIST"
-Line 2189
+Line 3695
            [ncbi_cv_lib_sybase=yes], [ncbi_cv_lib_sybase=no])])
     if test "$ncbi_cv_lib_sybase" = yes; then
-       WithPackages="$WithPackages Sybase"
+       NCBI_PACKAGE(Sybase)
        AC_DEFINE(HAVE_LIBSYBASE, 1,
                  [Define to 1 if SYBASE libraries are available.])
        if test "$with_mt" = "yes" -a "$ncbi_cv_lib_sybase_r" = "yes"; then
           AC_DEFINE(HAVE_SYBASE_REENTRANT, 1,
                     [Define to 1 if SYBASE has reentrant libraries.])
        fi
+       if test "$with_dbapi" != no -a -f ${real_srcdir}/src/objtools/data_loaders/genbank/pubseq/Makefile.ncbi_xreader_pubseqos.lib ; then
        AC_CACHE_CHECK([for PubSeq service availability], ncbi_cv_db_pubseq,
           [if grep PUBSEQ_OS $SYBASE_PATH/interfaces >/dev/null; then
               ncbi_cv_db_pubseq=yes
-Line 2205
+Line 3712
        if test "$ncbi_cv_db_pubseq" = yes; then
           AC_DEFINE(HAVE_PUBSEQ_OS, 1,
                     [Define to 1 if the PUBSEQ service is available.])
+             NCBI_FEATURE(PubSeqOS)
+             ncbi_xreader_pubseqos=ncbi_xreader_pubseqos
+             ncbi_xreader_pubseqos2=ncbi_xreader_pubseqos2
+             UNLESS_PUBSEQOS=\#
+          fi
        fi
        SYBASE_DBLIBS="$SYBASE_LPATH -lsybdb${bit64_sfx}"
        AC_CACHE_CHECK([for Sybase DBLib], ncbi_cv_lib_sybdb,
-          [CPPFLAGS="$SYBASE_INCLUDE $prig_CPPFLAGS"
+          [CPPFLAGS="$SYBASE_INCLUDE $orig_CPPFLAGS"
            LIBS="$SYBASE_DBLIBS $SYBASE_LIBS $SYBASE_DLLS $SYBASE_NETWORK_LIBS $DL_LIBS $orig_LIBS"
            AC_LINK_IFELSE([AC_LANG_PROGRAM(
               [[
-Line 2222
+Line 3734
               ]])],
               [ncbi_cv_lib_sybdb=yes], [ncbi_cv_lib_sybdb=no])])
        if test "$ncbi_cv_lib_sybdb" = yes; then
-          WithPackages="$WithPackages DBLib"
+          NCBI_PACKAGE(DBLib)
           AC_DEFINE(HAVE_LIBSYBDB, 1,
                     [Define to 1 if SYBASE DBLib is available.])
        else
-          WithoutPackages="$WithoutPackages DBLib"
           SYBASE_DBLIBS=
        fi
        # apply the Sybase patch to $NETWORK_LIBS
-Line 2234
+Line 3745
           NETWORK_LIBS="$SYBASE_LPATH $SYBASE_NETWORK_LIBS"
        fi
     else
-       with_sybase=no
+       NCBI_MISSING_PACKAGE(sybase)
     fi
  fi # with_sybase != no?
  if test "$with_sybase" = no; then
-    WithoutPackages="$WithoutPackages Sybase DBLib"
     SYBASE_PATH="No_Sybase"
     SYBASE_INCLUDE=
     SYBASE_LIBS=
-Line 2257
+Line 3767
  ## FreeTDS libraries
  freetds=
  if test "$with_ftds" != "no" ; then
-    if test -z "$with_ftds"  -o  "$with_ftds" = "yes" ; then
+    ftds64=ftds64
-       with_ftds=8
+    try_local=yes
-    fi
+    : ${FTDS_PATH:="/netopt/Sybase/clients-mssql/current"}
-    if test "$with_ftds" = 8 ; then
+    case "$with_ftds" in
-       FTDS8_LOCAL_PATH="dbapi/driver/ftds8/freetds"
+| yes | '' )
-       if test -f ${srcdir}/src/$FTDS8_LOCAL_PATH/Makefile.in ; then
+          ftds_ver=64
-          FTDS8_LIB="sybdb_ftds${STATIC} tds_ftds${STATIC}"
+          ftds64=ftds
-          FTDS8_PATH="<$FTDS8_LOCAL_PATH>"
+          ;;
-          FTDS8_INCLUDE="-I\$(includedir)/$FTDS8_LOCAL_PATH -I\$(includedir0)/$FTDS8_LOCAL_PATH"
+       * )
+          FTDS_PATH=$with_ftds
+          try_local=no
+          ;;
+    esac
+    : ${FTDS_CTLIBS:="-lct -ltds"}
+    NCBI_RPATHIFY(FTDS_CTLIBS,   $FTDS_PATH/lib,      [ ]$FTDS_CTLIBS)
+    FTDS_INCLUDE="-I$FTDS_PATH/include"
+    NCBI_LOCAL_FTDS(64)
+    if test -n "$freetds" ; then
+       FTDS_LIB="\$(FTDS${ftds_ver}_LIB)"
+       FTDS_LIBS="\$(FTDS${ftds_ver}_LIBS)"
+       FTDS_INCLUDE="\$(FTDS${ftds_ver}_INCLUDE)"
+       if test "$with_ftds_renamed" != "no" ; then
+           AC_DEFINE(NCBI_FTDS_RENAME_SYBDB, 1,
+                     [Rename DBLIB symbols in FTDS to avoid name clash with Sybase DBLIB.])
        fi
-       test -n "$FTDS8_PATH" && FTDS_PATH=$FTDS8_PATH && freetds="freetds"
+       AC_MSG_NOTICE([Using bundled FreeTDS (version $ftds_ver) from $FTDS_PATH])
     else
-       FTDS_PATH="$with_ftds"
+       FTDS_LIBS="$FTDS_CTLIBS"
-    fi
-    if test -n "$freetds" ; then
-       FTDS_LIB="\$(FTDS${with_ftds}_LIB)"
-       FTDS_INCLUDE="\$(FTDS${with_ftds}_INCLUDE)"
-       AC_MSG_NOTICE([Using bundled FreeTDS (protocol v$with_ftds) from $FTDS_PATH])
-    else
-       FTDS_PATH=${FTDS_PATH:="/netopt/Sybase/clients-mssql/current"}
-       FTDS_LIBS=${FTDS_LIBS:="-lsybdb -ltds"}
-       FTDS_LIBS="-L$FTDS_PATH/lib ${CONF_f_runpath}$FTDS_PATH/lib $FTDS_LIBS"
-       FTDS_INCLUDE="-I$FTDS_PATH/include"
        AC_CACHE_CHECK([for FreeTDS in $FTDS_PATH], ncbi_cv_lib_freetds,
           [CPPFLAGS="$FTDS_INCLUDE $orig_CPPFLAGS"
            LIBS="$FTDS_LIBS $NETWORK_LIBS $orig_LIBS"
-Line 2298
+Line 3812
              ]])],
              [ncbi_cv_lib_freetds=yes], [ncbi_cv_lib_freetds=no])])
        if test "$ncbi_cv_lib_freetds" = "no"; then
-          with_ftds=no
+          # Don't panic when using partial trees lacking dbapi/driver/ftdsN.
-       else
+          NCBI_MISSING_PACKAGE(ftds)
-          FTDS8_INCLUDE=$FTDS_INCLUDE
-          FTDS8_LIBS=$FTDS_LIBS
        fi
     fi
  fi
-Line 2310
+Line 3822
     FTDS_INCLUDE=
     FTDS_LIBS=
     FTDS_LIB=
-    FTDS8_INCLUDE=
+    FTDS64_INCLUDE=
-    FTDS8_LIBS=
+    FTDS64_LIBS=
-    FTDS8_LIB=
+    FTDS64_LIB=
+    FTDS64_CTLIB_INCLUDE=
+    FTDS64_CTLIB_LIBS=
+    FTDS64_CTLIB_LIB=
     freetds=
-    WithoutPackages="$WithoutPackages FreeTDS"
  else
     AC_DEFINE(HAVE_LIBFTDS, 1,
               [Define to 1 if FreeTDS libraries are available.])
-    WithPackages="$WithPackages FreeTDS"
+    NCBI_PACKAGE(FreeTDS)
  fi
- AC_SUBST(FTDS8_INCLUDE)
+ AC_SUBST(FTDS64_INCLUDE)
- AC_SUBST(FTDS8_LIBS)
+ AC_SUBST(FTDS64_LIBS)
- AC_SUBST(FTDS8_LIB)
+ AC_SUBST(FTDS64_LIB)
+ AC_SUBST(FTDS64_CTLIB_INCLUDE)
+ AC_SUBST(FTDS64_CTLIB_LIBS)
+ AC_SUBST(FTDS64_CTLIB_LIB)
  AC_SUBST(FTDS_INCLUDE)
  AC_SUBST(FTDS_LIBS)
  AC_SUBST(FTDS_LIB)
  AC_SUBST(freetds)
+ AC_SUBST(ftds64)
  ## MySQL
  if test "$with_mysql" != "no" ; then
-    : ${MYSQL_BINPATH=${MYSQL_PATH-/netopt/mysql/current}/bin}
+    case "$with_mysql" in
+       yes | "" ) : ${MYSQL_PATH=/netopt/mysql/current} ;;
+       *        ) MYSQL_PATH=$with_mysql ;;
+    esac
+    : ${MYSQL_BINPATH=$MYSQL_PATH/bin}
     AC_PATH_PROG(mysql_config, mysql_config, [], [$MYSQL_BINPATH:$PATH])
     if test -n "$mysql_config" ; then
        : ${MYSQL_BINPATH=`dirname $mysql_config`}
        # Kill off single quotes, due to later requoting
-       : ${MYSQL_INCLUDE=`$mysql_config --cflags | tr -d \'`}
+       : ${MYSQL_INCLUDE=`$mysql_config --include | tr -d \'`}
-       : ${MYSQL_LIBS=`$mysql_config --libs |\
+       NCBI_RPATHIFY_OUTPUT_COND(MYSQL_LIBS, $mysql_config --libs${mt_sfx:+_r},
-              sed -e "s/'//g; s/-L\\([[^ ]]*\\)/-L\\1 ${CONF_f_runpath}\\1/"`}
+          [s/'//g; ])
        AC_CACHE_CHECK([whether MySQL works], ncbi_cv_lib_mysql,
           [CPPFLAGS="$MYSQL_INCLUDE $orig_CPPFLAGS"
            LIBS="$MYSQL_LIBS $orig_LIBS"
-Line 2347
+Line 3869
            [[MYSQL *p;  p = mysql_init(p);]])],
            [ncbi_cv_lib_mysql=yes], [ncbi_cv_lib_mysql=no])])
        if test "$ncbi_cv_lib_mysql" = no; then
-          with_mysql=no
+          NCBI_MISSING_PACKAGE(mysql)
        fi
     else
-       with_mysql=no
+       NCBI_MISSING_PACKAGE(mysql)
     fi
  fi
  if test "$with_mysql" = "no" ; then
     MYSQL_PATH="No_MYSQL"
     MYSQL_INCLUDE=
     MYSQL_LIBS=
-    WithoutPackages="$WithoutPackages MySQL"
  else
-    WithPackages="$WithPackages MySQL"
+    NCBI_PACKAGE(MySQL)
     AC_DEFINE(HAVE_MYSQL, 1, [Define to 1 if MySQL is available.])
  fi
-Line 2367
+Line 3888
  ## Berkeley DB library
  if test "$with_bdb" != "no" ; then
     case "$with_bdb" in
-       yes | "" ) : ${BERKELEYDB_PATH:="$NCBI/BerkeleyDB"}     ;;
+       yes | "" )
-       */*      ) BERKELEYDB_PATH=$with_bdb                    ;;
+          : ${BERKELEYDB_PATH:="$NCBI/BerkeleyDB"}
-       *        ) BERKELEYDB_PATH=$NCBI/BerkeleyDB-${with_bdb} ;;
+          ;;
-    esac
+       */*)
-    BERKELEYDB_INCLUDE="-I$BERKELEYDB_PATH/include"
+           BERKELEYDB_PATH=$with_bdb
-    for d in "${release_debug}${bit64_sfx}" "lib${bit64_sfx}" lib; do
+           AS_UNSET(BERKELEYDB_INCLUDE)
-       BERKELEYDB_LIBPATH=${BERKELEYDB_PATH}/$d
+           AS_UNSET(BERKELEYDB_LIBPATH)
-       test -d ${BERKELEYDB_LIBPATH}  &&  break
+           AS_UNSET(BERKELEYDB_LIBS)
+           ;;
+       *)
+           BERKELEYDB_PATH=$NCBI/BerkeleyDB-${with_bdb}
+           AS_UNSET(BERKELEYDB_INCLUDE)
+           AS_UNSET(BERKELEYDB_LIBPATH)
+           AS_UNSET(BERKELEYDB_LIBS)
+           ;;
+    esac
+    if test -d "$BERKELEYDB_PATH"; then
+       NCBI_FIX_DIR(BERKELEYDB_PATH)
+       : ${BERKELEYDB_INCLUDE:="-I$BERKELEYDB_PATH/include"}
+    fi
+    if test -z "${BERKELEYDB_LIBPATH}"; then
+       for d in "${compiler_vpfx}${DEBUG_SFX}" "${compiler_pfx}${DEBUG_SFX}" \
+                "${DEBUG_SFX}" lib; do
+          for sfx in "$mt_sfx$bit64_sfx" "$bit64_sfx$mt_sfx" "$bit64_sfx" \
+                     "$mt_sfx" ""; do
+             BERKELEYDB_LIBPATH=${BERKELEYDB_PATH}/$d$sfx
+             test -d "${BERKELEYDB_LIBPATH}"  &&  break
     done
-    BERKELEYDB_LIBS="-L${BERKELEYDB_LIBPATH} ${CONF_f_runpath}${BERKELEYDB_LIBPATH} -ldb"
+          test -d "${BERKELEYDB_LIBPATH}"  &&  break
+       done
+    fi
+    if test -d "$BERKELEYDB_LIBPATH"; then
+       NCBI_RPATHIFY_COND(BERKELEYDB_LIBS:, ${BERKELEYDB_LIBPATH}, [ -ldb])
+    else
+       : ${BERKELEYDB_LIBS:="-ldb"}
+    fi
     if test -f "${BERKELEYDB_LIBPATH}/libdb-static.a"; then
        BERKELEYDB_STATIC_LIBS="-L${BERKELEYDB_LIBPATH} -ldb-static"
     else
-Line 2391
+Line 3938
            [[ DB* dbp;  db_create(&dbp, NULL, 0);  dbp->app_private = 0; ]])],
            [ncbi_cv_lib_berkeley_db=yes], [ncbi_cv_lib_berkeley_db=no])])
     if test "$ncbi_cv_lib_berkeley_db" = "no"; then
-       with_bdb="no"
+       NCBI_MISSING_PACKAGE(bdb)
     else
-       AC_CACHE_CHECK([Berkeley DB version (4.1 or newer required)],
+       AC_CACHE_CHECK([Berkeley DB version (4.3 or newer required)],
           ncbi_cv_lib_berkeley_db_version,
           [AC_LANG_CONFTEST([AC_LANG_SOURCE([[
  #include <db.h>
-Line 2405
+Line 3952
            rm -f contest*
           ])
        case "$ncbi_cv_lib_berkeley_db_version" in
-.* | 2.* | 3.* | 4.0.* )
+.* | 2.* | 3.* | 4.[[0-2]].* )
              AC_MSG_WARN(
-                [Your Berkeley DB version is too old to use.  (Needed 4.1.)])
+                [Your Berkeley DB version is too old to use.  (Needed >= 4.3.)])
+             if test -n "$with_bdb"; then
+                AC_MSG_ERROR([--with-bdb:  Berkeley DB library is too old])
+             fi
              with_bdb=no
              ;;
-.1.* ) ;;
+.[[3-6]].* ) ;;
           * )
              AC_MSG_WARN(
                 [Untested Berkeley DB version; may prove incompatible.])
-Line 2424
+Line 3974
     BERKELEYDB_PATH="No_BerkeleyDB"
     BERKELEYDB_INCLUDE=
     BERKELEYDB_LIBS=
-    WithoutPackages="$WithoutPackages BerkeleyDB"
+    BERKELEYDB_STATIC_LIBS=
+    BERKELEYDB_CXX_LIBS=
+    BERKELEYDB_CXX_STATIC_LIBS=
  else
-    WithPackages="$WithPackages BerkeleyDB"
+    NCBI_PACKAGE(BerkeleyDB)
     AC_DEFINE(HAVE_BERKELEY_DB, 1,
               [Define to 1 if Berkeley DB libraries are available.])
+    if test -d "$BERKELEYDB_LIBPATH"; then
+       NCBI_RPATHIFY_COND(BERKELEYDB_CXX_LIBS:, ${BERKELEYDB_LIBPATH},
+           [ -ldb_cxx -ldb])
+    else
+       : ${BERKELEYDB_CXX_LIBS:="-ldb_cxx -ldb"}
+    fi
+    if test -f "${BERKELEYDB_LIBPATH}/libdb_cxx-static.a"; then
+       BERKELEYDB_CXX_STATIC_LIBS="-L${BERKELEYDB_LIBPATH} -ldb_cxx-static -ldb-static"
+    else
+       BERKELEYDB_CXX_STATIC_LIBS=${BERKELEYDB_CXX_LIBS}
+    fi
+    AC_CACHE_CHECK([for native Berkeley DB C++ wrappers (optional)],
+       ncbi_cv_lib_berkeley_db_cxx,
+       [CPPFLAGS="$BERKELEYDB_INCLUDE $orig_CPPFLAGS"
+        LIBS="$BERKELEYDB_CXX_LIBS $orig_LIBS"
+        AC_LINK_IFELSE([AC_LANG_PROGRAM(
+           [[#include <db_cxx.h>]],
+           [[DbEnv env(0);  Db db(&env, 0);  db.set_app_private(NULL);]])],
+           [ncbi_cv_lib_berkeley_db_cxx=yes],
+           [ncbi_cv_lib_berkeley_db_cxx=no])])
+    if test "$ncbi_cv_lib_berkeley_db_cxx" = "yes"; then
+       NCBI_PACKAGE(BerkeleyDB++)
+       AC_DEFINE(HAVE_BERKELEY_DB_CXX, 1,
+                 [Define to 1 if the Berkeley `db_cxx' library is available.])
+    else
+       BERKELEYDB_CXX_LIBS=
+       BERKELEYDB_CXX_STATIC_LIBS=
+    fi
  fi
  ## ODBC
- if test "$with_odbc" != "no" ; then
     case "$with_odbc" in
-       yes | "" ) : ${ODBC_PATH:="/opt/machine/merant"} ;;
+    # yes | "" ) : ${ODBC_PATH:="/opt/machine/merant"}       ;;
-       */*      ) ODBC_PATH=$with_odbc                  ;;
+    yes | ""   ) : ${ODBC_PATH:=dbapi/driver/odbc/unix_odbc} ;;
+    internal   ) ODBC_PATH=dbapi/driver/odbc/unix_odbc       ;;
+    *          ) ODBC_PATH=$with_odbc                        ;;
     esac
+ case "$ODBC_PATH" in
+  dbapi/* ) ;;
+  *)
     ODBC_INCLUDE="-I$ODBC_PATH/include"
     ODBC_LIBPATH="${ODBC_PATH}/lib"
-    ODBC_LIBS="-L${ODBC_LIBPATH} ${CONF_f_runpath}${ODBC_LIBPATH} -lodbc -lodbcinst"
+    NCBI_RPATHIFY(ODBC_LIBS, ${ODBC_LIBPATH}, [ -lodbc -lodbcinst])
     CPPFLAGS="$ODBC_INCLUDE $orig_CPPFLAGS"
     LIBS="$ODBC_LIBS $orig_LIBS"
     AC_CACHE_CHECK([for ODBC libraries in $ODBC_PATH], ncbi_cv_lib_odbc,
-Line 2450
+Line 4035
              SQLRETURN x = SQLConnect(hdbc, cp, 1, cp, 2, cp, 3);]])],
            [ncbi_cv_lib_odbc=yes], [ncbi_cv_lib_odbc=no])])
     if test "$ncbi_cv_lib_odbc" = "no"; then
-       with_odbc="no"
+       dnl ODBC_PATH=dbapi/driver/odbc/unix_odbc
+       dnl AC_MSG_WARN([Falling back to internal FreeTDS-specific ODBC implementation.])
+       NCBI_MISSING_PACKAGE(odbc)
     else
        # odbcss.h isn't self-contained :-/
        AC_CHECK_HEADERS(odbcss.h, [], [], [#include <sql.h>])
+       AC_CHECK_FUNCS(SQLGetPrivateProfileString)
+       AC_CHECK_TYPES(SQLLEN,,,[#include <sqltypes.h>])
+       AC_CACHE_CHECK([whether SQLColAttribute's last argument is an SQLLEN *],
+          ncbi_cv_func_sqlcolattribute_sqllen,
+          [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
+             [[#include <sql.h>>
+               SQLRETURN SQL_API SQLColAttribute
+                 (SQLHSTMT sh, SQLUSMALLINT cn, SQLUSMALLINT fi, SQLPOINTER ca,
+                  SQLSMALLINT bl, SQLSMALLINT *sl, SQLLEN *na);]],
+             [[]])],
+             ncbi_cv_func_sqlcolattribute_sqllen=yes,
+             ncbi_cv_func_sqlcolattribute_sqllen=no)])
+       if test $ncbi_cv_func_sqlcolattribute_sqllen = yes; then
+          AC_DEFINE(NCBI_SQLCOLATTRIBUTE_SQLLEN, 1,
+             [Define to 1 if SQLColAttribute's last argument is an SQLLEN *])
     fi
  fi
- if test "$with_odbc" = "no" ; then
+    ;;
-    ODBC_PATH="No_ODBC"
+ esac
-    ODBC_INCLUDE=
+ case "$ODBC_PATH" in
+  dbapi/*)
+    # ODBC_PATH="No_ODBC"
+    # Point to a local copy of unixODBC's headers, required by FreeTDS 0.64+.
+    ODBC_INCLUDE="-I\$(includedir)/$ODBC_PATH -I\$(includedir0)/$ODBC_PATH"
     ODBC_LIBS=
-    WithoutPackages="$WithoutPackages ODBC"
+    dnl AC_DEFINE(HAVE_SQLGETPRIVATEPROFILESTRING, 1)
- else
+    AC_DEFINE(HAVE_SQLLEN, 1)
-    WithPackages="$WithPackages ODBC"
+    ;;
+  *)
+    NCBI_PACKAGE(ODBC)
     AC_DEFINE(HAVE_ODBC, 1, [Define to 1 if ODBC libraries are available.])
+    ;;
+ esac
+ ## Python
+ if test "$with_python" != "no" ; then
+    case "$with_python" in
+       yes | "" ) ;;
+       */*      ) PYTHON_PATH=$with_python ;;
+    esac
+    NCBI_CHECK_PYTHON()
+    NCBI_CHECK_PYTHON(2.3)
+    : ${PYTHON_PATH:="/usr/local/python-2.4.4"}
+    NCBI_CHECK_PYTHON(2.4)
+    NCBI_CHECK_PYTHON(2.5)
+    if test "$ncbi_cv_lib_python" = "no"; then
+       # Favor python 2.4 as the only version configure historically
+       # recognized, but otherwise prefer newer versions.
+       if test "$ncbi_cv_lib_python24" = "yes"; then
+          PYTHON_INCLUDE=$PYTHON24_INCLUDE
+          PYTHON_LIBS=$PYTHON24_LIBS
+       elif test "$ncbi_cv_lib_python25" = "yes"; then
+          PYTHON_INCLUDE=$PYTHON25_INCLUDE
+          PYTHON_LIBS=$PYTHON25_LIBS
+       elif test "$ncbi_cv_lib_python23" = "yes"; then
+          PYTHON_INCLUDE=$PYTHON23_INCLUDE
+          PYTHON_LIBS=$PYTHON23_LIBS
+       fi
+       if test -n "$PYTHON_LIBS"; then
+          NCBI_PACKAGE(PYTHON)
+          AC_DEFINE(HAVE_PYTHON, 1)
+       else
+          NCBI_MISSING_PACKAGE(python)
+       fi
+    fi
+ fi
+ ## CPPUNIT
+ if test "$with_cppunit" != "no" ; then
+    case "$with_cppunit" in
+       yes | "" ) : ${CPPUNIT_PATH=$NCBI/cppunit} ;;
+       *        ) CPPUNIT_PATH=$with_cppunit ;;
+    esac
+    if test -d "$CPPUNIT_PATH/${compiler_vpfx}Debug${bit64_sfx}/lib" \
+         -a -z "$CPPUNIT_ARCH_PATH"; then
+       CPPUNIT_ARCH_PATH="$CPPUNIT_PATH/${compiler_vpfx}Debug${bit64_sfx}"
+    elif test -d "$CPPUNIT_PATH/${compiler_pfx}Debug${bit64_sfx}/lib" \
+         -a -z "$CPPUNIT_ARCH_PATH"; then
+       CPPUNIT_ARCH_PATH="$CPPUNIT_PATH/${compiler_pfx}Debug${bit64_sfx}"
+    else
+       CPPUNIT_ARCH_PATH="$CPPUNIT_PATH"
+    fi
+    CPPUNIT_BINPATH=${CPPUNIT_BINPATH:="$CPPUNIT_ARCH_PATH/bin"}
+    CPPUNIT_LIBPATH=${CPPUNIT_LIBPATH:="$CPPUNIT_ARCH_PATH/lib"}
+    CPPUNIT_INCLUDE=
+    AC_CACHE_CHECK([for CPPUNIT in $CPPUNIT_ARCH_PATH], ncbi_cv_lib_cppunit,
+       [if test -x "$CPPUNIT_BINPATH/cppunit-config" ; then
+           CPPUNIT_INCLUDE=`$CPPUNIT_BINPATH/cppunit-config --cflags`
+           NCBI_RPATHIFY_OUTPUT(CPPUNIT_LIBS,
+                $CPPUNIT_BINPATH/cppunit-config --libs)
+           CPPFLAGS="$CPPUNIT_INCLUDE $orig_CPPFLAGS"
+           LIBS="$CPPUNIT_LIBS $orig_LIBS"
+           AC_LINK_IFELSE([AC_LANG_PROGRAM(
+             [[
+                #include <cppunit/TestResult.h>
+                #include <cppunit/TestResultCollector.h>
+             ]],
+             [[
+                CPPUNIT_NS::TestResult controller;
+                CPPUNIT_NS::TestResultCollector result;
+                controller.addListener( &result );
+             ]])],
+             [ncbi_cv_lib_cppunit=yes], [ncbi_cv_lib_cppunit=no])
+        else
+           ncbi_cv_lib_cppunit=no
+        fi])
+    if test "$ncbi_cv_lib_cppunit" = "no"; then
+       NCBI_MISSING_PACKAGE(cppunit)
+    fi
+ fi
+ if test "$with_cppunit" = "no" ; then
+    CPPUNIT_PATH="No_CPPUNIT"
+    CPPUNIT_INCLUDE=
+    CPPUNIT_LIBS=
+ else
+    NCBI_PACKAGE(CPPUNIT)
+    CPPUNIT_CONFIG="$CPPUNIT_BINPATH/cppunit-config"
+    # The "yes" may have been cached; get the actual settings again if needed
+    if test -z "$CPPUNIT_INCLUDE"; then
+       CPPUNIT_INCLUDE=`$CPPUNIT_CONFIG --cflags`
+       NCBI_RPATHIFY_OUTPUT(CPPUNIT_LIBS, $CPPUNIT_CONFIG --libs)
+    fi
+    AC_DEFINE(HAVE_CPPUNIT, 1, [Define to 1 if CPPUNIT libraries are available.])
+ fi
+ ## Boost
+ if test "$with_boost" != "no"; then
+    if test "${with_boost-yes}" = yes; then
+       : ${BOOST_PATH=$NCBI/boost}
+    else
+       BOOST_PATH=$with_boost
+    fi
+    if test -d "$BOOST_PATH"; then
+       NCBI_FIX_DIR(BOOST_PATH)
+    fi
+    : ${BOOST_INCLUDE=-I$BOOST_PATH/include}
+    BOOST_LIBPATH_=$BOOST_PATH/lib
+    NCBI_RPATHIFY_COND(BOOST_LIBPATH, $BOOST_LIBPATH_)
+    test -n "$BOOST_PATH"  ||  BOOST_LIBPATH_=/usr/lib
+    boost_path_digits=`basename $BOOST_PATH | sed -e 's/.0$//' | tr -cd 0123456789`
+    if test -n "$boost_path_digits"; then
+       boost_version_digits=`echo $ncbi_cv_lib_boost_version | sed -e 's/.0$//' | tr -cd 0123456789`
+       if test $boost_path_digits != "$boost_version_digits"; then
+          # presumably stale, particularly if boost_version WASN'T cached;
+          # uncache all relevant settings
+          AS_UNSET(ncbi_cv_lib_boost_version)
+          AS_UNSET(ncbi_cv_lib_boost_regex)
+          AS_UNSET(ncbi_cv_lib_boost_spirit)
+          AS_UNSET(ncbi_cv_lib_boost_test)
+          AS_UNSET(ncbi_cv_lib_boost_thread)
+       fi
+    fi
+       AC_CACHE_CHECK([Boost version],
+          ncbi_cv_lib_boost_version,
+          [AC_LANG_CONFTEST([AC_LANG_SOURCE([[
+ #include <boost/version.hpp>
+ ncbi_cv_lib_boost_version=BOOST_LIB_VERSION
+           ]])])
+           eval "$ac_cpp $BOOST_INCLUDE conftest.$ac_ext" \
+>&AS_MESSAGE_LOG_FD | grep '^ncbi_cv_' | tr -d '  ' > conftest.sh
+           . ./conftest.sh
+           rm -f contest*
+          ])
+    if test -d `echo $BOOST_INCLUDE | sed -e 's/^-I//'`/boost-${ncbi_cv_lib_boost_version}/boost; then
+       BOOST_INCLUDE=$BOOST_INCLUDE/boost-${ncbi_cv_lib_boost_version}
+    fi
+    case "$ncbi_compiler" in
+       MIPSPRO)
+          BOOST_INCLUDE="$BOOST_INCLUDE $BOOST_INCLUDE/boost/compatibility/cpp_c_headers"
+          ;;
+       WORKSHOP)
+          # Boost.Test's macros yield a *lot* of spurious "should not initialize
+          # a non-const reference with a temporary" warnings, to the point of
+          # overwhelming the compiler in some cases; turn them off altogether
+          # when using Boost at all.
+          BOOST_INCLUDE="$BOOST_INCLUDE -erroff=reftotemp"
+          ;;
+    esac
+    case "$ncbi_cv_lib_boost_version" in
+_* | 1_[[0-9]] | 1_[[0-9]]_* | 1_[[0-2]][[0-9]] | 1_[[0-2]][[0-9]]_* ) ;;
+_3[[0-3]] | 1_3[[0-4]]_* )
+          AC_MSG_WARN(
+             [Your Boost version is too old to use.  (Needed >= 1.35.)])
+          if test -n "$with_boost"; then
+             AC_MSG_ERROR([--with-boost:  Boost library is too old])
+          fi
+          with_boost=no
+          ;;
+_35 | 1_35_* ) ;;
+       * )
+          AC_MSG_WARN(
+             [Untested Boost version; may prove incompatible.])
+          AC_MSG_WARN(
+             [If so, please re-run this script with the flag --without-boost.])
+          ;;
+    esac
+    AC_MSG_CHECKING([for Boost library name tag])
+    boost_compiler_version=`echo $compiler_version | cut -c1-2`
+    case "$with_boost_tag" in
+       yes | "" )
+          case "$host_os:$ncbi_compiler" in
+             darwin*:GCC) BOOST_TAG=""     ;;
+             *:GCC)       BOOST_TAG="-gcc$boost_compiler_version" ;;
+             *:KCC)       BOOST_TAG="-kcc" ;;
+             linux*:ICC)  BOOST_TAG="-il$boost_compiler_version" ;;
+             *:WORKSHOP)  BOOST_TAG="-sw"  ;;
+             *:MIPSPRO)   BOOST_TAG="-mp"  ;;
+             *:VISUALAGE) BOOST_TAG="-xlc" ;;
+             *:COMPAQ)    BOOST_TAG="-tru" ;;
+             *:MSVC)      BOOST_TAG="-vc"  ;;
+          esac
+          test "$with_mt"    = "yes"  &&  BOOST_MT=-mt
+          test "$with_debug" = "yes"  &&  BOOST_D=-d
+          test "$bit64_sfx"  = "64"   &&  BOOST_64=-64
+          found=no
+          for bvers in "-$ncbi_cv_lib_boost_version" ''; do
+             for b64 in $BOOST_64 ''; do
+                for bmt in "$BOOST_MT" '-mt' ''; do
+                   for bd in "$BOOST_D" '' '-d'; do
+                      bsfx=$bmt$bd$bvers$b64
+                      if ls $BOOST_LIBPATH_/libboost*$BOOST_TAG$bsfx.* \
+                          >/dev/null 2>&1;
+                      then
+                         found=yes
+                         break
+                      fi
+                   done
+                   test "$found" = yes  &&  break
+                done
+                test "$found" = yes  &&  break
+             done
+             test "$found" = yes  &&  break
+          done
+          BOOST_TAG=$BOOST_TAG$bsfx
+          AC_MSG_RESULT([$BOOST_TAG (autodetected)])
+          ;;
+       no )
+          BOOST_TAG=""
+          AC_MSG_RESULT([none (by explicit request)])
+          ;;
+       *)
+          BOOST_TAG=$with_boost_tag
+          AC_MSG_RESULT([$BOOST_TAG (by explicit request)])
+          ;;
+    esac
+    case "$BOOST_TAG" in
+       *-mt*) ;;
+       *) BOOST_INCLUDE="$BOOST_INCLUDE -DBOOST_DISABLE_THREADS" ;;
+    esac
+    BOOST_REGEX_LIBS=-lboost_regex${BOOST_TAG}
+    if test -f "$BOOST_LIBPATH_/libboost_regex${BOOST_TAG}-static.a"; then
+        BOOST_REGEX_STATIC_LIBS=-lboost_regex${BOOST_TAG}-static
+    else
+        BOOST_REGEX_STATIC_LIBS=$BOOST_REGEX_LIBS
+    fi
+    AC_CACHE_CHECK([for Boost.Regex in $BOOST_PATH], ncbi_cv_lib_boost_regex,
+       CPPFLAGS="$BOOST_INCLUDE $orig_CPPFLAGS"
+       LIBS="$BOOST_LIBPATH $BOOST_REGEX_LIBS $RT_LIBS $orig_LIBS"
+       [AC_LINK_IFELSE(
+           [AC_LANG_PROGRAM([[#include <boost/regex.hpp>]],
+               [[throw boost::regex_error(boost::regex_constants::error_stack);]])],
+           [ncbi_cv_lib_boost_regex=yes], [ncbi_cv_lib_boost_regex=no])])
+    AC_CACHE_CHECK([for Boost.Spirit in $BOOST_PATH], ncbi_cv_lib_boost_spirit,
+       CPPFLAGS="$BOOST_INCLUDE $orig_CPPFLAGS"
+       LIBS="$RT_LIBS $orig_LIBS"
+       [AC_LINK_IFELSE(
+           [AC_LANG_PROGRAM([[#include <boost/spirit.hpp>]],
+               [[boost::spirit::parse("123", boost::spirit::int_p);]])],
+           [ncbi_cv_lib_boost_spirit=yes], [ncbi_cv_lib_boost_spirit=no])])
+    BOOST_TEST_PEM_LIBS=-lboost_prg_exec_monitor${BOOST_TAG}
+    if test -f "$BOOST_LIBPATH_/libboost_prg_exec_monitor${BOOST_TAG}-static.a"; then
+        BOOST_TEST_PEM_STATIC_LIBS=-lboost_prg_exec_monitor${BOOST_TAG}-static
+    else
+        BOOST_TEST_PEM_STATIC_LIBS=$BOOST_TEST_PEM_LIBS
+    fi
+    BOOST_TEST_TEM_LIBS=-lboost_test_exec_monitor${BOOST_TAG}
+    if test -f "$BOOST_LIBPATH_/libboost_test_exec_monitor${BOOST_TAG}-static.a"; then
+        BOOST_TEST_TEM_STATIC_LIBS=-lboost_test_exec_monitor${BOOST_TAG}-static
+    else
+        BOOST_TEST_TEM_STATIC_LIBS=$BOOST_TEST_TEM_LIBS
+    fi
+    BOOST_TEST_UTF_LIBS=-lboost_unit_test_framework${BOOST_TAG}
+    if test -f "$BOOST_LIBPATH_/libboost_unit_test_framework${BOOST_TAG}-static.a"; then
+        BOOST_TEST_UTF_STATIC_LIBS=-lboost_unit_test_framework${BOOST_TAG}-static
+    else
+        BOOST_TEST_UTF_STATIC_LIBS=$BOOST_TEST_UTF_LIBS
+    dnl AC_DEFINE([NCBI_BOOST_TEST_DLL], 1,
+    dnl   [Define to 1 if unable to locate an appropriate
+    dnl    libboost_unit_test_framework${BOOST_TAG}-static.a.])
+    fi
+    BOOST_TEST_PEM_LIBS=$BOOST_TEST_PEM_STATIC_LIBS
+    BOOST_TEST_TEM_LIBS=$BOOST_TEST_TEM_STATIC_LIBS
+    BOOST_TEST_UTF_LIBS=$BOOST_TEST_UTF_STATIC_LIBS
+    AC_CACHE_CHECK([for Boost.Test in $BOOST_PATH], ncbi_cv_lib_boost_test,
+       CPPFLAGS="$BOOST_INCLUDE $orig_CPPFLAGS"
+       LIBS="$RT_LIBS $orig_LIBS"
+       found=
+       for mode in included external; do
+         if test "$mode" = external; then
+           CPPFLAGS="-DNCBI_BOOST_NOT_INCLUDED $CPPFLAGS"
+           LIBS="$BOOST_LIBPATH $BOOST_TEST_UTF_LIBS $LIBS"
  fi
+         [AC_LINK_IFELSE(
+            [AC_LANG_SOURCE(
+               [[#ifdef NCBI_BOOST_NOT_INCLUDED
+                 #  include <boost/test/unit_test.hpp>
+                 #else
+                 #  include <boost/test/included/unit_test.hpp>
+                 #endif
+                 using boost::unit_test::test_suite;
+                 static void s_Test1(void) { BOOST_CHECK(1 == 1); }
+                 test_suite* init_unit_test_suite(int, char*[])
+                 {
+                     test_suite* test = BOOST_TEST_SUITE("foo");
+                     test->add(BOOST_TEST_CASE(&s_Test1), 0);
+                     return test;
+                 }]])],
+            [found="$found:$mode"])]
+       done
+       [case "$found" in
+         :included:external ) ncbi_cv_lib_boost_test=yes           ;;
+         :included          ) ncbi_cv_lib_boost_test=included-only ;;
+         :external          ) ncbi_cv_lib_boost_test=external-only ;;
+         ''                 ) ncbi_cv_lib_boost_test=no            ;;
+       esac])
+    BOOST_THREAD_LIBS=-lboost_thread${BOOST_TAG}
+    if test -f "$BOOST_LIBPATH_/libboost_thread${BOOST_TAG}-static.a"; then
+        BOOST_THREAD_STATIC_LIBS=-lboost_thread${BOOST_TAG}-static
+    else
+        BOOST_THREAD_STATIC_LIBS=$BOOST_THREAD_LIBS
+    fi
+    AC_CACHE_CHECK([for Boost.Threads in $BOOST_PATH], ncbi_cv_lib_boost_thread,
+       CPPFLAGS="$BOOST_INCLUDE $orig_CPPFLAGS"
+       LIBS="$BOOST_LIBPATH $BOOST_THREAD_LIBS $RT_LIBS $orig_LIBS"
+       [AC_LINK_IFELSE(
+           [AC_LANG_PROGRAM([[#include <boost/thread.hpp>]],
+               [[boost::mutex m; boost::mutex::scoped_lock l(m);]])],
+           [ncbi_cv_lib_boost_thread=yes], [ncbi_cv_lib_boost_thread=no])])
+ else
+    BOOST_INCLUDE=
+    BOOST_LIBPATH=
+    BOOST_TAG=
+    ncbi_cv_lib_boost_regex=no
+    ncbi_cv_lib_boost_test=no
+    ncbi_cv_lib_boost_thread=no
+ fi
+ if test "$ncbi_cv_lib_boost_regex" != "no"; then
+    AC_DEFINE(HAVE_BOOST_REGEX, 1,
+              [Define to 1 if the `Boost.Regex' library is available.])
+    NCBI_PACKAGE(Boost.Regex)
+ else
+    BOOST_REGEX_LIBS=
+    BOOST_REGEX_STATIC_LIBS=
+ fi
+ if test "$ncbi_cv_lib_boost_spirit" != "no"; then
+    AC_DEFINE(HAVE_BOOST_SPIRIT, 1,
+              [Define to 1 if the `Boost.Spirit' headers are available.])
+    NCBI_PACKAGE(Boost.Spirit)
+ fi
+ if test "$ncbi_cv_lib_boost_test" != "no"; then
+    AC_DEFINE(HAVE_BOOST_TEST, 1,
+              [Define to 1 if the `Boost.Test' libraries are available.])
+    if test "$ncbi_cv_lib_boost_test" != "included-only"; then
+       NCBI_PACKAGE(Boost.Test)
+    fi
+    if test "$ncbi_cv_lib_boost_test" != "external-only"; then
+       NCBI_PACKAGE(Boost.Test.Included)
+    fi
+ else
+    BOOST_TEST_PEM_LIBS=
+    BOOST_TEST_PEM_STATIC_LIBS=
+    BOOST_TEST_TEM_LIBS=
+    BOOST_TEST_TEM_STATIC_LIBS=
+    BOOST_TEST_UTF_LIBS=
+    BOOST_TEST_UTF_STATIC_LIBS=
+ fi
+ if test "$ncbi_cv_lib_boost_thread" != "no"; then
+    AC_DEFINE(HAVE_BOOST_THREAD, 1,
+              [Define to 1 if the `Boost.Threads' library is available.])
+    NCBI_PACKAGE(Boost.Threads)
+ else
+    BOOST_THREAD_LIBS=
+    BOOST_THREAD_STATIC_LIBS=
+ fi
+ case "$with_boost:$ncbi_cv_lib_boost_test" in
+    :* | no:* | *:yes | *:included-only ) ;; # no problem
+    * ) AC_MSG_ERROR([Boost explicitly requested, but Boost.Test.Included unavailable.]) ;;
+ esac
  ## NCBI C Toolkit
  if test "$with_ncbi_c" != "no" ; then
     NCBI_C_PATH=${NCBI_C_PATH:="$NCBI"}
+    if test "$ncbi_compiler" = ICC -a -d "$NCBI_C_PATH/ncbi_icc"; then
+       NCBI_C_PATH=$NCBI_C_PATH/ncbi_icc
+    fi
     NCBI_C_INCLUDE="-I$NCBI_C_PATH/include${bit64_sfx}"
     if test "$with_debug" = "no" ; then
       NCBI_C_LIBPATH="$NCBI_C_PATH/lib${bit64_sfx}"
-Line 2495
+Line 4486
            [[ Nlm_Boolean b = Nlm_GetArgs("fake", -1, 0); ]])],
            [ncbi_cv_lib_ctools=yes], [ncbi_cv_lib_ctools=no])])
     if test "$ncbi_cv_lib_ctools" = no; then
-       with_ncbi_c=no
+       NCBI_MISSING_PACKAGE(ncbi-c)
     fi
  fi
  if test "$with_ncbi_c" = "no" ; then
+    if test "$with_ctools" = "yes"; then
+       AC_MSG_ERROR([--with-ctools:  NCBI C Toolkit is missing])
+    fi
     NCBI_C_PATH="No_NCBI_CToolkit"
     NCBI_C_INCLUDE=
     NCBI_C_LIBPATH=
     NCBI_C_ncbi=
-    WithoutPackages="$WithoutPackages C-Toolkit"
  else
-    WithPackages="$WithPackages C-Toolkit"
+    NCBI_PACKAGE(C-Toolkit)
     AC_DEFINE(HAVE_NCBI_C, 1, [Define to 1 if the NCBI C toolkit is available.])
  fi
  ## OpenGL
  if test "$with_opengl" != "no"; then
+    if test "${with_opengl-yes}" = yes; then
+       if test -d $NCBI/MesaGL; then
+          : ${OPENGL_PATH=$NCBI/MesaGL}
+       fi
+    else
+       OPENGL_PATH=$with_opengl
+    fi
+    if test -d "$OPENGL_PATH"; then
+       NCBI_FIX_DIR(OPENGL_PATH)
+    fi
     case "$OSTYPE" in
        darwin) # Use native interface
           OPENGL_LIBS="-framework Carbon -framework AGL -framework OpenGL"
-Line 2520
+Line 4523
        *) # Default -- assume X-based
           LIBS="$orig_LIBS"
           CPPFLAGS="$orig_CPPFLAGS"
+          # Look in /usr/X11R6/lib64 if necessary
+          xlib=`ls -d /usr/X11R6/lib$bit64_sfx/libX11.* 2>/dev/null | sed -ne 1p`
+          if test -f "$xlib" -a "${x_libraries-NONE}" = NONE \
+            -a "${x_includes-NONE}" = NONE; then
+             base=`basename $xlib`
+             cmp -s /usr/X11R6/lib/$base $xlib  || \
+                cmp -s /usr/lib/$base $xlib  || \
+                cmp -s /usr/lib$bit64_sfx/$base $xlib  || \
+                x_libraries=/usr/X11R6/lib$bit64_sfx x_includes=/usr/X11R6/include
+          fi
           AC_PATH_XTRA
           LDFLAGS="$orig_LDFLAGS $X_LIBS"
           AC_CHECK_LIB(Xext, XextCreateExtension, Xext="-lXext", Xext=,
-Line 2528
+Line 4541
              [$Xext $X_PRE_LIBS -lX11 $X_EXTRA_LIBS])
           AC_CHECK_LIB(Xmu, XmuMakeAtom, Xmu="-lXmu", Xmu=,
              [$Xt $Xext $X_PRE_LIBS -lX11 $X_EXTRA_LIBS])
+          LDFLAGS=$orig_LDFLAGS
           X_ALL_LIBS="$Xmu $Xt $Xext $X_PRE_LIBS -lX11 $X_EXTRA_LIBS"
-          ogl_lib_sfx=
+          if test -d "$OPENGL_PATH/include/GL"; then
-          case "${with_opengl:=yes}" in
+             OPENGL_INCLUDE="-I$OPENGL_PATH/include $X_CFLAGS"
-             yes)
+          else
-                # Check for NCBI's oddly located in-house installations.
+             OPENGL_INCLUDE=$X_CFLAGS
-                case "$OSTYPE:$host_cpu:$bit64_sfx" in
-                   solaris:sparc:64)
-                      with_opengl=/usr/ncbi/lib/OpenGL64/openwin
-                      ogl_lib_sfx=/sparcv9
-                      ;;
-                   solaris:i386:) with_opengl=/usr/ncbi ;;
-                esac
-                ;;
-          esac
-          if test -d "$with_opengl/include/GL"; then
-             X_CFLAGS="-I$with_opengl/include $X_CFLAGS"
           fi
-          if test -d "$with_opengl/lib$ogl_lib_sfx"; then
+          if test -d "$OPENGL_PATH/lib${bit64_sfx}"; then
-             l=$with_opengl/lib$ogl_lib_sfx
+             NCBI_RPATHIFY(OPENGL_LIBPATH, $OPENGL_PATH/lib${bit64_sfx},
-             X_LIBS="-L$l ${CONF_f_runpath}$l $X_LIBS"
+                           [ ]$X_LIBS)
           fi
-          LDFLAGS="$orig_LDFLAGS $X_LIBS"
+          OPENGL_LIBS="$OPENGL_LIBPATH -lGLU -lGL $X_ALL_LIBS"
-          OPENGL_INCLUDE="$X_CFLAGS"
-          OPENGL_LIBS="$X_LIBS -lGLU -lGL $X_ALL_LIBS"
           ;;
     esac
-    case "${with_opengl}" in
+    case "${OPENGL_PATH}" in
-       */*) where=" in $with_opengl" ;;
+       */*) where=" in $OPENGL_PATH" ;;
        *  ) where= ;;
     esac
     AC_CACHE_CHECK([for OpenGL$where], ncbi_cv_lib_opengl,
-Line 2576
+Line 4577
  if test "$with_opengl" = "no" -o "$ncbi_cv_lib_opengl" = "no"; then
     OPENGL_INCLUDE=
     OPENGL_LIBS=
+    OPENGL_STATIC_LIBS=
     OSMESA_INCLUDE=
     OSMESA_LIBS=
+    OSMESA_STATIC_LIBS=
     GLUT_INCLUDE=
     GLUT_LIBS=
-    with_opengl="no"
+    NCBI_MISSING_PACKAGE(opengl)
-    WithoutPackages="$WithoutPackages OpenGL MESA"
  else
-    WithPackages="$WithPackages OpenGL"
+    NCBI_PACKAGE(OpenGL)
     AC_DEFINE(HAVE_OPENGL, 1, [Define to 1 if you have OpenGL (-lGL).])
-    : ${OSMESA_PATH=$NCBI/MesaGL}
+    if test -f "$OPENGL_PATH/lib${bit64_sfx}/libGLU-static.a"; then
-    orig_LDFLAGS_X=$LDFLAGS
+       OPENGL_STATIC_LIBS="$OPENGL_LIBPATH -lGLU-static -lGL-static $X_ALL_LIBS"
+    else
+       OPENGL_STATIC_LIBS=$OPENGL_LIBS
+    fi
+    : ${OSMESA_PATH=$OPENGL_PATH}
     if test "$with_mesa" != "no"; then
-       if test "${with_mesa-yes}" = "yes" -a -d "$OSMESA_PATH"; then
+       if test "${with_mesa-yes}" != "yes"; then
-          with_mesa=$OSMESA_PATH
+          OSMESA_PATH=$with_mesa
+       fi
+       if test -d "$OSMESA_PATH"; then
+          OSMESA_INCLUDE=-I$OSMESA_PATH/include
+          if test "$OSMESA_PATH" != "$OPENGL_PATH"; then
+             NCBI_RPATHIFY(OSMESA_LDFLAGS, $OSMESA_PATH/lib${bit64_sfx})
        fi
-       if test -n "$with_mesa" -a "$with_mesa" != "yes"; then
-          OSMESA_INCLUDE=-I$with_mesa/include
-          OSMESA_LDFLAGS="-L$with_mesa/lib ${CONF_f_runpath}$with_mesa/lib"
        fi
-       LDFLAGS="$orig_LDFLAGS_X $OSMESA_LDFLAGS"
+       LDFLAGS="$orig_LDFLAGS $OSMESA_LDFLAGS $OPENGL_LIBPATH"
        AC_CHECK_LIB(OSMesa, OSMesaCreateContext,
-          [WithPackages="$WithPackages MESA";
+          [NCBI_PACKAGE(MESA);
-           OSMESA_LIBS="$OSMESA_LDFLAGS $X_LIBS -lOSMesa -lGLU -lGL $X_ALL_LIBS"
+           OSMESA_LIBS="$OSMESA_LDFLAGS $OPENGL_LIBPATH -lOSMesa -lGLU -lGL $X_ALL_LIBS"
            AC_DEFINE(HAVE_LIBOSMESA, 1, [Define to 1 if you have libOSMesa.])],
-          [WithoutPackages="$WithoutPackages MESA"; OSMESA_LIBS=],
+          [OSMESA_LIBS=],
           $OPENGL_LIBS)
     fi
+    if test -z "$OSMESA_LIBS"; then
+       NCBI_MISSING_PACKAGE(mesa)
+    elif test -f "$OSMESA_PATH/lib${bit64_sfx}/libOSMesa-static.a"; then
+       OSMESA_STATIC_LIBS="$OSMESA_LDFLAGS $OPENGL_LIBPATH -lOSMesa-static -lGLU-static -lGL-static $X_ALL_LIBS"
+    else
+       OSMESA_STATIC_LIBS=$OSMESA_LIBS
+    fi
     : ${GLUT_PATH=$NCBI/glut}
     if test "$with_glut" != "no"; then
-       if test "${with_glut-yes}" = "yes" -a -d "$GLUT_PATH"; then
+       if test "${with_glut-yes}" != "yes"; then
-          with_glut=$GLUT_PATH
+          GLUT_PATH=$with_glut
        fi
-       if test -n "$with_glut" -a "$with_glut" != "yes"; then
+       if test -d "GLUT_PATH"; then
-          GLUT_INCLUDE=-I$with_glut/include
+          GLUT_INCLUDE=-I$GLUT_PATH/include
-          GLUT_LDFLAGS="-L$with_glut/lib ${CONF_f_runpath}$with_glut/lib"
+          NCBI_RPATHIFY(GLUT_LDFLAGS, $GLUT_PATH/lib${bit64_sfx})
        fi
-       LDFLAGS="$orig_LDFLAGS_X $GLUT_LDFLAGS"
+       LDFLAGS="$orig_LDFLAGS $GLUT_LDFLAGS $OPENGL_LIBPATH"
        AC_CHECK_LIB(glut, glutInit,
-          [WithPackages="$WithPackages GLUT";
+          [NCBI_PACKAGE(GLUT);
-           GLUT_LIBS="$GLUT_LDFLAGS $X_LIBS -lglut -lGLU -lGL $X_ALL_LIBS"
+           GLUT_LIBS="$GLUT_LDFLAGS $OPENGL_LIBPATH -lglut -lGLU -lGL $X_ALL_LIBS"
            AC_DEFINE(HAVE_LIBGLUT, 1, [Define to 1 if you have libglut.])],
-          [WithoutPackages="$WithoutPackages GLUT"; GLUT_LIBS=],
+          [GLUT_LIBS=],
           $OPENGL_LIBS)
+       if test -z "$GLUT_LIBS"; then
+          NCBI_MISSING_PACKAGE(glut)
+       fi
     fi
  fi
-Line 2627
+Line 4645
  ## FLTK
  if test "$with_fltk" != "no"; then
-    if test -z "$FLTK_PATH"; then
+    case "$with_fltk" in
-       if test -d "$with_fltk"; then
+       yes | "" ) : ${FLTK_PATH=$NCBI/fltk} ;;
-          FLTK_PATH=$with_fltk
+       *        ) FLTK_PATH=$with_fltk ;;
-       else
+    esac
-          FLTK_PATH="$NCBI/fltk"
+    if test -d "$FLTK_PATH/${compiler_vpfx}${DEBUG_SFX}${mt_sfx}${bit64_sfx}/lib" \
-       fi
-    fi
-    if test -d "$FLTK_PATH/${compiler_vpfx}${release_debug}${mt_sfx}${bit64_sfx}/lib" \
          -a -z "$FLTK_ARCH_PATH"; then
-       FLTK_ARCH_PATH="$FLTK_PATH/${compiler_vpfx}${release_debug}${mt_sfx}${bit64_sfx}"
+       FLTK_ARCH_PATH="$FLTK_PATH/${compiler_vpfx}${DEBUG_SFX}${mt_sfx}${bit64_sfx}"
-    elif test -d "$FLTK_PATH/${compiler_pfx}${release_debug}${mt_sfx}${bit64_sfx}/lib" \
+    elif test -d "$FLTK_PATH/${compiler_pfx}${DEBUG_SFX}${mt_sfx}${bit64_sfx}/lib" \
          -a -z "$FLTK_ARCH_PATH"; then
-       FLTK_ARCH_PATH="$FLTK_PATH/${compiler_pfx}${release_debug}${mt_sfx}${bit64_sfx}"
+       FLTK_ARCH_PATH="$FLTK_PATH/${compiler_pfx}${DEBUG_SFX}${mt_sfx}${bit64_sfx}"
     else
        FLTK_ARCH_PATH="$FLTK_PATH"
     fi
     FLTK_BINPATH=${FLTK_BINPATH:="$FLTK_ARCH_PATH/bin"}
     FLTK_LIBPATH=${FLTK_LIBPATH:="$FLTK_ARCH_PATH/lib"}
     FLTK_INCLUDE=
+    case "$host_os:$compiler" in
+       solaris2.10:GCC ) extrased='s/-lpthread//g; ' ;;
+       *               ) extrased= ;;
+    esac
     AC_CACHE_CHECK([for FLTK in $FLTK_ARCH_PATH], ncbi_cv_lib_fltk,
        [if test -x "$FLTK_BINPATH/fltk-config" ; then
            FLTK_INCLUDE=`$FLTK_BINPATH/fltk-config --cxxflags --use-gl`
-           FLTK_LIBS=`$FLTK_BINPATH/fltk-config --ldflags`
+           NCBI_RPATHIFY_OUTPUT(FLTK_LIBS, $FLTK_BINPATH/fltk-config --ldflags,
+              $extrased)
            CPPFLAGS="$FLTK_INCLUDE $orig_CPPFLAGS"
            LIBS="$FLTK_LIBS $orig_LIBS"
-Line 2661
+Line 4681
            ncbi_cv_lib_fltk=no
         fi])
     if test "$ncbi_cv_lib_fltk" = "no"; then
-       with_fltk="no"
+       NCBI_MISSING_PACKAGE(fltk)
     fi
  fi
-Line 2670
+Line 4690
     FLTK_INCLUDE=
     FLTK_LIBS=
     FLTK_LIBS_GL=
-    WithoutPackages="$WithoutPackages FLTK"
  else
-    WithPackages="$WithPackages FLTK"
+    NCBI_PACKAGE(FLTK)
+    FLTK_CONFIG="$FLTK_BINPATH/fltk-config"
     # The "yes" may have been cached; get the actual settings again if needed
     if test -z "$FLTK_INCLUDE"; then
-       FLTK_INCLUDE=`$FLTK_BINPATH/fltk-config --cxxflags --use-gl`
+       FLTK_INCLUDE=`$FLTK_CONFIG --cxxflags --use-gl`
-       FLTK_LIBS=`$FLTK_BINPATH/fltk-config --ldflags`
+       NCBI_RPATHIFY_OUTPUT(FLTK_LIBS, $FLTK_BINPATH/fltk-config --ldflags,
-    fi
+          $extrased)
-    FLTK_LIBS_GL=`$FLTK_BINPATH/fltk-config --ldflags --use-gl`
+    fi
-    FLTK_CONFIG="$FLTK_BINPATH/fltk-config"
+    NCBI_RPATHIFY_OUTPUT(FLTK_LIBS_GL,
+       $FLTK_BINPATH/fltk-config --ldflags --use-gl, $extrased)
+    NCBI_RPATHIFY_OUTPUT(FLTK_LIBS_IMAGES,
+       $FLTK_BINPATH/fltk-config --ldflags --use-images, $extrased)
+    NCBI_RPATHIFY_OUTPUT(FLTK_LIBS_ALL,
+       $FLTK_BINPATH/fltk-config --ldflags --use-gl --use-images, $extrased)
+    # Also supply static versions for use in CGIs to be deployed to servers
+    # without access to the shared libraries.
+    NCBI_RPATHIFY_OUTPUT(FLTK_STATIC_LIBS,
+       $FLTK_BINPATH/fltk-config --ldstaticflags, $extrased)
+    NCBI_RPATHIFY_OUTPUT(FLTK_STATIC_LIBS_GL,
+       $FLTK_BINPATH/fltk-config --ldstaticflags --use-gl, $extrased)
+    NCBI_RPATHIFY_OUTPUT(FLTK_STATIC_LIBS_IMAGES,
+       $FLTK_BINPATH/fltk-config --ldstaticflags --use-images, $extrased)
+    NCBI_RPATHIFY_OUTPUT(FLTK_STATIC_LIBS_ALL,
+       $FLTK_BINPATH/fltk-config --ldstaticflags --use-gl --use-images,
+       $extrased)
     AC_DEFINE(HAVE_FLTK, 1, [Define to 1 if FLTK is available.])
  fi
  ## wxWindows
  if test "$with_wxwin" != "no" ; then
-    if test -z "$WXWIN_PATH"; then
+    case "$with_wxwin" in
-       if test -d "$with_wxwin"; then
+       yes | "" ) : ${WXWIN_PATH=$NCBI/wxwin} ;;
-          WXWIN_PATH=$with_wxwin
+       *        ) WXWIN_PATH=$with_wxwin ;;
-       else
+    esac
-          WXWIN_PATH="$NCBI/wxwin"
+    if test -d "$WXWIN_PATH/${compiler_vpfx}${DEBUG_SFX}${mt_sfx}${bit64_sfx}/lib" \
-       fi
-    fi
-    if test -d "$WXWIN_PATH/${compiler_vpfx}${release_debug}${mt_sfx}${bit64_sfx}/lib" \
          -a -z "$WXWIN_ARCH_PATH"; then
-       WXWIN_ARCH_PATH="$WXWIN_PATH/${compiler_vpfx}${release_debug}${mt_sfx}${bit64_sfx}"
+       WXWIN_ARCH_PATH="$WXWIN_PATH/${compiler_vpfx}${DEBUG_SFX}${mt_sfx}${bit64_sfx}"
-    elif test -d "$WXWIN_PATH/${compiler_pfx}${release_debug}${mt_sfx}${bit64_sfx}/lib" \
+    elif test -d "$WXWIN_PATH/${compiler_pfx}${DEBUG_SFX}${mt_sfx}${bit64_sfx}/lib" \
          -a -z "$WXWIN_ARCH_PATH"; then
-       WXWIN_ARCH_PATH="$WXWIN_PATH/${compiler_pfx}${release_debug}${mt_sfx}${bit64_sfx}"
+       WXWIN_ARCH_PATH="$WXWIN_PATH/${compiler_pfx}${DEBUG_SFX}${mt_sfx}${bit64_sfx}"
     else
        WXWIN_ARCH_PATH="$WXWIN_PATH"
     fi
-Line 2714
+Line 4747
        # May work without gtk-config (e.g., on Mac OS X)
        gtkconf=:
     fi
+    case "$host_os" in
+       darwin* ) baseflags=""                  ;;
+       *       ) baseflags=`$gtkconf --cflags` ;;
+    esac
     AC_CACHE_CHECK([for wxWindows in $WXWIN_ARCH_PATH], ncbi_cv_lib_wxwindows,
        [if test -x "$wxconf" ; then
-           WXWIN_INCLUDE="`$gtkconf --cflags` `$wxconf --cflags`"
+           WXWIN_INCLUDE="$baseflags `$wxconf --cflags`"
            WXWIN_LIBS=`$wxconf --libs`
            CPPFLAGS="$WXWIN_INCLUDE $orig_CPPFLAGS"
-Line 2729
+Line 4766
            ncbi_cv_lib_wxwindows=no
         fi])
     if test "$ncbi_cv_lib_wxwindows" = "no"; then
-       with_wxwin="no"
+       NCBI_MISSING_PACKAGE(wxwin)
     fi
  fi
-Line 2737
+Line 4774
     WXWIN_LIBPATH="No_wxWindows"
     WXWIN_INCLUDE=
     WXWIN_LIBS=
+    WXWIN_STATIC_LIBS=
     WXWIN_GL_LIBS=
-    WithoutPackages="$WithoutPackages wxWindows"
+    WXWIN_GL_STATIC_LIBS=
+    WXWIN_POST_LINK=:
  else
-    WithPackages="$WithPackages wxWindows"
+    NCBI_PACKAGE(wxWindows)
     # The "yes" may have been cached; get the actual settings again if needed
     if test -z "$WXWIN_INCLUDE"; then
-       WXWIN_INCLUDE="`$gtkconf --cflags` `$wxconf --cflags`"
+       WXWIN_INCLUDE="$baseflags `$wxconf --cflags`"
        WXWIN_LIBS=`$wxconf --libs`
     fi
+    WXWIN_STATIC_LIBS=`$wxconf --libs --static`
     WXWIN_GL_LIBS=`$wxconf --gl-libs`
+    WXWIN_GL_STATIC_LIBS=`$wxconf --gl-libs --static`
+    WXWIN_POST_LINK=`$wxconf --rezflags`
+    test -n "$WXWIN_POST_LINK"  ||  WXWIN_POST_LINK=:
     AC_DEFINE(HAVE_WXWINDOWS, 1, [Define to 1 if wxWindows is available.])
  fi
+ ## wxWidgets
+ # Insist on single-byte builds by default, per various projects' expectations.
+ : ${with_wxwidgets_ucs=no}
+ if test "$with_wxwidgets" != "no" ; then
+    case "$with_wxwidgets" in
+       yes | "" ) : ${WXWIDGETS_PATH=$NCBI/wxwidgets} ;;
+       *        ) WXWIDGETS_PATH=$with_wxwidgets ;;
+    esac
+    if test -d "$WXWIDGETS_PATH/${compiler_vpfx}${DEBUG_SFX}${mt_sfx}${bit64_sfx}/lib" \
+         -a -z "$WXWIDGETS_ARCH_PATH"; then
+       WXWIDGETS_ARCH_PATH="$WXWIDGETS_PATH/${compiler_vpfx}${DEBUG_SFX}${mt_sfx}${bit64_sfx}"
+    elif test -d "$WXWIDGETS_PATH/${compiler_pfx}${DEBUG_SFX}${mt_sfx}${bit64_sfx}/lib" \
+         -a -z "$WXWIDGETS_ARCH_PATH"; then
+       WXWIDGETS_ARCH_PATH="$WXWIDGETS_PATH/${compiler_pfx}${DEBUG_SFX}${mt_sfx}${bit64_sfx}"
+    else
+       WXWIDGETS_ARCH_PATH="$WXWIDGETS_PATH"
+    fi
+    WXWIDGETS_BINPATH=${WXWIDGETS_BINPATH:="$WXWIDGETS_ARCH_PATH/bin"}
+    WXWIDGETS_LIBPATH=${WXWIDGETS_LIBPATH:="$WXWIDGETS_ARCH_PATH/lib"}
+    WXWIDGETS_INCLUDE=
+    AS_UNSET(wxconf)
+    AC_PATH_PROG(wxconf, wx-config, [], $WXWIDGETS_BINPATH:$PATH)
+    if test -x "$wxconf"; then
+       WXWIDGETS_ARCH_PATH=`$wxconf --exec-prefix`
+       if test -n "$with_wxwidgets_ucs"; then
+          wxcfflags=--unicode=$with_wxwidgets_ucs
+       else
+          wxcfflags=
+       fi
+       for x in `"$wxconf" $wxcfflags --libs --static 2>&AS_MESSAGE_LOG_FD`; do
+          case "$x" in
+             -L*)
+                 d=`echo $x | sed -e 's/^-L//'`
+                 pcd=$d/pkgconfig
+                 if test -d "$pcd"; then
+                    PKG_CONFIG_PATH="${PKG_CONFIG_PATH+$PKG_CONFIG_PATH:}$pcd"
+                 fi
+                 ;;
+          esac
+       done
+       export PKG_CONFIG_PATH
+    else
+       AS_UNSET(wxconf)
+    fi
+    if test -x "$wxconf" \
+      &&  "$wxconf" $wxcfflags --list 2>/dev/null \
+        | grep 'Default config is gtk2' >/dev/null; then
+       gtkconf="pkg-config gtk+-2.0"
+    elif test -x "$WXWIDGETS_BINPATH/gtk-config"; then
+       gtkconf=$WXWIDGETS_BINPATH/gtk-config
+    elif gtk-config --version >/dev/null 2>&1; then
+       gtkconf=gtk-config
+    else
+       # May work without gtk-config (e.g., on Mac OS X)
+       gtkconf=:
+    fi
+    case "$host_os" in
+       darwin* )
+          baseflags=""
+          basesed='s/-isysroot [[^ ]]*//g; s/-arch [[^ ]]*//g'
+          if test -n "$SYSROOT"; then
+             deps=`"$wxconf" $wxcfflags --libs --static 2>/dev/null \
+                   | sed -e 's/.*\.a//'`
+             libsed="$basesed; s/\$/ $deps/"
+          else
+             libsed=$basesed
+          fi
+          ;;
+       * )
+          baseflags=`$gtkconf --cflags 2>/dev/null`
+          basesed=$no_usr_lib
+          libsed=$basesed
+          ;;
+    esac
+    AC_CACHE_CHECK([for wxWidgets in $WXWIDGETS_ARCH_PATH],
+       ncbi_cv_lib_wxwidgets,
+       [if test -x "$wxconf" ; then
+           WXWIDGETS_INCLUDE="$baseflags `"$wxconf" $wxcfflags --cflags`"
+           NCBI_RPATHIFY_OUTPUT(WXWIDGETS_LIBS, ["$wxconf" $wxcfflags --libs],
+              [$libsed; ])
+           CPPFLAGS="$WXWIDGETS_INCLUDE $orig_CPPFLAGS"
+           LIBS="$WXWIDGETS_LIBS $orig_LIBS"
+           AC_LINK_IFELSE([AC_LANG_PROGRAM(
+              [[#include <wx/wx.h>]],
+              [[ wxExit(); ]])],
+              [ncbi_cv_lib_wxwidgets=yes], [ncbi_cv_lib_wxwidgets=no])
+        else
+           ncbi_cv_lib_wxwidgets=no
+        fi])
+    if test "$ncbi_cv_lib_wxwidgets" = "no"; then
+       NCBI_MISSING_PACKAGE(wxwidgets)
+    fi
+ fi
+ if test "$with_wxwidgets" = "no" ; then
+    WXWIDGETS_LIBPATH="No_wxWidgets"
+    WXWIDGETS_INCLUDE=
+    WXWIDGETS_LIBS=
+    WXWIDGETS_STATIC_LIBS=
+    WXWIDGETS_GL_LIBS=
+    WXWIDGETS_GL_STATIC_LIBS=
+    WXWIDGETS_POST_LINK=:
+ else
+    NCBI_PACKAGE(wxWidgets)
+    case "`"$wxconf" $wxcfflags --version`" in
+.[[89]].* | 2.[[0-9]][[0-9]]* )
+          NCBI_PACKAGE(wx2.8)
+          wxlibs=std,richtext
+          ;;
+       *)
+          wxlibs=std
+          ;;
+    esac
+    # The "yes" may have been cached; get the actual settings again if needed
+    if test -z "$WXWIDGETS_INCLUDE"; then
+       WXWIDGETS_INCLUDE="$baseflags `"$wxconf" $wxcfflags --cflags`"
+    fi
+    NCBI_RPATHIFY_OUTPUT(WXWIDGETS_LIBS, [$wxconf $wxcfflags --libs $wxlibs],
+       [$libsed; ])
+    WXWIDGETS_STATIC_LIBS=`"$wxconf" $wxcfflags --libs --static $wxlibs \
+>/dev/null | sed -e "$basesed"`
+    : ${WXWIDGETS_STATIC_LIBS:=$WXWIDGETS_LIBS}
+    WXWIDGETS_GL_LIBS=`"$wxconf" $wxcfflags --libs gl | sed -e "$basesed"`
+    WXWIDGETS_GL_STATIC_LIBS=`"$wxconf" $wxcfflags --libs gl --static \
+>/dev/null | sed -e "$basesed; s|-lGLU* -lGLU*|$OPENGL_STATIC_LIBS|"`
+    : ${WXWIDGETS_GL_STATIC_LIBS:=$WXWIDGETS_GL_LIBS}
+    WXWIDGETS_POST_LINK=`"$wxconf" $wxcfflags --rezflags 2>/dev/null`
+    test -n "$WXWIDGETS_POST_LINK"  ||  WXWIDGETS_POST_LINK=:
+    AC_DEFINE(HAVE_WXWIDGETS, 1, [Define to 1 if wxWidgets is available.])
+ fi
  ## In-house Fast-CGI library
  if test "$with_fastcgi" != "no" ; then
     case "$with_fastcgi" in
-Line 2758
+Line 4934
        */*      ) FASTCGI_PATH=$with_fastcgi              ;;
        *        ) FASTCGI_PATH=$NCBI/fcgi-${with_fastcgi} ;;
     esac
+    if test -d "$FASTCGI_PATH"; then
+       NCBI_FIX_DIR(FASTCGI_PATH)
+    fi
     FASTCGI_INCLUDE="-I$FASTCGI_PATH/include${bit64_sfx}"
     if test "$with_debug" = "no" ; then
-       FASTCGI_LIBS="-L$FASTCGI_PATH/lib${bit64_sfx} -lfcgi $NETWORK_LIBS"
+       FASTCGI_LIBDIR="$FASTCGI_PATH/lib${bit64_sfx}"
     else
-       FASTCGI_LIBS="-L$FASTCGI_PATH/altlib${bit64_sfx} -lfcgi $NETWORK_LIBS"
+       FASTCGI_LIBDIR="$FASTCGI_PATH/altlib${bit64_sfx}"
     fi
+    NCBI_RPATHIFY(FASTCGI_LIBS, $FASTCGI_LIBDIR, [ -lfcgi $NETWORK_LIBS])
     FASTCGI_OBJS="fcgibuf"
     LIBS="$FASTCGI_LIBS $orig_LIBS"
     AC_CACHE_CHECK([for FastCGI libraries in $FASTCGI_PATH], ncbi_cv_lib_fcgi,
-Line 2773
+Line 4953
            [[ (void) FCGX_IsCGI(); ]])],
            [ncbi_cv_lib_fcgi=yes], [ncbi_cv_lib_fcgi=no])])
     if test "$ncbi_cv_lib_fcgi" = "no"; then
-       with_fastcgi="no"
+       NCBI_MISSING_PACKAGE(fastcgi)
     fi
     AC_CHECK_FUNCS(FCGX_Accept_r)
  fi
-Line 2782
+Line 4962
     FASTCGI_INCLUDE=
     FASTCGI_LIBS=
     FASTCGI_OBJS=
-    WithoutPackages="$WithoutPackages Fast-CGI"
  else
-    WithPackages="$WithPackages Fast-CGI"
+    NCBI_PACKAGE(Fast-CGI)
     AC_DEFINE(HAVE_LIBFASTCGI, 1,
               [Define to 1 if FastCGI libraries are available.])
  fi
  ## NCBI SSS libraries
- with_sss=${with_sss:="yes"}
- with_sssutils=${with_sssutils:="yes"}
- with_sssdb=${with_sssdb:="yes"}
  if test "$with_sybase" = "no" ; then
-    with_sssdb="no"
+    NCBI_MISSING_PACKAGE(sssdb)
  fi
+ case "$host_os:$compiler:$compiler_version" in
+    linux*:GCC:*)
+       : ${with_included_sss=yes}
+    ;;
+ esac
  if test "$with_sss" != "no" ; then
+    local_sss=${real_srcdir}/src/internal/sss
+    if test "${with_included_sss-no}" = "yes" \
+        -a -f "$local_sss/utils/sssdebug.hpp" \
+        -a -f "${local_sss}srv/cli/sssconnection.cpp"; then
+       with_included_sss=yes
+       NCBI_SSS_PATH=$local_sss
+       NCBI_SSS_INCLUDE="\$(incdir)/sss"
+       NCBI_SSS_LIBPATH="\$(libdir)"
+       NCBI_PACKAGE(LocalSSS)
+       if test -f "$local_sss/../ncbi_ls/asn/login.asn"; then
+          NCBI_PACKAGE(LocalNCBILS)
+       fi
+       if test -f "$local_sss/../msgmail2/asn/msgmail.asn"; then
+          NCBI_PACKAGE(LocalMSGMAIL2)
+       fi
+    else
+       with_included_sss=no
+    fi
     NCBI_SSS_PATH=${NCBI_SSS_PATH:="$NCBI/sss/BUILD"}
     NCBI_SSS_INCLUDE=${NCBI_SSS_INCLUDE:="$NCBI_SSS_PATH/include"}
     if test -z "$NCBI_SSS_LIBPATH" ; then
-       NCBI_SSS_LIBPATH="${NCBI_SSS_PATH}/lib/${release_debug}"
+       NCBI_SSS_LIBPATH="${NCBI_SSS_PATH}/lib/${compiler_vpfx}${DEBUG_SFX}${bit64_sfx}"
-       if test "$compiler" = "GCC" ; then
-          NCBI_SSS_LIBPATH="${NCBI_SSS_LIBPATH}GNU"
-          if test -d "$NCBI_SSS_LIBPATH$ncbi_compiler_ver"; then
-             NCBI_SSS_LIBPATH=$NCBI_SSS_LIBPATH$ncbi_compiler_ver
-          fi
-       elif test "$compiler" = "KCC" ; then
-          NCBI_SSS_LIBPATH="${NCBI_SSS_LIBPATH}KAI"
-       elif test "$compiler" = "ICC" ; then
-          NCBI_SSS_LIBPATH="${NCBI_SSS_LIBPATH}ICC"
-       fi
-       NCBI_SSS_LIBPATH="${NCBI_SSS_LIBPATH}${bit64_sfx}"
        if test "$with_mt" = "yes" ; then
           NCBI_SSS_LIBPATH="${NCBI_SSS_LIBPATH}mt"
        fi
     fi
     AC_MSG_CHECKING([for NCBI SSS directories in $NCBI_SSS_PATH])
-    if test ! -d "${NCBI_SSS_LIBPATH}"  -o  ! -d "${NCBI_SSS_INCLUDE}" ; then
+    if test "$with_included_sss" = "yes"; then
+       AC_MSG_RESULT([yes]) # duh
+    elif test ! -d "${NCBI_SSS_LIBPATH}"  -o  ! -d "${NCBI_SSS_INCLUDE}" ; then
        AC_MSG_RESULT([no])
-       with_sss="no"
+       NCBI_MISSING_PACKAGE(sss)
     else
        AC_MSG_RESULT([yes])
     fi
  fi
  if test "$with_sss" = "no" ; then
-    with_sssutils="no"
+    NCBI_MISSING_PACKAGE(sssutils)
-    with_sssdb="no"
+    NCBI_MISSING_PACKAGE(sssdb)
     NCBI_SSS_INCLUDE=
     NCBI_SSS_LIBPATH=
     LIBSSSUTILS=
     LIBSSSDB=
-    WithoutPackages="$WithoutPackages SSS"
+ else
+    if test "$with_included_sss" = "yes"; then
+       NCBI_SSS_LIBPATH= # Not needed
+       ncbi_cv_lib_sssutils=yes
+       ncbi_cv_lib_sssdb=yes
  else
     NCBI_SSS_LIBPATH="-L${NCBI_SSS_LIBPATH}"
+    fi
     NCBI_SSS_INCLUDE="-I${NCBI_SSS_INCLUDE}"
     # SSS UTILS
-Line 2853
+Line 5048
        if test "$ncbi_cv_lib_sssutils" = yes; then
           AC_DEFINE(HAVE_LIBSSSUTILS, 1,
                     [Define to 1 if the NCBI SSS UTILS library is available.])
-          WithPackages="$WithPackages SSSUTILS"
+          NCBI_PACKAGE(SSSUTILS)
        else
-          with_sssutils="no"
+          NCBI_MISSING_PACKAGE(sssutils)
-          with_sss="no"
+          NCBI_MISSING_PACKAGE(sss)
           LIBSSSUTILS=""
-          WithoutPackages="$WithoutPackages SSSUTILS"
        fi
     fi
-Line 2879
+Line 5073
        if test "$ncbi_cv_lib_sssdb" = "yes"; then
           AC_DEFINE(HAVE_LIBSSSDB, 1,
                     [Define to 1 if the NCBI SSS DB library is available.])
-          WithPackages="$WithPackages SSSDB"
+          NCBI_PACKAGE(SSSDB)
        else
-          with_sssdb="no"
+          NCBI_MISSING_PACKAGE(sssdb)
-          with_sss="no"
+          NCBI_MISSING_PACKAGE(sss)
           LIBSSSDB=""
-          WithoutPackages="$WithoutPackages SSSDB"
-       fi
-    fi
- fi
- # GEO
- with_geo=${with_geo:="yes"}
- if test "$with_sssdb" = "no"  -o  "$with_sssutils" = "no" ; then
-    with_geo="no"
- fi
- if test "$with_geo" != "no" ; then
-    NCBI_GEO_PATH=${NCBI_GEO_PATH:="$NCBI/geo/BUILD"}
-    NCBI_GEO_INCLUDE=${NCBI_GEO_INCLUDE:="$NCBI_GEO_PATH/include"}
-    if test -z "$NCBI_GEO_LIBPATH" ; then
-       NCBI_GEO_LIBPATH="${NCBI_GEO_PATH}/lib/${release_debug}${bit64_sfx}"
-    fi
-    AC_MSG_CHECKING([for NCBI GEO directories in $NCBI_GEO_PATH])
-    if test ! -d "${NCBI_GEO_LIBPATH}"  -o  ! -d "${NCBI_GEO_INCLUDE}" ; then
-       AC_MSG_RESULT([no])
-       with_geo="no"
-    else
-       AC_MSG_RESULT([yes])
     fi
  fi
- if test "$with_geo" = "no" ; then
-    NCBI_GEO_INCLUDE=
-    NCBI_GEO_LIBPATH=
-    LIBGEODB=
- else
-    NCBI_GEO_LIBPATH="-L${NCBI_GEO_LIBPATH}"
-    NCBI_GEO_INCLUDE="-I${NCBI_GEO_INCLUDE}"
-    LIBGEODB="-lgeodb"
-    # We have to be careful here, since GEO uses our libxncbi...
-    # We can't reasonably test *at all* on WorkShop, so just assume success.
-    case "$compiler" in
-       WorkShop*) ncbi_cv_lib_geodb=yes ;;
-    esac
-    AC_CACHE_CHECK([for the NCBI GEO DB library], ncbi_cv_lib_geodb,
-      [CPPFLAGS="$NCBI_GEO_INCLUDE $NCBI_SSS_INCLUDE $SYBASE_INCLUDE -I$srcdir/include $orig_CPPFLAGS"
-       LIBS="$NCBI_GEO_LIBPATH $LIBGEODB $NCBI_SSS_LIBPATH $LIBSSSDB $LIBSSSUTILS $SYBASE_LIBS $NETWORK_LIBS $DL_LIBS $orig_LIBS"
-       AC_LINK_IFELSE([AC_LANG_PROGRAM(
-          [[#define FORWARDING_NCBICONF_H
-            #include <geo_api.hpp>]],
-          [[GEO_API::Pattern* p; if (p->isValid()) p->bind(1, "x", true, "y"); ]])],
-          [ncbi_cv_lib_geodb=yes], [ncbi_cv_lib_geodb=no])])
-    if test "$ncbi_cv_lib_geodb" = yes; then
-       AC_DEFINE(HAVE_LIBGEODB, 1,
-                 [Define to 1 if NCBI GEO DB library is available.])
-    else
-       with_geo=no
-    fi
- fi
- if test "$with_geo" != "no" ; then
-    WithPackages="$WithPackages GEO"
- else
-    WithoutPackages="$WithoutPackages GEO"
  fi
  # SP
- with_sp=${with_sp:="yes"}
  if test "$with_sp" != "no" ; then
     SP_PATH=${SP_PATH:="$NCBI/SP"}
     if test -n "$SP_INCLUDE"; then
-Line 2962
+Line 5093
        SP_GENERIC="$SP_PATH/generic"
     fi
     if test -z "$SP_LIBPATH" ; then
-       SP_LIBPATH="${SP_PATH}/${compiler_pfx}${release_debug}${mt_sfx}${bit64_sfx}"
+       SP_LIBPATH="${SP_PATH}/${compiler_vpfx}${DEBUG_SFX}${mt_sfx}${bit64_sfx}"
     fi
     AC_MSG_CHECKING([for SP directories in $SP_PATH])
     if test ! -d "${SP_LIBPATH}"  -o  ! -d "${SP_INCLUDE}" ; then
        AC_MSG_RESULT([no])
-       with_sp="no"
+       NCBI_MISSING_PACKAGE(sp)
     else
        AC_MSG_RESULT([yes])
     fi
-Line 2988
+Line 5119
            [[ SP_API::SGMLApplication app; ]])],
            [ncbi_cv_lib_sp=yes], [ncbi_cv_lib_sp=no])])
     if test "$ncbi_cv_lib_sp" = "no"; then
-       with_sp="no"
+       NCBI_MISSING_PACKAGE(sp)
     fi
  fi
  if test "$with_sp" = "no" ; then
     SP_INCLUDE=
     SP_LIBS=
-    WithoutPackages="$WithoutPackages SP"
  else
-    WithPackages="$WithPackages SP"
+    NCBI_PACKAGE(SP)
     AC_DEFINE(HAVE_LIBSP, 1, [Define to 1 if the SP SGML library is available.])
  fi
- ## NCBI PubMed
- if test "$with_ncbi_c" = "no" ; then
-    with_pubmed="no"
- fi
- if test "$with_pubmed" != "no" ; then
-    case "$NCBI_PM_PATH" in
-       "" )          NCBI_PM_PATH=$NCBI/pubmed${bit64_sfx} ;;
-       *$bit64_sfx ) ;;
-       * )           NCBI_PM_PATH=${NCBI_PM_PATH}${bit64_sfx} ;;
-    esac
-    pmtag=${release_debug}${bit64_sfx:-32}
-    AC_CACHE_CHECK([for NCBI PubMed libraries in $NCBI_PM_PATH], ncbi_cv_lib_pm,
-       [if test ! -d "${NCBI_PM_PATH}" ; then
-           ncbi_cv_lib_pm="no"
-        else
-           CPPFLAGS="-I$NCBI_PM_PATH/pmentrez/include/Ncbi -I$NCBI_PM_PATH/xmldb/ur/include $NCBI_C_INCLUDE $orig_CPPFLAGS"
-           LIBS="-L$NCBI_PM_PATH/xmldb$mt_sfx/out.$pmtag/lib -lpmurapi-static -L$NCBI_PM_PATH/pmentrez.$pmtag$mt_sfx/pmentrez/libs -lpmncbi $NCBI_C_LIBPATH -lncbi $orig_LIBS"
-           AC_LINK_IFELSE([AC_LANG_PROGRAM(
-              [[#include <ncbistr.hpp>
-                #include <hastring.h>]],
-              [[ CNcbiString("abc"); CAString("def"); ]])],
-              [ncbi_cv_lib_pm=yes], [ncbi_cv_lib_pm=no])
-        fi])
-    if test "$ncbi_cv_lib_pm" = "no"; then
-       with_pubmed="no"
-    fi
- fi
- if test "$with_pubmed" = "no" ; then
-    NCBI_PM_PATH="No_NCBI_PubMed"
-    WithoutPackages="$WithoutPackages PubMed"
- else
-    WithPackages="$WithPackages PubMed"
-    AC_DEFINE(HAVE_LIBPUBMED, 1,
-              [Define to 1 if NCBI PubMed libraries are available.])
- fi
  ## ORBacus CORBA
  if test "${with_orbacus:-yes}" = yes; then
+    if test -d $NCBI/corba/${compiler_vpfx}Release${bit64_sfx}MT; then
+       : ${ORBACUS_PATH=$NCBI/corba/${compiler_vpfx}Release${bit64_sfx}MT}
+    else
      : ${ORBACUS_PATH=$NCBI/corba/OB-4.0.1}
+    fi
  elif test "$with_orbacus" != no; then
      ORBACUS_PATH=$with_orbacus
  fi
- if test "$with_orbacus" != no; then
+ if test -d "$ORBACUS_PATH"; then
-    fullpath=${ORBACUS_PATH}/${release_debug}${mt_sfx}${bit64_sfx}
+    NCBI_FIX_DIR(ORBACUS_PATH)
-    LIBOB="-lOB"
-    if test "$with_mt" = "yes" ; then
-       LIBOB="$LIBOB -lJTC"
-       LIBIMR="-lIMR"
-    else
-       LIBIMR=
     fi
+ if test "$with_orbacus" != no; then
+    fullpath=${ORBACUS_PATH}/${DEBUG_SFX}${mt_sfx}${bit64_sfx}
     if test -f ${fullpath}/inc/OB/Config.h ; then
        : ${ORBACUS_INCLUDE="-I$ORBACUS_PATH/include -I$fullpath/inc"}
-       : ${ORBACUS_LIBPATH="-L$fullpath/lib ${CONF_f_runpath}${fullpath}/lib"}
+       NCBI_RPATHIFY_COND(ORBACUS_LIBPATH, $fullpath/lib)
     elif test -f ${ORBACUS_PATH}/include/OB/Config.h ; then
       : ${ORBACUS_INCLUDE="-I$ORBACUS_PATH/include"}
-      : ${ORBACUS_LIBPATH="-L$ORBACUS_PATH/lib ${CONF_f_runpath}${ORBACUS_PATH}/lib"}
+      NCBI_RPATHIFY_COND(ORBACUS_LIBPATH, $ORBACUS_PATH/lib)
     fi
+    case "$host_os:$with_mt" in
+        linux*:no) LIBJTC="-lJTC -pthread" ;;
+        *)         LIBJTC="-lJTC"          ;;
+    esac
+    case "$with_mt:$ORBACUS_LIBPATH" in
+       yes:* | *:-L*MT/lib* )
+          LIBOB="-lOB $LIBJTC"
+          LIBIMR="-lIMR"
+          ;;
+       * )
+          LIBOB="-lOB"
+          LIBIMR=
+          ;;
+    esac
     AC_CACHE_CHECK([for ORBacus in $ORBACUS_PATH], ncbi_cv_lib_orbacus,
        [CPPFLAGS="$ORBACUS_INCLUDE $orig_CPPFLAGS"
-        LIBS="$ORBACUS_LIBPATH $LIBOB $NETWORK_LIBS $orig_LIBS"
+        LIBS="$ORBACUS_LIBPATH $LIBOB $NETWORK_LIBS $DL_LIBS $orig_LIBS"
         AC_LINK_IFELSE([AC_LANG_PROGRAM(
            [[#include <OB/CORBA.h>]],
            [[
-Line 3077
+Line 5182
            ]])],
            [ncbi_cv_lib_orbacus=yes], [ncbi_cv_lib_orbacus=no])])
     if test "$ncbi_cv_lib_orbacus" = "no"; then
-       with_orbacus="no"
+       NCBI_MISSING_PACKAGE(orbacus)
     fi
  fi
  if test "$with_orbacus" = no; then
-    WithoutPackages="$WithoutPackages ORBacus"
     ORBACUS_PATH=No_ORBacus
     ORBACUS_INCLUDE=
     ORBACUS_LIBPATH=
     LIBOB=
     LIBIMR=
  else
-    WithPackages="$WithPackages ORBacus"
+    NCBI_PACKAGE(ORBacus)
     AC_DEFINE(HAVE_ORBACUS, 1,
               [Define to 1 if the ORBacus CORBA package is available.])
  fi
-Line 3097
+Line 5201
  test -d SunWS_cache  &&  rm -r SunWS_cache
+ ## International Components for Unicode (ICU)
+ if test -z "$ICU_PATH"  &&  icu-config --version >/dev/null 2>&1; then
+     ICU_PATH=`icu-config --prefix`
+ fi
+ if test "$with_icu" != "no" ; then
+    case "$with_icu" in
+       yes | "" ) : ${ICU_PATH=$NCBI/icu} ;;
+       *        ) ICU_PATH=$with_icu ;;
+    esac
+    if test -d "$ICU_PATH/${compiler_vpfx}${DEBUG_SFX}${bit64_sfx}${mt_sfx}/lib" \
+         -a -z "$ICU_ARCH_PATH"; then
+       ICU_ARCH_PATH="$ICU_PATH/${compiler_vpfx}${DEBUG_SFX}${bit64_sfx}${mt_sfx}"
+    elif test -d "$ICU_PATH/${compiler_pfx}${DEBUG_SFX}${bit64_sfx}${mt_sfx}/lib" \
+         -a -z "$ICU_ARCH_PATH"; then
+       ICU_ARCH_PATH="$ICU_PATH/${compiler_pfx}${DEBUG_SFX}${bit64_sfx}${mt_sfx}"
+    else
+       ICU_ARCH_PATH="$ICU_PATH"
+    fi
+    ICU_BINPATH=${ICU_BINPATH:="$ICU_ARCH_PATH/bin"}
+    ICU_LIBPATH=${ICU_LIBPATH:="$ICU_ARCH_PATH/lib"}
+    ICU_INCLUDE=
+    AC_CACHE_CHECK([for ICU in $ICU_ARCH_PATH], ncbi_cv_lib_icu,
+       [ICU_CONFIG=`$ICU_BINPATH/icu-config --bindir 2>/dev/null`/icu-config
+        if test -x "$ICU_CONFIG" ; then
+           ICU_INCLUDE=`$ICU_CONFIG --cppflags-searchpath`
+           NCBI_RPATHIFY_OUTPUT(ICU_LIBS, $ICU_CONFIG --ldflags)
+           CPPFLAGS="$ICU_INCLUDE $orig_CPPFLAGS"
+           LIBS="$ICU_LIBS $orig_LIBS"
+           AC_LINK_IFELSE([AC_LANG_PROGRAM(
+             [[#include <unicode/unistr.h>]],
+             [[int32_t i = UNICODE_STRING_SIMPLE("foo").indexOf('f');]])],
+             [ncbi_cv_lib_icu=yes], [ncbi_cv_lib_icu=no])
+        else
+           ncbi_cv_lib_icu=no
+        fi])
+    if test "$ncbi_cv_lib_icu" = "no"; then
+       NCBI_MISSING_PACKAGE(icu)
+    fi
+ fi
+ if test "$with_icu" = "no" ; then
+    ICU_PATH="No_ICU"
+    ICU_INCLUDE=
+    ICU_LIBS=
+    ICU_STATIC_LIBS=
+ else
+    NCBI_PACKAGE(ICU)
+    ICU_CONFIG="`$ICU_BINPATH/icu-config --bindir`/icu-config"
+    # The "yes" may have been cached; get the actual settings again if needed
+    if test -z "$ICU_INCLUDE"; then
+       ICU_INCLUDE=`$ICU_CONFIG --cppflags-searchpath`
+       NCBI_RPATHIFY_OUTPUT(ICU_LIBS, $ICU_CONFIG --ldflags)
+    fi
+    ICU_STATIC_LIBS=`$ICU_CONFIG --ldflags | sed -e 's/-licu/-lsicu/g'`
+    AC_DEFINE(HAVE_ICU, 1, [Define to 1 if ICU libraries are available.])
+ fi
  ### XML/XSL libraries
+ if test -d "$NCBI/expat/include"; then
  : ${EXPAT_PATH=$NCBI/expat}
+ fi
  NCBI_CHECK_THIRD_PARTY_LIB(expat,
   AC_LANG_PROGRAM([#include <expat.h>],
      [XML_Parser parser = XML_ParserCreate("utf-8");]))
+ if test -f "${EXPAT_PATH}/lib${bit64_sfx}/libexpat-static.a"; then
+    EXPAT_STATIC_LIBS="-L${EXPAT_PATH}/lib${bit64_sfx} -lexpat-static"
+ else
+    EXPAT_STATIC_LIBS=${EXPAT_LIBS}
+ fi
  : ${SABLOT_PATH=$NCBI/Sablot}
+ vpath="$SABLOT_PATH/${compiler_vpfx}build"
+ test -d "$vpath"  &&  SABLOT_PATH=$vpath
+ if test -d "$SABLOT_PATH"; then
+    NCBI_FIX_DIR(SABLOT_PATH)
+ fi
  NCBI_CHECK_THIRD_PARTY_LIB(sablot,
   AC_LANG_PROGRAM([#include <sablot.h>],
      [SDOM_Document* D; int x = SablotParse(NULL, "file:/dev/null", D);]),
   $EXPAT_LIBS)
  test -d SunWS_cache  &&  rm -r SunWS_cache
+ if test -f "${SABLOT_PATH}/lib${bit64_sfx}/libsablot-static.a"; then
+    SABLOT_STATIC_LIBS="-L${SABLOT_PATH}/lib${bit64_sfx} -lsablot-static $EXPAT_STATIC_LIBS"
+ else
+    SABLOT_STATIC_LIBS=${SABLOT_LIBS}
+ fi
+ : ${LIBXML_PATH=$NCBI/libxml}
+ # test -d "$LIBXML_PATH" || LIBXML_PATH=`xml2-config --prefix 2>/dev/null`
+ if test "$with_libxml" != "no"; then
+    case "$with_libxml" in
+       yes | "" ) ;;
+       *        ) LIBXML_PATH=$with_libxml ;;
+    esac
+    for pfx in "$compiler_vpfx" "$compiler_pfx" "" ; do
+       vpath=$LIBXML_PATH/$pfx${DEBUG_SFX}${mt_sfx}${bit64_sfx}
+       if test -d "$vpath" ; then
+          LIBXML_PATH=$vpath
+          break
+       fi
+    done
+    if test -d "$LIBXML_PATH"; then
+       NCBI_FIX_DIR(LIBXML_PATH)
+       in_path=" in $LIBXML_PATH"
+       if test -n "$LIBXML_INCLUDE"; then
+          :
+       elif test -d "$LIBXML_PATH/include/libxml2/libxml"; then
+          LIBXML_INCLUDE="-I$LIBXML_PATH/include/libxml2 -I$LIBXML_PATH/include"
+       elif test -d "$LIBXML_PATH/include/libxml"; then
+          LIBXML_INCLUDE="-I$LIBXML_PATH/include";
+       fi
+       if test -d "$LIBXML_PATH/lib${bit64_sfx}"; then
+          LIBXML_LIBPATH_="$LIBXML_PATH/lib${bit64_sfx}"
+       elif test -d "$LIBXML_PATH/lib"; then
+          LIBXML_LIBPATH_="$LIBXML_PATH/lib"
+       fi
+       NCBI_RPATHIFY_COND(LIBXML_LIBPATH, $LIBXML_LIBPATH_)
+       LIBXML_LIBS="$LIBXML_LIBPATH -lxml2"
+    else
+       LIBXML_INCLUDE="-I/usr/include/libxml2"
+       LIBXML_LIBS="-lxml2"
+       in_path=
+    fi
+    LIBXML_LIBS="$LIBXML_LIBS $ICONV_LIBS"
+    AC_CACHE_CHECK([for libxml2$in_path], ncbi_cv_lib_libxml,
+       CPPFLAGS="$LIBXML_INCLUDE $orig_CPPFLAGS"
+       LIBS="$LIBXML_LIBS $orig_LIBS"
+       [AC_LINK_IFELSE(
+          [AC_LANG_PROGRAM(
+              [#include <libxml/parser.h>],
+              [xmlDocPtr doc = xmlParseFile("foo.xml");])],
+       [ncbi_cv_lib_libxml=yes], [ncbi_cv_lib_libxml=no])])
+    if test "$ncbi_cv_lib_libxml" = "no"; then
+       NCBI_MISSING_PACKAGE(libxml)
+    fi
+ fi
+ if test "$with_libxml" = "no"; then
+    LIBXML_PATH="No_LIBXML"
+    LIBXML_INCLUDE=
+    LIBXML_LIBPATH_=
+    LIBXML_LIBS=
+ else
+    NCBI_PACKAGE(LIBXML)
+    LIBXML_INCLUDE="$LIBXML_INCLUDE"
+    AC_DEFINE(HAVE_LIBXML, 1, [Define to 1 if libxml2 is available.])
+ fi
+ AC_SUBST(LIBXML_INCLUDE)
+ AC_SUBST(LIBXML_LIBS)
+ if test -f "${LIBXML_LIBPATH_}/libxml2-static.a"; then
+    LIBXML_STATIC_LIBS="-L${LIBXML_LIBPATH_} -lxml2-static"
+ else
+    LIBXML_STATIC_LIBS=${LIBXML_LIBS}
+ fi
+ : ${LIBXSLT_PATH=$LIBXML_PATH}
+ NCBI_CHECK_THIRD_PARTY_LIB_EX(libxslt, LIBXSLT, xslt,
+  [AC_LANG_PROGRAM([#include <libxslt/xslt.h>], [xsltInit()])],
+  [], [$LIBXML_LIBS $Z_LIBS], [$LIBXML_INCLUDE])
+ # XXX - they might be in different directories in some setups
+ if test -f "${LIBXML_LIBPATH_}/libxslt-static.a"; then
+    LIBXSLT_STATIC_LIBS="-L${LIBXML_LIBPATH_} -lxslt-static"
+ else
+    LIBXSLT_STATIC_LIBS=${LIBXSLT_LIBS}
+ fi
+ : ${XERCES_PATH=$NCBI/xerces}
+ if test "$with_xerces" != no; then
+    if test "${with_xerces-yes}" != yes; then
+       XERCES_PATH=$with_xerces
+    fi
+    if test -d "$XERCES_PATH"; then
+       NCBI_FIX_DIR(XERCES_PATH)
+    fi
+    vpath="$XERCES_PATH/${compiler_vpfx}${DEBUG_SFX}${bit64_sfx}${mt_sfx}"
+    if test -d "$vpath/lib"; then
+       XERCES_PATH=$vpath
+       NCBI_FIX_DIR(XERCES_PATH)
+    elif test -d "$vpath"; then
+       : ${XERCES_LIBPATH=$vpath}
+       NCBI_FIX_DIR(XERCES_LIBPATH)
+    else
+       vpath="$XERCES_PATH/${compiler_pfx}${DEBUG_SFX}${bit64_sfx}${mt_sfx}"
+       if test -d "$vpath/lib"; then
+          XERCES_PATH=$vpath
+          NCBI_FIX_DIR(XERCES_PATH)
+       elif test -d "$vpath"; then
+          XERCES_LIBPATH=$vpath
+          NCBI_FIX_DIR(XERCES_LIBPATH)
+       fi
+    fi
+    if test -d $XERCES_PATH; then
+       in_path=" in $XERCES_PATH"
+       : ${XERCES_INCLUDE=-I$XERCES_PATH/include}
+       : ${XERCES_LIBPATH=$XERCES_PATH/lib}
+    else
+       in_path=''
+    fi
+    NCBI_RPATHIFY(XERCES_LIBPATH_, $XERCES_LIBPATH)
+    XERCES_LIBS="$XERCES_LIBPATH_ -lxerces-c"
+    AC_CACHE_CHECK([for Xerces-C++$in_path], ncbi_cv_lib_xerces_c,
+       [CPPFLAGS="$XERCES_INCLUDE $orig_CPPFLAGS"
+        LIBS="$XERCES_LIBS $ICU_LIBS $orig_LIBS"
+        AC_LINK_IFELSE(
+           [AC_LANG_PROGRAM([[#include <xercesc/dom/DOM.hpp>]],
+              [[xercesc::DOMImplementation* impl
+                = xercesc::DOMImplementationRegistry::getDOMImplementation
+                  (xercesc::XMLString::transcode("XML 1.0"));]])],
+           ncbi_cv_lib_xerces_c=yes, ncbi_cv_lib_xerces_c=no)])
+    if test $ncbi_cv_lib_xerces_c = yes; then
+       if test -f "$XERCES_LIBPATH/libxerces-c-static.a"; then
+          XERCES_STATIC_LIBS="-L$XERCES_LIBPATH -lxerces-c-static"
+       else
+          XERCES_STATIC_LIBS=$XERCES_LIBS
+       fi
+    else
+       NCBI_MISSING_PACKAGE(xerces)
+    fi
+ fi
+ if test "$with_xerces" != no; then
+    NCBI_PACKAGE(Xerces)
+    AC_DEFINE(HAVE_XERCES, 1, [Define to 1 if Xerces-C++ is available.])
+ else
+    XERCES_INCLUDE=
+    XERCES_LIBS=
+    XERCES_STATIC_LIBS=
+ fi
+ : ${XALAN_PATH=$NCBI/xalan}
+ if test "$with_xalan" != no; then
+    if test "${with_xalan-yes}" != yes; then
+       XALAN_PATH=$with_xalan
+    fi
+    if test -d "$XALAN_PATH"; then
+       NCBI_FIX_DIR(XALAN_PATH)
+    fi
+    vpath="$XALAN_PATH/${compiler_vpfx}${DEBUG_SFX}${bit64_sfx}${mt_sfx}"
+    if test -d "$vpath/lib"; then
+       XALAN_PATH=$vpath
+       NCBI_FIX_DIR(XALAN_PATH)
+    elif test -d "$vpath"; then
+       : ${XALAN_LIBPATH=$vpath}
+       NCBI_FIX_DIR(XALAN_LIBPATH)
+    else
+       vpath="$XALAN_PATH/${compiler_pfx}${DEBUG_SFX}${bit64_sfx}${mt_sfx}"
+       if test -d "$vpath/lib"; then
+          XALAN_PATH=$vpath
+          NCBI_FIX_DIR(XALAN_PATH)
+       elif test -d "$vpath"; then
+          XALAN_LIBPATH=$vpath
+          NCBI_FIX_DIR(XALAN_LIBPATH)
+       fi
+    fi
+    if test -d $XALAN_PATH; then
+       in_path=" in $XALAN_PATH"
+       : ${XALAN_INCLUDE=-I$XALAN_PATH/include}
+       : ${XALAN_LIBPATH=$XALAN_PATH/lib}
+    else
+       in_path=''
+    fi
+    NCBI_RPATHIFY(XALAN_LIBPATH_, $XALAN_LIBPATH)
+    XALAN_LIBS="$XALAN_LIBPATH_ -lxalan-c -lxalanMsg"
+    AC_CACHE_CHECK([for Xalan-C++$in_path], ncbi_cv_lib_xalan_c,
+       [CPPFLAGS="$XALAN_INCLUDE $XERCES_INCLUDE $orig_CPPFLAGS"
+        LIBS="$XALAN_LIBS $XERCES_LIBS $ICU_LIBS $orig_LIBS"
+        AC_LINK_IFELSE(
+           [AC_LANG_PROGRAM([[#include <xalanc/XalanEXSLT/XalanEXSLTMath.hpp>]],
+              [[xalanc::XalanEXSLTMathFunctionsInstaller::installGlobal();]])],
+           ncbi_cv_lib_xalan_c=yes, ncbi_cv_lib_xalan_c=no)])
+    if test $ncbi_cv_lib_xalan_c = yes; then
+       if test -f "$XALAN_LIBPATH/libxalan-c-static.a"; then
+          XALAN_STATIC_LIBS="-L$XALAN_LIBPATH -lxalan-c-static -lxalanMsg-static"
+       else
+          XALAN_STATIC_LIBS=$XALAN_LIBS
+       fi
+    else
+       NCBI_MISSING_PACKAGE(xalan)
+    fi
+ fi
+ if test "$with_xalan" != no; then
+    NCBI_PACKAGE(Xalan)
+    AC_DEFINE(HAVE_XALAN, 1, [Define to 1 if Xalan-C++ is available.])
+ else
+    XALAN_INCLUDE=
+    XALAN_LIBS=
+    XALAN_STATIC_LIBS=
+ fi
+ test -d SunWS_cache  &&  rm -r SunWS_cache
  ### SQLite
- : ${SQLITE_PATH=$NCBI/sqlite}
+ : ${SQLITE_PATH=$NCBI/sqlite2}
+ if test -d "$SQLITE_PATH"; then
+    NCBI_FIX_DIR(SQLITE_PATH)
+ fi
  NCBI_CHECK_THIRD_PARTY_LIB(sqlite,
   AC_LANG_PROGRAM([#include <sqlite.h>],
-     [sqlite* db = sqlite_open("foo.db", 0, NULL);]))
+     [char *errs; sqlite* db = sqlite_open("foo.db", 0, &errs);]))
+ case "$with_sqlite3" in
+    yes | '' ) : ${SQLITE3_PATH=$NCBI/sqlite3} ;;
+    *        ) SQLITE3_PATH=$with_sqlite3 ;;
+ esac
+ if test -d "$SQLITE3_PATH"; then
+    NCBI_FIX_DIR(SQLITE3_PATH)
+ fi
+ if test -d "$SQLITE3_PATH/${compiler_pfx}${DEBUG_SFX}${MT_SFX}${bit64_sfx}/lib"; then
+    SQLITE3_LIBDIR=$SQLITE3_PATH/${compiler_pfx}${DEBUG_SFX}${MT_SFX}${bit64_sfx}/lib
+ elif test -d $SQLITE3_PATH/lib${bit64_sfx}; then
+    SQLITE3_LIBDIR=$SQLITE3_PATH/lib${bit64_sfx}
+ else
+    SQLITE3_LIBDIR=$SQLITE3_PATH/lib
+ fi
+ NCBI_RPATHIFY(SQLITE3_LIBPATH, $SQLITE3_LIBDIR)
+ NCBI_CHECK_THIRD_PARTY_LIB(sqlite3,
+  AC_LANG_PROGRAM([#include <sqlite3.h>],
+     [sqlite3_pcache_methods m;
+      int status = sqlite3_config(SQLITE_CONFIG_GETPCACHE, &m);]))
+ if test -n "$SQLITE3_LIBS"; then
+    CPPFLAGS="$SQLITE3_INCLUDE $orig_CPPFLAGS"
+    AC_CHECK_HEADER(sqlite3async.h,
+       [AC_DEFINE(HAVE_SQLITE3ASYNC_H, 1,
+           [Define to 1 if you have the <sqlite3async.h> header file.])
+        NCBI_PACKAGE(SQLITE3ASYNC)])
+    LIBS="$SQLITE3_LIBS $orig_LIBS"
+    AC_CHECK_FUNCS(sqlite3_unlock_notify)
+ fi
+ if test -n "$SQLITE3_LIBS" -a -f "$SQLITE3_LIBDIR/libsqlite3-static.a"; then
+    SQLITE3_STATIC_LIBS="-L$SQLITE3_LIBDIR -lsqlite3-static"
+ else
+    SQLITE3_STATIC_LIBS=$SQLITE3_LIBS
+ fi
+ ### OEChem
+ # somewhat kludgish, as we now wanto to add in oeiupac and oedepict,
+ # which depend on oechem....
+ : ${OECHEM_PATH=$NCBI/oechem}
+ NCBI_CHECK_THIRD_PARTY_LIB(oechem,
+  AC_LANG_PROGRAM([#include <oechem.h>],
+     [OEChem::OEMol mol; OEChem::OEConfBase* c = mol.GetActive();]),
+   -loeiupac -loedepict -loechem -loesystem -loeplatform -lz, $NETWORK_LIBS)
+ if test -n "$OECHEM_LIBS"; then
+    OECHEM_LIBS=`echo $OECHEM_LIBS | sed -e 's/-loechem \(.*-loechem .*\)/\1/'`
+ fi
+ test -d SunWS_cache  &&  rm -r SunWS_cache
+ ### Sun Grid Engine
+ case "$with_sge" in
+    yes | "" ) : ${SGE_PATH=/netopt/sge} ;;
+    *        ) SGE_PATH=$with_sge ;;
+ esac
+ if test -d "$SGE_PATH" -a -z "$SGE_LIBPATH"; then
+    case "$host:$NCBI_PLATFORM_BITS" in
+       i?86-*-darwin*      ) SGE_LIBPATH=$SGE_PATH/lib/darwin-x86  ;;
+       i?86-*-linux*       ) SGE_LIBPATH=$SGE_PATH/lib/lx24-x86    ;;
+       i?86-*-solaris*:32  ) SGE_LIBPATH=$SGE_PATH/lib/sol-x86     ;;
+       i?86-*-solaris*:64  ) SGE_LIBPATH=$SGE_PATH/lib/sol-amd64   ;;
+       powerpc-*-darwin*   ) SGE_LIBPATH=$SGE_PATH/lib/darwin-ppc  ;;
+       sparc-*-solaris*:32 ) SGE_LIBPATH=$SGE_PATH/lib/sol-sparc   ;;
+       sparc-*-solaris*:64 ) SGE_LIBPATH=$SGE_PATH/lib/sol-sparc64 ;;
+       x86_64-*-linux*     ) SGE_LIBPATH=$SGE_PATH/lib/lx24-amd64  ;;
+    esac
+    NCBI_RPATHIFY(SGE_LIBPATH, $SGE_LIBPATH)
+ fi
+ NCBI_CHECK_THIRD_PARTY_LIB_EX(sge, SGE, drmaa,
+   [[AC_LANG_PROGRAM([[#include <sys/types.h>
+                       #include <drmaa.h>]],
+      [[char buf[1024]; drmaa_init("SGE", buf, sizeof(buf));]])]])
+ ### muParser
+ case "$with_muparser" in
+    yes | '' ) : ${MUPARSER_PATH=$NCBI/muParser} ;;
+    *        ) MUPARSER_PATH=$with_muparser ;;
+ esac
+ if test -d "$MUPARSER_PATH"; then
+    NCBI_FIX_DIR(MUPARSER_PATH)
+ fi
+ if test -d "$MUPARSER_PATH/${compiler_vpfx}${DEBUG_SFX}${bit64_sfx}/lib"; then
+    MUPARSER_LIBPATH=-L$MUPARSER_PATH/${compiler_vpfx}${DEBUG_SFX}${bit64_sfx}/lib
+ elif test -d "$MUPARSER_PATH/${compiler_pfx}${DEBUG_SFX}${bit64_sfx}/lib"; then
+    MUPARSER_LIBPATH=-L$MUPARSER_PATH/${compiler_pfx}${DEBUG_SFX}${bit64_sfx}/lib
+ fi
+ NCBI_CHECK_THIRD_PARTY_LIB(muparser,
+   [[AC_LANG_PROGRAM([[#include <muParser.h>]],
+      [[mu::Parser parser;]])]])
+ ### hdf5
+ case "$with_hdf5" in
+    yes | '' ) : ${HDF5_PATH=$NCBI/hdf5} ;;
+    *        ) HDF5_PATH=$with_hdf5 ;;
+ esac
+ if test -d "$HDF5_PATH/${compiler_vpfx}${DEBUG_SFX}${bit64_sfx}"; then
+    HDF5_PATH=$HDF5_PATH/${compiler_vpfx}${DEBUG_SFX}${bit64_sfx}
+ elif test -d "$HDF5_PATH/${compiler_pfx}${DEBUG_SFX}${bit64_sfx}"; then
+    HDF5_PATH=$HDF5_PATH/${compiler_pfx}${DEBUG_SFX}${bit64_sfx}
+ fi
+ if test -d "$HDF5_PATH"; then
+    NCBI_FIX_DIR(HDF5_PATH)
+ fi
+ NCBI_CHECK_THIRD_PARTY_LIB_EX(hdf5, HDF5, hdf5_cpp,
+   [[AC_LANG_PROGRAM([[#include <H5Cpp.h>]],
+      [[H5::H5Library::open();]])]],
+   [-lhdf5])
  ### Image libraries
- : ${JPEG_PATH=$NCBI/gd}
+ # : ${JPEG_PATH=/usr/sfw}
  # Grr... jpeglib.h isn't especially well-behaved.
  NCBI_CHECK_THIRD_PARTY_LIB(jpeg,
   AC_LANG_PROGRAM([#include <sys/types.h>
-Line 3131
+Line 5632
       cinfo.err = jpeg_std_error(&jerr);
   ]))
- : ${PNG_PATH=$NCBI/gd}
+ # : ${PNG_PATH=/usr/sfw}
  NCBI_CHECK_THIRD_PARTY_LIB(png,
   AC_LANG_PROGRAM([#include <png.h>],
      [png_structp png_ptr
        = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
-  ]), -lz)
+  ]), $Z_LIBS, [], $Z_INCLUDE)
- : ${TIFF_PATH=/usr/sfw}
+ # : ${TIFF_PATH=/usr/sfw}
  NCBI_CHECK_THIRD_PARTY_LIB(tiff,
   AC_LANG_PROGRAM([#include <tiffio.h>],
-     [TIFF* tiff = TIFFOpen("foo", "r");]), -lz)
+     [TIFF* tiff = TIFFOpen("foo", "r");]), $Z_LIBS, $JPEG_LIBS)
  ## etc.
  # Paths?
-Line 3163
+Line 5664
     GIF_LIBS=$UNGIF_LIBS
  fi
- test -n "$x_includes"  &&  : ${XPM_PATH=`dirname "$x_includes"`}
+ test -n "$x_libraries"  &&  : ${XPM_PATH=`dirname "$x_libraries"`}
  NCBI_CHECK_THIRD_PARTY_LIB(Xpm,
   AC_LANG_PROGRAM([#include <X11/xpm.h>],
      [XpmImage image; XpmInfo info;
-      XpmReadFileToXpmImage("foo", &image, &info);]), $X_LIBS -lX11)
+      XpmReadFileToXpmImage("foo", &image, &info);]), $X_LIBS -lX11, [],
+     $X_CFLAGS)
+ # The use of X_CFLAGS is probably redundant, but shouldn't hurt.
+ ## FreeType
+ if test "$with_freetype" != "no" ; then
+    : ${FREETYPE_BINPATH=$FREETYPE_PATH/bin}
+    AC_PATH_PROG(freetype_config, freetype-config, [],
+                 [$FREETYPE_BINPATH:$PATH])
+    if test -n "$freetype_config" ; then
+       : ${FREETYPE_BINPATH=`dirname $freetype_config`}
+       : ${FREETYPE_INCLUDE=`$freetype_config --cflags`}
+       NCBI_RPATHIFY_OUTPUT_COND(FREETYPE_LIBS, $freetype_config --libs,
+          [$no_usr_lib])
+       AC_CACHE_CHECK([whether FREETYPE_INCLUDE needs doctoring],
+                      ncbi_cv_lib_freetype_fix_include,
+          [CPPFLAGS="$FREETYPE_INCLUDE $orig_CPPFLAGS"
+           AC_COMPILE_IFELSE(
+              [AC_LANG_PROGRAM(
+                  [[#include <ft2build.h>]], [])],
+              [ncbi_cv_lib_freetype_fix_include=no],
+              [ncbi_cv_lib_freetype_fix_include=yes])])
+       if test "$ncbi_cv_lib_freetype_fix_include" = yes; then
+          FREETYPE_INCLUDE=`echo "$FREETYPE_INCLUDE" |\
+              sed -e 's:\(-I[[^ ]]*\)\(/freetype2\):\1 \1\2:g'`
+       fi
+       AC_CACHE_CHECK([whether FreeType works], ncbi_cv_lib_freetype,
+          [CPPFLAGS="$FREETYPE_INCLUDE $orig_CPPFLAGS"
+           LIBS="$FREETYPE_LIBS $orig_LIBS"
+           AC_LINK_IFELSE(
+              [AC_LANG_PROGRAM(
+                  [[#include <ft2build.h>
+                    #include FT_FREETYPE_H]],
+                  [[FT_Select_Charmap(NULL, ft_encoding_unicode);]])],
+              [ncbi_cv_lib_freetype=yes], [ncbi_cv_lib_freetype=no])])
+       if test "$ncbi_cv_lib_freetype" = no; then
+          NCBI_MISSING_PACKAGE(freetype)
+       fi
+    else
+       NCBI_MISSING_PACKAGE(freetype)
+    fi
+ fi
+ if test "$with_freetype" = "no" ; then
+    FREETYPE_PATH="No_FREETYPE"
+    FREETYPE_INCLUDE=
+    FREETYPE_LIBS=
+ else
+    NCBI_PACKAGE(FreeType)
+    AC_DEFINE(HAVE_FREETYPE, 1, [Define to 1 if FreeType is available.])
+ fi
  ### Restore original compiler/linker flags
  LIBS="$orig_LIBS"
-Line 3183
+Line 5734
  local_lbsm="ncbi_lbsm ncbi_lbsm_ipc ncbi_lbsmd"
- # The IPC stuff doesn't build on Cygwin or Darwin.
+ ## requires semaphores (lacking on older versions of Cygwin and Darwin)
- case "$host_os" in
+ if test $ncbi_cv_sys_semaphores = no; then
-   cygwin* | darwin* ) with_local_lbsm="no" ;;
+     NCBI_MISSING_PACKAGE(local-lbsm)
- esac
+ fi
+ ## disable by default even on newer Cygwin, as its semaphores don't
+ ## actually work very well
+ test $OSTYPE = cygwin  &&  : ${with_local_lbsm=no}
  for fff in $local_lbsm ; do
-    if test ! -f ${srcdir}/src/connect/${fff}.c ; then
+    if test ! -f ${real_srcdir}/src/connect/${fff}.c ; then
        if test "$with_local_lbsm" = "yes" ; then
-          AC_MSG_ERROR(["--with-local-lbsm:  src/connect/${fff}.c is  missing"])
+          AC_MSG_ERROR([--with-local-lbsm:  src/connect/${fff}.c is  missing])
        fi
        with_local_lbsm="no"
        break
-Line 3199
+Line 5753
  done
  if test "$with_local_lbsm" = "no" ; then
-    WithoutProjects="$WithoutProjects local_lbsm"
     local_lbsm="ncbi_lbsmd_stub"
  else
-    WithProjects="$WithProjects local_lbsm"
+    NCBI_PROJECT(local_lbsm)
+    AC_DEFINE(HAVE_LOCAL_LBSM, 1,
+              [Define to 1 if local LBSM support is available.])
  fi
- ## daemons under 'connect' don't build on Darwin (MacOS X)
+ ## `connext' support
- case "$host_os" in
-   darwin* ) daemons= ;;
-   *)        daemons="daemons" ;;
- esac
- ## `serial' projects
+ connext="ncbi_dblb ncbi_ifconf ncbi_localnet"
- if test "$with_serial" = "no" ; then
+ for fff in $connext ; do
-    NoConfProjects="$NoConfProjects serial"
+    if test ! -f ${real_srcdir}/src/connect/ext/${fff}.c ; then
+       if test "$with_connext" = "yes" ; then
+          AC_MSG_ERROR([--with-connext:  src/connect/ext/${fff}.c is missing])
+       fi
+       with_connext="no"
+       break
  fi
+ done
- if test ! -f ${srcdir}/src/serial/Makefile.in  -o  \
+ if test "$with_connext" = "no"; then
-         ! -d ${srcdir}/include/serial ; then
+    if test "$with_ncbi_crypt" = "yes" ; then
-    if test "$with_serial" = "yes" ; then
+       AC_MSG_ERROR([--with-ncbi-crypt specified, but CONNECT extensions are unavailable])
-       AC_MSG_ERROR(["--with-serial:  SERIAL sources are missing"])
     fi
-    with_serial="no"
+    with_ncbi_crypt=no
  fi
- if test "$with_serial" = "no" ; then
+ if test "$with_connext" = "no" ; then
-    WithoutProjects="$WithoutProjects serial"
+    CONNEXT=
-    serial=
+    XCONNEXT=
  else
-    WithProjects="$WithProjects serial"
+    NCBI_PROJECT(connext)
-    serial="serial"
+    CONNEXT=connext
+    XCONNEXT=xconnext
+    AC_DEFINE(HAVE_LIBCONNEXT, 1,
+       [Define to 1 if non-public CONNECT extensions are available.])
  fi
- ## `objects' projects
+ ## `ncbi_crypt' support
- if test "$with_objects" = "no" ; then
+ ncbi_crypt="ncbi_crypt"
-    NoConfProjects="$NoConfProjects objects"
+ for fff in $ncbi_crypt ; do
+    if test ! -f ${real_srcdir}/src/connect/ext/${fff}.c ; then
+       if test "$with_ncbi_crypt" = "yes" ; then
+          AC_MSG_ERROR([--with-ncbi-crypt:  src/connect/ext/${fff}.c is missing])
  fi
+       with_ncbi_crypt="no"
+       break
+    fi
+ done
- if test ! -f ${srcdir}/src/objects/Makefile.in  -o  \
+ if test "$with_ncbi_crypt" = "no" ; then
-         ! -d ${srcdir}/include/objects ; then
+    ncbi_crypt="ncbi_crypt_stub"
-    if test "$with_objects" = "yes" ; then
+ else
-       AC_MSG_ERROR(["--with-objects:  OBJECTS sources are missing"])
+    NCBI_PROJECT(ncbi_crypt)
+    AC_DEFINE(HAVE_NCBI_CRYPT, 1,
+       [Define to 1 if the real version of ncbi_crypt support is available.])
     fi
-    with_objects="no"
+ ## `serial' projects
+ if test "$with_serial" = "no" ; then
+    serial=
+ else
+    NCBI_PROJECT(serial)
+    serial="serial"
  fi
+ ## `objects' projects
  if test "$with_objects" = "no"  -o  -z "$serial" ; then
-    WithoutProjects="$WithoutProjects objects"
     objects=
  else
-    WithProjects="$WithProjects objects"
+    NCBI_PROJECT(objects)
     objects="objects"
  fi
  ## `bdb' projects
+ dnl NCBI_CHECK_SUBTREE(bdb)
  if test "$with_bdb" = "no" ; then
     NoConfProjects="$NoConfProjects bdb"
  fi
- if test ! -f ${srcdir}/src/bdb/Makefile.in  -o  ! -d ${srcdir}/include/bdb
+ if test ! -f ${real_srcdir}/src/db/bdb/Makefile.in  -o  \
- then
+         ! -d ${real_srcdir}/include/db/bdb ; then
-    if test "$with_bdb" = "yes" ; then
+    if test "${with_bdb-no}" != "no" ; then
-       AC_MSG_ERROR(["--with-bdb:  BDB sources are missing"])
+       AC_MSG_ERROR([--with-]bdb[:  ]BDB[ sources are missing])
     fi
     with_bdb="no"
  fi
  if test "$with_bdb" = "no" ; then
-    WithoutProjects="$WithoutProjects bdb"
     bdb=
+    BDB_LIB=
+    BDB_CACHE_LIB=
  else
-    WithProjects="$WithProjects bdb"
+    NCBI_PROJECT(bdb)
     bdb="bdb"
+    BDB_LIB="bdb"
+    AC_DEFINE(HAVE_BDB, 1,
+              [Define to 1 if NCBI C++ API for BerkeleyDB is available.])
+    bdb_cache="ncbi_xcache_bdb"
+    BDB_CACHE_LIB="ncbi_xcache_bdb"
+    AC_DEFINE(HAVE_BDB_CACHE, 1,
+              [Define to 1 if NCBI C++ API for BerkeleyDB based data cache is available.])
  fi
  ## `dbapi' projects
+ DBAPI_CTLIB=
+ DBAPI_DBLIB=
+ DBAPI_MYSQL=
+ DBAPI_ODBC=
  if test "$with_dbapi" = "no" ; then
-    NoConfProjects="$NoConfProjects dbapi"
- fi
- if test ! -f ${srcdir}/src/dbapi/Makefile.in  -o  \
-         ! -d ${srcdir}/include/dbapi ; then
-    if test "$with_dbapi" = "yes" ; then
-       AC_MSG_ERROR(["--with-dbapi:  DBAPI sources are missing"])
-    fi
-    with_dbapi="no"
- fi
- if test "$with_dbapi" = "no" ; then
-    WithoutProjects="$WithoutProjects dbapi"
     dbapi=
  else
-    WithProjects="$WithProjects dbapi"
+    NCBI_PROJECT(dbapi)
     dbapi="dbapi"
+    test -n "$SYBASE_LIBS"    &&  DBAPI_CTLIB=ncbi_xdbapi_ctlib
+    test -n "$SYBASE_DBLIBS"  &&  DBAPI_DBLIB=ncbi_xdbapi_dblib
+    test -n "$MYSQL_LIBS"     &&  DBAPI_MYSQL=ncbi_xdbapi_mysql
+    test -n "$ODBC_LIBS"      &&  DBAPI_ODBC=ncbi_xdbapi_odbc
  fi
  ## `app' projects
  if test "$with_app" = "no" ; then
-    NoConfProjects="$NoConfProjects app"
- fi
- if test ! -f ${srcdir}/src/app/Makefile.in  -o  \
-         ! -d ${srcdir}/include/app ; then
-    if test "$with_app" = "yes" ; then
-       AC_MSG_ERROR(["--with-app:  APP sources are missing"])
-    fi
-    with_app="no"
- fi
- if test "$with_app" = "no" ; then
-    WithoutProjects="$WithoutProjects app"
     app=
  else
-    WithProjects="$WithProjects app"
+    NCBI_PROJECT(app)
     app="app"
  fi
  ## `ctools' project cluster
- if test "$with_ctools" = "no" ; then
+ if test "$with_ctools" != "no" ; then
-    NoConfProjects="$NoConfProjects ctools"
+    NCBI_PROJECT(ctools)
- fi
- if test ! -f ${srcdir}/src/ctools/Makefile.in  -o  \
-         ! -d ${srcdir}/include/ctools  -o  "$with_ncbi_c" = "no"
- then
-    if test "$with_ctools" = "yes" ; then
-       if test "$with_ncbi_c" = "no" ; then
-          AC_MSG_ERROR(["--with-ctools:  NCBI C Toolkit is missing"])
-       else
-          AC_MSG_ERROR(["--with-ctools:  CTOOLS sources are missing"])
-       fi
-    fi
-    with_ctools="no"
- fi
- if test "$with_ctools" = "no" ; then
-    WithoutProjects="$WithoutProjects ctools"
- else
-    ctools="ctools"
-    OPT_GROUPS="$OPT_GROUPS ctools"
  fi
  ## `gui' projects
  if test "$with_gui" = "no" ; then
-    NoConfProjects="$NoConfProjects gui"
- fi
- if test ! -f ${srcdir}/src/gui/Makefile.in  -o  ! -d ${srcdir}/include/gui \
-     -o  "$with_fltk" = "no"
- then
-    if test "$with_gui" = "yes" ; then
-       if test "$with_fltk" = "no" ; then
-          AC_MSG_ERROR(["--with-gui:  FLTK package is missing"])
-       else
-          AC_MSG_ERROR(["--with-gui:  GUI sources are missing"])
-       fi
-    fi
-    with_gui="no"
- fi
- if test "$with_gui" = "no" ; then
-    WithoutProjects="$WithoutProjects gui"
     gui=
  else
-    WithProjects="$WithProjects gui"
+    NCBI_PROJECT(gui)
     gui="gui"
  fi
-Line 3386
+Line 5918
  ## `algo' projects
  if test "$with_algo" = "no" ; then
-    NoConfProjects="$NoConfProjects algo"
- fi
- if test ! -f ${srcdir}/src/algo/Makefile.in  -o  ! -d ${srcdir}/include/algo
- then
-    if test "$with_algo" = "yes" ; then
-       AC_MSG_ERROR(["--with-algo:  ALGO sources are missing"])
-    fi
-    with_algo="no"
- fi
- if test "$with_algo" = "no" ; then
-    WithoutProjects="$WithoutProjects algo"
     algo=
  else
-    WithProjects="$WithProjects algo"
+    NCBI_PROJECT(algo)
     algo="algo"
  fi
  ## `internal' project cluster
- if test "$with_internal" = "no"  -o  ! -f ${srcdir}/src/internal/Makefile.in \
+ if test "$with_internal" = "no"  \
-     -o  ! -d ${srcdir}/include/internal; then
+     -o  ! -f "${real_srcdir}/src/internal/Makefile.in"; then
     NoConfProjects="$NoConfProjects internal"
     internal=
  else
     reason=""
     sep=
+    if test ! -d "${real_srcdir}/include/internal"; then
+      reason="$reason${sep}headers"
+      sep=", "
+    fi
     if test "$with_sybase" = "no"; then
       reason="$reason${sep}Sybase"
       sep=", "
-Line 3427
+Line 5950
       reason="$reason${sep}SSS"
       sep=", "
     fi
-    if test "$with_pubmed" = "no"; then
-      reason="$reason${sep}PubMed"
-      sep=", "
-    fi
     if test -n "$reason" -a "$with_internal" = "yes"; then
        if test -z "$with_projects"  -o  "$with_projects" = "no"; then
-          AC_MSG_ERROR(["--with-internal:  Cannot build INTERNAL projects: missing $reason"])
+          AC_MSG_ERROR([--with-internal:  Cannot build INTERNAL projects: missing $reason])
        else
-          AC_MSG_WARN(["--with-internal:  Cannot build all INTERNAL projects: missing $reason"])
+          AC_MSG_WARN([--with-internal:  Cannot build all INTERNAL projects: missing $reason])
           OPT_GROUPS="$OPT_GROUPS internal"
           internal="internal"
        fi
-Line 3448
+Line 5967
     fi
  fi
+ ## Genome Workbench
+ if test "$with_gbench" != "no"  -a  -d "$real_srcdir/src/gui/app/gbench"; then
+    reason=""
+    sep=
+    if test -d "$real_srcdir/src/gui/packages"; then
+      if test "$with_wxwidgets" = "no"; then
+        reason="$reason${sep}wxWidgets"
+        sep=", "
+      fi
+    elif test -d "$real_srcdir/src/gui/plugins"; then
+      if test "$with_fltk" = "no"; then
+        reason="$reason${sep}FLTK"
+        sep=", "
+      fi
+    else
+      reason="$reason${sep}plugins or packages"
+      sep=", "
+    fi
+    if test "$with_opengl" = "no"; then
+      reason="$reason${sep}OpenGL"
+      sep=", "
+    fi
+    if test "$with_bdb" = "no"; then
+      reason="$reason${sep}Berkeley DB 4.3"
+      sep=", "
+    fi
+    if test "$with_mt" = "no"; then
+      reason="$reason${sep}multithreading"
+      sep=", "
+    fi
+    if test "$with_dll" != "yes"; then
+      reason="$reason${sep}full-DLL setup"
+      sep=", "
+    fi
+    # Anything else?
+    if test -n "$reason" -a "$with_gbench" = "yes"; then
+       AC_MSG_ERROR([--with-gbench:  Cannot build Genome Workbench: missing $reason])
+    elif test -z "$reason"; then
+       NCBI_PROJECT(gbench)
+    fi
+ fi
  ### Miscellanea
-Line 3472
+Line 6034
    ask) IF_REBUILDING_CONDITIONALLY="" ;;
  esac
- case "$with_projects" in
+ case "$with_deactivation" in
-  "") if test -r projects; then
+   no) IF_DEACTIVATING="#" ;;
-         AC_MSG_NOTICE([using default projects file "projects".])
+   * ) IF_DEACTIVATING=""  ;;
-         with_projects=projects
-         AC_SUBST(PROJECTS, "\$(top_srcdir)/projects")
-      else
-         AC_SUBST(PROJECTS, "")
-         if test -f projects; then
-            AC_MSG_WARN([default projects file "projects" is unreadable.])
-         elif test -h projects; then
-            AC_MSG_WARN([default projects file "projects" is a dangling link.])
-         fi
-      fi
-      ;;
-  no) with_projects="" ;  AC_SUBST(PROJECTS, "") ;;
-  /*) AC_SUBST(PROJECTS, $with_projects) ;;
-  * ) AC_SUBST(PROJECTS, "\$(top_srcdir)/$with_projects") ;;
  esac
+ case "$with_makefile_auto_update" in
+   no) configurables_mfname=configurables.null ;;
+   * ) configurables_mfname=configurables      ;;
+ esac
  # Run the test suite after the build?
-Line 3499
+Line 6051
     if test "$with_check" != "yes" ; then
        CHECK_ARG=`echo "$with_check" | sed 's/%/ /g'`
     fi
-    WithFeatures="$WithFeatures check"
+    NCBI_FEATURE(check)
  fi
+ CHECK_TOOLS=$with_check_tools
+ ### Compute Without{Features,Packages,Projects}.  Takes quadratic time,
+ ### but that's life.
+ m4_foreach(CATEGORY, [Features,Packages,Projects],
+   [for x in m4_indir([NCBI_ALL_]CATEGORY); do
+       case " [$With]CATEGORY " in
+          *" $x "*) ;;
+          *) [Without]CATEGORY="[$Without]CATEGORY[$Without]CATEGORY[Sep$x]"
+             [Without]CATEGORY[Sep]=" "
+           ;;
+       esac
+    done
+   ])
  ### Cleanup
  ### ---------------------------------
-Line 3539
+Line 6104
  case "$CXXCPP" in compilers/*) CXXCPP="\$(top_srcdir)/$CXXCPP" ;; esac
  case "$AR"     in compilers/*)     AR="\$(top_srcdir)/$AR"     ;; esac
- ### Get Insure++ to honor the top-level .psrc file
+ ### Get Insure++ to honor the Toolkit's psrc file
  case "$CC" in
     */insure*)
-       CC="$CC -Zop \$(top_srcdir)/.psrc -D__INSURE__"
+       CC="$CC -Zop \$(top_srcdir)/compilers/unix/psrc -D__INSURE__"
-       CXX="$CXX -Zop \$(top_srcdir)/.psrc -D__INSURE__"
+       CXX="$CXX -Zop \$(top_srcdir)/compilers/unix/psrc -D__INSURE__"
-       CXXCPP="$CXXCPP -Zop \$(top_srcdir)/.psrc -D__INSURE__"
+       CXXCPP="$CXXCPP -Zop \$(top_srcdir)/compilers/unix/psrc -D__INSURE__"
-       LINK_DLL=`echo "$LINK_DLL" | sed -e 's:insure:& -Zop \$(top_srcdir)/.psrc:'`
+       LINK_DLL=`echo "$LINK_DLL" | sed -e 's:insure:& -Zop \$(top_srcdir)/compilers/unix/psrc:'`
     ;;
  esac
-Line 3556
+Line 6121
  ### Compose their target counterparts
  ### Configure
- AC_MSG_NOTICE([looking for configurables below $srcdir...])
+ AC_MSG_NOTICE([looking for configurables below $real_srcdir...])
- excl_file="`pwd`/config.tmp.$$"
+ tmp_sed="`pwd`/config.tmp.$$"
- changequote(<<, >>)dnl
+ for x in $NoConfProjects dll; do
- echo "NoConfProjects $NoConfProjects" | sed 's% \([^ ][^ ]*\)%\
+    echo "/^\\.\\/$x/d"
- ^\\./\1/%g' > $excl_file
+ done > $tmp_sed
- changequote([, ])dnl
+ cat >>$tmp_sed <<EOF
- configurables=`cd "${srcdir}/src"  &&  find . -name '*.in' -print | $EGREP -v -f $excl_file | sed "s%\.\(.*\)\.in%$builddir\1:\./src\1\.in%g"`
+ s%^.\\(/build-system.*/Makefile*\\)\\.in\$%$builddir\\1:./src\\1\\.in%
- rm $excl_file
+ s%^.\\(/build-system\\)\\(/.*\\)\\.in\$%$builddir\\2:./src\\1\\2\\.in%
+ s%^.\\(/[[^:]]*\\)\\.in\$%$builddir\\1:./src\\1\\.in%
+ EOF
+ cat $tmp_sed >&AS_MESSAGE_LOG_FD
+ configurables=`cd "${real_srcdir}/src"  &&  find . -name '.svn' -prune -o -name '*.in' -print | sed -f $tmp_sed`
+ rm $tmp_sed
  if test -z "$configurables" ; then
-   AC_MSG_ERROR([cannot find any configurables below "${srcdir}"!])
+   AC_MSG_ERROR([cannot find any configurables below "${real_srcdir}"!])
  else
    AC_MSG_NOTICE([...done])
  fi
-Line 3581
+Line 6151
  AC_SUBST(top_srcdir)
  AC_SUBST(srcdir)
+ #AC_SUBST(real_srcdir)
  AC_SUBST(includedir)
  AC_SUBST(status_dir)
  AC_SUBST(builddir)
-Line 3595
+Line 6166
  AC_SUBST(STRIP)
  AC_SUBST(LINK)
  AC_SUBST(C_LINK)
+ AC_SUBST(TAIL_N)
+ AC_SUBST(EGREP_Q)
  AC_SUBST(CFLAGS)
  AC_SUBST(FAST_CFLAGS)
-Line 3605
+Line 6178
  AC_SUBST(DEPFLAGS_POST)
  AC_SUBST(LDFLAGS)
  AC_SUBST(FAST_LDFLAGS)
+ AC_SUBST(APP_LDFLAGS)
+ AC_SUBST(DLL_LDFLAGS)
  AC_SUBST(LIBS)
  AC_SUBST(C_LIBS)
+ AC_SUBST(GCCPCH)
+ AC_SUBST(RUNPATH_ORIGIN)
  AC_SUBST(D_SFX)
  AC_SUBST(DEBUG_SFX)
  AC_SUBST(LIB_OR_DLL)
  AC_SUBST(FORCE_STATIC_LIB)
+ AC_SUBST(APP_LIB_SETTING)
+ AC_SUBST(APP_LIBS_SETTING)
  AC_SUBST(LINK_DLL)
  AC_SUBST(has_dll_loadable)
  AC_SUBST(LINK_LOADABLE)
  AC_SUBST(CFLAGS_DLL)
  AC_SUBST(CXXFLAGS_DLL)
+ AC_SUBST(ALLOW_UNDEF)
+ AC_SUBST(FORBID_UNDEF)
  AC_SUBST(OPT_GROUPS)
  AC_SUBST(local_lbsm)
- AC_SUBST(daemons)
+ AC_SUBST(ncbi_crypt)
+ AC_SUBST(CONNEXT)
+ AC_SUBST(XCONNEXT)
  AC_SUBST(serial)
  AC_SUBST(bdb)
  AC_SUBST(dbapi)
  AC_SUBST(objects)
- AC_SUBST(ctools)
  AC_SUBST(gui)
  AC_SUBST(algo)
  AC_SUBST(app)
-Line 3634
+Line 6216
  AC_SUBST(check)
  AC_SUBST(CHECK_ARG)
+ AC_SUBST(CHECK_TOOLS)
  AC_SUBST(script_shell)
  AC_SUBST(make_shell)
-Line 3652
+Line 6235
  AC_SUBST(f_runpath)
  AC_SUBST(f_outexe)
+ AC_SUBST(BDB_LIB)
+ AC_SUBST(BDB_CACHE_LIB)
+ AC_SUBST(DBAPI_CTLIB)
+ AC_SUBST(DBAPI_DBLIB)
+ AC_SUBST(DBAPI_MYSQL)
+ AC_SUBST(DBAPI_ODBC)
  AC_SUBST(THREAD_LIBS)
+ AC_SUBST(NCBIATOMIC_LIB)
  AC_SUBST(NETWORK_LIBS)
  AC_SUBST(NETWORK_PURE_LIBS)
  AC_SUBST(RESOLVER_LIBS)
-Line 3662
+Line 6253
  AC_SUBST(CRYPT_LIBS)
  AC_SUBST(DL_LIBS)
  AC_SUBST(RT_LIBS)
+ AC_SUBST(UUID_LIBS)
+ AC_SUBST(DEMANGLE_LIBS)
  AC_SUBST(ICONV_LIBS)
+ AC_SUBST(Z_LIB)
+ AC_SUBST(BZ2_LIB)
+ AC_SUBST(PCREPOSIX_LIBS)
+ AC_SUBST(PCRE_LIB)
+ AC_SUBST(OPENSSL_STATIC_LIBS)
+ AC_SUBST(TLS_INCLUDE)
+ AC_SUBST(TLS_LIBS)
  AC_SUBST(SYBASE_PATH)
+ AC_SUBST(SYBASE_LCL_PATH)
  AC_SUBST(SYBASE_INCLUDE)
  AC_SUBST(SYBASE_LIBS)
  AC_SUBST(SYBASE_DLLS)
-Line 3671
+Line 6272
  AC_SUBST(MYSQL_INCLUDE)
  AC_SUBST(MYSQL_LIBS)
  AC_SUBST(BERKELEYDB_INCLUDE)
- AC_SUBST(BERKELEYDB_STATIC_LIBS)
  AC_SUBST(BERKELEYDB_LIBS)
+ AC_SUBST(BERKELEYDB_STATIC_LIBS)
+ AC_SUBST(BERKELEYDB_CXX_LIBS)
+ AC_SUBST(BERKELEYDB_CXX_STATIC_LIBS)
  AC_SUBST(ODBC_INCLUDE)
  AC_SUBST(ODBC_LIBS)
+ AC_SUBST(CPPUNIT_INCLUDE)
+ AC_SUBST(CPPUNIT_LIBS)
+ AC_SUBST(BOOST_INCLUDE)
+ AC_SUBST(BOOST_LIBPATH)
+ AC_SUBST(BOOST_TAG)
+ AC_SUBST(BOOST_REGEX_LIBS)
+ AC_SUBST(BOOST_REGEX_STATIC_LIBS)
+ AC_SUBST(BOOST_TEST_PEM_LIBS)
+ AC_SUBST(BOOST_TEST_PEM_STATIC_LIBS)
+ AC_SUBST(BOOST_TEST_TEM_LIBS)
+ AC_SUBST(BOOST_TEST_TEM_STATIC_LIBS)
+ AC_SUBST(BOOST_TEST_UTF_LIBS)
+ AC_SUBST(BOOST_TEST_UTF_STATIC_LIBS)
+ AC_SUBST(BOOST_THREAD_LIBS)
+ AC_SUBST(BOOST_THREAD_STATIC_LIBS)
  AC_SUBST(NCBI_C_INCLUDE)
  AC_SUBST(NCBI_C_LIBPATH)
  AC_SUBST(OPENGL_INCLUDE)
  AC_SUBST(OPENGL_LIBS)
+ AC_SUBST(OPENGL_STATIC_LIBS)
  AC_SUBST(OSMESA_INCLUDE)
  AC_SUBST(OSMESA_LIBS)
+ AC_SUBST(OSMESA_STATIC_LIBS)
  AC_SUBST(GLUT_INCLUDE)
  AC_SUBST(GLUT_LIBS)
  AC_SUBST(FLTK_INCLUDE)
  AC_SUBST(FLTK_LIBS)
  AC_SUBST(FLTK_LIBS_GL)
+ AC_SUBST(FLTK_LIBS_IMAGES)
+ AC_SUBST(FLTK_LIBS_ALL)
+ AC_SUBST(FLTK_STATIC_LIBS)
+ AC_SUBST(FLTK_STATIC_LIBS_GL)
+ AC_SUBST(FLTK_STATIC_LIBS_IMAGES)
+ AC_SUBST(FLTK_STATIC_LIBS_ALL)
  AC_SUBST(FLTK_CONFIG)
  AC_SUBST(WXWIN_INCLUDE)
  AC_SUBST(WXWIN_LIBS)
+ AC_SUBST(WXWIN_STATIC_LIBS)
  AC_SUBST(WXWIN_GL_LIBS)
+ AC_SUBST(WXWIN_GL_STATIC_LIBS)
+ AC_SUBST(WXWIN_POST_LINK)
+ AC_SUBST(WXWIDGETS_INCLUDE)
+ AC_SUBST(WXWIDGETS_LIBS)
+ AC_SUBST(WXWIDGETS_STATIC_LIBS)
+ AC_SUBST(WXWIDGETS_GL_LIBS)
+ AC_SUBST(WXWIDGETS_GL_STATIC_LIBS)
+ AC_SUBST(WXWIDGETS_POST_LINK)
  AC_SUBST(FASTCGI_INCLUDE)
  AC_SUBST(FASTCGI_LIBS)
  AC_SUBST(FASTCGI_OBJS)
-Line 3697
+Line 6332
  AC_SUBST(NCBI_SSS_LIBPATH)
  AC_SUBST(LIBSSSUTILS)
  AC_SUBST(LIBSSSDB)
- AC_SUBST(NCBI_GEO_INCLUDE)
- AC_SUBST(NCBI_GEO_LIBPATH)
- AC_SUBST(LIBGEODB)
  AC_SUBST(SP_INCLUDE)
  AC_SUBST(SP_LIBS)
- AC_SUBST(NCBI_PM_PATH)
  AC_SUBST(ORBACUS_INCLUDE)
  AC_SUBST(ORBACUS_LIBPATH)
  AC_SUBST(LIBOB)
  AC_SUBST(LIBIMR)
+ AC_SUBST(ICU_CONFIG)
+ AC_SUBST(ICU_INCLUDE)
+ AC_SUBST(ICU_LIBS)
+ AC_SUBST(ICU_STATIC_LIBS)
+ AC_SUBST(EXPAT_STATIC_LIBS)
+ AC_SUBST(SABLOT_STATIC_LIBS)
+ AC_SUBST(LIBXML_STATIC_LIBS)
+ AC_SUBST(LIBXSLT_STATIC_LIBS)
+ AC_SUBST(XERCES_INCLUDE)
+ AC_SUBST(XERCES_LIBS)
+ AC_SUBST(XERCES_STATIC_LIBS)
+ AC_SUBST(XALAN_INCLUDE)
+ AC_SUBST(XALAN_LIBS)
+ AC_SUBST(XALAN_STATIC_LIBS)
+ AC_SUBST(SQLITE3_STATIC_LIBS)
+ AC_SUBST(FREETYPE_INCLUDE)
+ AC_SUBST(FREETYPE_LIBS)
+ AC_SUBST(ncbi_xreader_pubseqos)
+ AC_SUBST(ncbi_xreader_pubseqos2)
+ AC_SUBST(UNLESS_PUBSEQOS)
  AC_SUBST(NCBI_C_ncbi)
-Line 3715
+Line 6366
  AC_SUBST(APP_OR_NULL)
  AC_SUBST(IF_REBUILDING_LIBS)
  AC_SUBST(IF_REBUILDING_CONDITIONALLY)
+ AC_SUBST(IF_DEACTIVATING)
+ AC_SUBST(configurables_mfname)
  AC_SUBST(CC_FILTER)
  AC_SUBST(CXX_FILTER)
  AC_SUBST(AR_FILTER)
-Line 3759
+Line 6412
  ncbicfg="$builddir/corelib/ncbicfg.c"
  test -f "$ncbicfg" -a ! -f "$ncbicfg.last" && cp -p "$ncbicfg" "$ncbicfg.last"
+ test -d "$status_dir"  ||  mkdir -p "$status_dir"
+ CONFIG_STATUS=$status_dir/config.status
  ## Configure the compiler/flag-dependent header
- AC_CONFIG_HEADER(${ncbiconf}:config.h.in)
+ AC_CONFIG_HEADER(${ncbiconf}:src/build-system/config.h.in)
  ##
  ## Configure makefiles, shell scripts, etc.
  ##
- AC_CONFIG_FILES($configurables $srcdir/./Makefile:Makefile.in)
+ AC_CONFIG_FILES($configurables $srcdir/./Makefile:src/build-system/Makefile.in.top)
  AC_CONFIG_COMMANDS([default], [
- status_dir="$SAVE_status_dir"
- builddir="$SAVE_builddir"
- build_root="$SAVE_build_root"
- x_configurables="$SAVE_x_configurables"
- ncbiconf="$SAVE_ncbiconf"
- CFLAGS="$SAVE_CFLAGS"
- CXXFLAGS="$SAVE_CXXFLAGS"
- CPPFLAGS="$SAVE_CPPFLAGS"
- LDFLAGS="$SAVE_LDFLAGS"
- LIB_OR_DLL="$SAVE_LIB_OR_DLL"
- with_dll="$SAVE_with_dll"
- WithFeatures="$SAVE_WithFeatures"
- WithPackages="$SAVE_WithPackages"
- WithoutPackages="$SAVE_WithoutPackages"
- WithProjects="$SAVE_WithProjects"
- WithoutProjects="$SAVE_WithoutProjects"
- with_extra_action="$SAVE_with_extra_action"
- with_projects="$SAVE_with_projects"
  dnl make all shell scripts *.sh be executable
  find "$build_root/." -name '*.sh' -print | while read x_file ; do
     chmod a+x "$x_file"
  done
- dnl save status, cache, and log files to the build tree dir "status/"
+ dnl save cache and log files to the build tree dir "status/"
- if test -f config.status -a -f config.cache -a -f config.log ; then
+ dnl (alongside config.status, which is now directly created there to
+ dnl avoid possible trouble; for that matter, it can be at least as
+ dnl important to avoid having config.log still open for writing during
+ dnl the move).
+ if test -f config.cache -a -f config.log ; then
     test -d  "$status_dir"  ||  mkdir -p "$status_dir"
-    mv config.status config.cache config.log "$status_dir"/
+    exec AS_MESSAGE_LOG_FD>/dev/null
+    mv config.cache config.log "$status_dir"/
+    exec AS_MESSAGE_LOG_FD>>"$status_dir/config.log"
  fi
  dnl Update list of enabled packages
-Line 3803
+Line 6446
  for p in $WithPackages $WithProjects $WithFeatures ; do
     touch "$status_dir"/$p.enabled
  done
+ for p in $WithoutPackages $WithoutProjects $WithoutFeatures ; do
+    touch "$status_dir"/-$p.enabled
+ done
+ dnl Create dummy .dep files for system installations of (b)zlib.
+ dnl This is a stopgap measure, and fails for installations in non-system dirs.
+ # test -f "$status_dir"/LocalZ.enabled  ||  \
+ #    touch -t 197001010000 $status_dir/.z.dep
+ # test -f "$status_dir"/LocalBZ2.enabled  ||  \
+ #    touch -t 197001010000 $status_dir/.bz2.dep
+ dnl Incorporate any Makefile.*.mk and ncbiconf.*.h files found in the tree.
+ find "$srcdir"/src/* -name .svn -prune -o -name 'Makefile.*.mk' -print \
+    | while read x; do
+       echo
+       echo "### Extra macro definitions from $x"
+       echo
+       echo "#line 1 \"$x\""
+       cat "$x"
+    done >> "$builddir/Makefile.mk"
+ $srcdir/scripts/common/impl/report_duplicates.awk \
+    src="$srcdir/src/build-system/Makefile.mk.in" "$builddir/Makefile.mk"
+ find "$srcdir"/src/* -name .svn -prune -o -name 'ncbiconf.*.h' -print \
+    | while read x; do
+       echo
+       echo "/*** Extra macro definitions from $x ***/"
+       echo
+       echo "#line 1 \"$x\""
+       cat "$x"
+    done > "$build_root/inc/ncbiconf_extra.h"
+ if test -s "$build_root/inc/ncbiconf_extra.h"; then
+    ncbiconf=$build_root/inc/ncbiconf_unix.h
+    newconf=$ncbiconf.extra.new
+    savedconf=$ncbiconf.extra.prev
+    cat "$ncbiconf" "$build_root/inc/ncbiconf_extra.h" > "$newconf"
+    $srcdir/scripts/common/impl/report_duplicates.awk \
+       src="$srcdir/src/build-system/config.h.in" "$newconf"
+    if test -f "$savedconf"  &&  cmp "$newconf" "$savedconf" >/dev/null; then
+       echo "$ncbiconf is unchanged"
+    else
+       cp -p "$newconf" "$savedconf"
+    fi
+    cp -p "$savedconf" "$ncbiconf"
+ else
+    rm "$build_root/inc/ncbiconf_extra.h"
+ fi
  dnl Avoid gratuitous relinking
  ncbicfg="$builddir/corelib/ncbicfg.c"
-Line 3817
+Line 6506
     echo "$ncbicfg" is not present
  fi
+ dnl Create Makefile.flat if requested
+ if test "$with_configure_dialog" = yes; then
+    if test "$with_flat_makefile" = no; then
+       AC_MSG_ERROR([incompatible options: --without-flat-makefile but --with-configure-dialog.])
+    fi
+    with_flat_makefile=yes
+ elif test "${with_saved_settings:-no}" != no; then
+    if test "$with_flat_makefile" = no; then
+       AC_MSG_ERROR([incompatible options: --without-flat-makefile but --with-saved-settings.])
+    fi
+    with_flat_makefile=yes
+ fi
+ if test "$with_flat_makefile" != "no"; then
+    if test "$with_flat_makefile" = yes; then
+       cfm_flags=''
+    else
+       cfm_flags='-remoteptb'
+    fi
+    case "$with_projects" in
+       yes     ) cfm_flags="$cfm_flags -p projects" ;;
+       no | '' ) ;;
+       *       ) cfm_flags="$cfm_flags -p $with_projects" ;;
+    esac
+    if test "$with_configure_dialog" = yes; then
+       cfm_flags="$cfm_flags -cfg"
+    fi
+    if test "${with_saved_settings-no}" != no; then
+       cfm_flags="$cfm_flags -saved $with_saved_settings"
+    fi
+    if $real_srcdir/scripts/common/impl/create_flat_makefile.sh "$build_root" \
+        -s "$real_srcdir" $cfm_flags  &&  test -f "$builddir/Makefile.flat"; then
+       build_flat="Alternatively, cd $builddir && make -f Makefile.flat"
+    elif test -f "$builddir/Flat.configuration_log"; then
+       grep 'already defined' "$builddir/Flat.configuration_log"
+       AC_MSG_ERROR([flat makefile generation failed.])
+    fi
+ fi
  dnl execute extra-action
  if test -n "$with_extra_action" ; then
     with_extra_action=`echo "$with_extra_action" | sed "s%{}%$build_root%g"`
-Line 3825
+Line 6552
     eval $with_extra_action
     exit_code="$?"
     if test $exit_code -ne 0 ; then
-       echo "WARNING! non-zero exit code ($exit_code):  $with_extra_action"
+       AC_MSG_WARN([non-zero exit code ($exit_code):  $with_extra_action])
     fi
     echo
  fi
-Line 3872
+Line 6599
  To build everything:  cd $builddir && make all_r
  or simply run make in the current directory
  $build_proj
+ $build_flat
  ******* CONFIGURATION SUCCESSFUL *******
  EOCONF
  ], [
- SAVE_status_dir='$status_dir'
+ status_dir='$status_dir'
- SAVE_builddir='$builddir'
+ builddir='$builddir'
- SAVE_build_root='$build_root'
+ build_root='$build_root'
- SAVE_x_configurables='$x_configurables'
+ x_configurables='$x_configurables'
- SAVE_ncbiconf='$ncbiconf'
+ ncbiconf='$ncbiconf'
- SAVE_CFLAGS='$CFLAGS'
+ CFLAGS='$CFLAGS'
- SAVE_CXXFLAGS='$CXXFLAGS'
+ CXXFLAGS='$CXXFLAGS'
- SAVE_CPPFLAGS='$CPPFLAGS'
+ CPPFLAGS='$CPPFLAGS'
- SAVE_LDFLAGS='$LDFLAGS'
+ LDFLAGS='$LDFLAGS'
- SAVE_LIB_OR_DLL='$LIB_OR_DLL'
+ LIB_OR_DLL='$LIB_OR_DLL'
- SAVE_with_dll='$with_dll'
+ with_dll='$with_dll'
- SAVE_WithFeatures='$WithFeatures'
+ WithFeatures='$WithFeatures'
- SAVE_WithPackages='$WithPackages'
+ WithoutFeatures='$WithoutFeatures'
- SAVE_WithoutPackages='$WithoutPackages'
+ WithPackages='$WithPackages'
- SAVE_WithProjects='$WithProjects $OPT_GROUPS'
+ WithoutPackages='$WithoutPackages'
- SAVE_WithoutProjects='$WithoutProjects'
+ WithProjects='$WithProjects $OPT_GROUPS'
- SAVE_with_extra_action='$with_extra_action'
+ WithoutProjects='$WithoutProjects'
- SAVE_with_projects='$with_projects'
+ with_extra_action='$with_extra_action'
+ with_projects='$with_projects'
+ with_flat_makefile='$with_flat_makefile'
+ with_configure_dialog='$with_configure_dialog'
+ with_saved_settings='$with_saved_settings'
+ smart_pwd='$smart_pwd'
+ real_srcdir='$real_srcdir'
  ])
+ AC_WARNING([*** Please don't forget to update .../src/build-system/NEWS if appropriate! ***])dnl
  AC_OUTPUT

 Legend:



Removed from v.12408
 


changed lines


 
Added in v.45256
 Legend:



Removed from v.12408
 


changed lines


 
Added in v.45256
-Removed from v.12408
+Added in v.45256

NCBI Systems Team">NCBI Systems Team	ViewVC Help
Powered by ViewVC 1.1.20

HHS Vulnerability Disclosure