diff options
Diffstat (limited to 'TAO/configure.in')
-rw-r--r-- | TAO/configure.in | 664 |
1 files changed, 664 insertions, 0 deletions
diff --git a/TAO/configure.in b/TAO/configure.in new file mode 100644 index 00000000000..609ceadb091 --- /dev/null +++ b/TAO/configure.in @@ -0,0 +1,664 @@ +dnl +dnl $Id$ + +AC_REVISION($Revision 0.6 $)dnl + +dnl +dnl An autoconf script to automatically configure TAO. +dnl Process this file with autoconf to produce a configure script. +dnl + +dnl +dnl The autoconf documentation states that this is the recommended +dnl sequence for this file: +dnl +dnl `AC_INIT(FILE)' +dnl checks for programs +dnl checks for libraries +dnl checks for header files +dnl checks for typedefs +dnl checks for structures +dnl checks for variables +dnl checks for compiler characteristics +dnl checks for library functions +dnl checks for system services +dnl `AC_OUTPUT([FILE...])' +dnl +dnl I followed this convention, and added a few sections. +dnl -- Gonzo + + +dnl +dnl SECTION 1: `AC_INIT(FILE)' +dnl +dnl This macro must be the very first invoked. +dnl Its argument names a file that must exist in the directory where +dnl autoconf will run, just to check things. +dnl AC_INIT(ace_unique.m4) +dnl +AC_INIT(tao/TAO.cpp) + +dnl Require GNU Autoconf 2.13 or better. +AC_PREREQ(2.13) + +dnl Check what platform we are running on. +AC_CANONICAL_SYSTEM + +dnl Allow the standard program name transformations. +dnl We probably don't need AC_ARG_PROGRAM any longer since AM_INIT_AUTOMAKE +dnl handles this functionality. -- Ossama +dnl AC_ARG_PROGRAM + +dnl Cause GNU Automake to initialize the state of things and run +dnl some sanity checks +TAO_PACKAGE="tao" +dnl Temporarily change M4 quotes to prevent "regex []" from being eaten +changequote(, )dnl +TAO_VERSION=`head -1 ${srcdir}/VERSION | sed 's/.*version \([0-9.]*\).*/\1/'` +changequote([, ])dnl + +AM_INIT_AUTOMAKE("$TAO_PACKAGE", "$TAO_VERSION", DUMMY) + +dnl Generate a header file with all settings. +dnl AM_CONFIG_HEADER(tao/config.h) + +dnl Move before the AC_ARG_ENABLE stuff to prevent autoconf complaints. +dnl This is a bit messy but it makes life easier for me. +dnl -Ossama +dnl +dnl SECTION: checks for programs +dnl + +dnl Check if system supports "#! /bin/sh" line in scripts +AC_SYS_INTERPRETER + + +dnl Check for ace-config script +AC_CHECK_PROG(ACE_CONFIG, ace-config, ace-config,) dnl +if test -z "$ACE_CONFIG"; then + AC_MSG_WARN(ace-config script not found) + AC_MSG_WARN(TAO may not find all of the necessary ACE related libraries) +fi + +dnl Check the C compiler and preprocessor. +AC_PROG_CC +AC_PROG_CPP +AC_PROG_CC_C_O + +dnl The C++ compiler used to compile TAO must be the same as the one +dnl used to compile ACE. +if test -n $ACE_CONFIG; then + CXX=`$ACE_CONFIG --cxx ace` +fi + +dnl Check the C++ compiler and preprocessor. +AC_PROG_CXX +AC_PROG_CXXCPP + +dnl Disable building of static libraries by default +AC_DISABLE_STATIC + +dnl Enable Libtool module support +AC_LIBTOOL_DLOPEN + +dnl FIXME: Temporary hack to make libtool work with g++. +dnl Shared library support will only work with GNU g++ and GNU ld +dnl right now. +save_CC="$CC" +CC="$CXX" + +dnl Check for libtool and turn on Automake processing for Libtool +AM_PROG_LIBTOOL + +CC="$save_CC" + + +dnl This checks for a binary called gm4, gnum4 or m4, and assigns +dnl whatever was found (or "gonzo") to the M4 macro. +dnl AC_CHECK_PROGS(M4, gm4 gnum4 m4, gonzo) + +dnl Look for the best awk-style program available. +AC_PROG_AWK + +dnl Set some version information +TAO_CURRENT="0" +TAO_AGE="0" +TAO_REVISION="0" + +if test -n "$AWK"; then + TAO_MAJOR=`echo "$TAO_VERSION" | sed 's/\./ /g' | $AWK '{ print \[$]1 }'` + TAO_MINOR=`echo "$TAO_VERSION" | sed 's/\./ /g' | $AWK '{ print \[$]2 }'` + TAO_BETA=`echo "$TAO_VERSION" | sed 's/\./ /g' | $AWK '{ print \[$]3 }'` + +dnl This is a terrible kludge to fool libtool into making it produce a shared +dnl library with the "right" version information. +dnl We really should switch to a version scheme that is compatible with +dnl libtool. +dnl -Ossama + TAO_CURRENT=`expr $TAO_MAJOR + $TAO_MINOR` + TAO_AGE=$TAO_MINOR + TAO_REVISION=$TAO_BETA +fi + +AC_SUBST(TAO_CURRENT) +AC_SUBST(TAO_AGE) +AC_SUBST(TAO_REVISION) + +dnl Do the usual install settings; don't forget to include a +dnl install-sh script, in case the is no BDS compatible install +dnl installed (no pun intended) in your machine. +dnl +dnl We don't need this anymore since AM_INIT_AUTOMAKE calls AM_PROG_INSTALL +dnl yes "AM_PROG_INSTALL," not "AC_PROG_INSTALL." -- Ossama +dnl AC_PROG_INSTALL + +dnl Special handling for some UNIX variants and Cygwin32 +AC_AIX +AC_ISC_POSIX +AC_MINIX +AC_CYGWIN + +dnl The user's/default C++ flags are stored in "CXXFLAGS." We use +dnl the variable "TAO_CXXFLAGS" to set the C++ flags we want. At the end +dnl of the configuration process we combine TAO_CXXFLAGS and CXXFLAGS +dnl into CXXFLAGS (e.g., CXXFLAGS="$TAO_CXXFLAGS $CXXFLAGS"). CXXFLAGS +dnl goes after TAO_CXXFLAGS so that the user's C++ flag command line +dnl choices always override the configure script's choices. +TAO_CXXFLAGS="" +TAO_CFLAGS="" + +dnl Set the test language as C++ +AC_LANG_CPLUSPLUS + +dnl Check if we support symlinks +AC_PROG_LN_S + +dnl Check if a lexical analyzer exists (lex, flex, etc.) +AM_PROG_LEX + +dnl Check if some implementation of YACC exists (yacc, byacc, bison, etc.) +AC_PROG_YACC +dnl if test -z "$YACC"; then +dnl ./missing yacc +dnl fi + +dnl We actually check for this in the user AC_ARG_WITH(--with-gperf) +dnl block since it is more convenient to put it there. +dnl Check for gperf program +dnl AC_CHECK_PROGS(GPERF, gperf-ace gperf,) dnl + +dnl Check for profiling progam +AC_CHECK_PROGS(PROF, gprof prof,) dnl + + +dnl +dnl SECTION 2: Configure script command line options +dnl +AC_ARG_ENABLE(fast, + [ --enable-fast enable -fast flag, e.g. Sun C++ [default=no]], + [ + case "${enableval}" in + yes) + TAO_CXXFLAGS="$TAO_CXXFLAGS -fast" + TAO_CFLAGS="$TAO_CFLAGS -fast" + ;; + no) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-fast) + ;; + esac + ],) + +AC_ARG_ENABLE(messaging, + [ --enable-messaging enable CORBA messaging support [default=yes]], + [ + case "${enableval}" in + yes) + AC_DEFINE(TAO_HAS_CORBA_MESSAGING) + ;; + no) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-messaging) + ;; + esac + ], + [ + AC_DEFINE(TAO_HAS_CORBA_MESSAGING) + ]) + +AC_ARG_ENABLE(minimum-corba, + [ --enable-minimum-corba enable minimum CORBA support [default=no]], + [ + case "${enableval}" in + yes) + AC_DEFINE(TAO_HAS_MINIMUM_CORBA) + ;; + no) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-minimum-corba) + ;; + esac + ],) + +AC_ARG_ENABLE(optimize, + [ --enable-optimize enable additional optimizations [default=no]], + [ + case "${enableval}" in + yes) + AC_MSG_WARN(Optimization configure support not implemented yet.) + ;; + no) + AC_MSG_WARN(Optimization configure support not implemented yet.) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-optimize) + ;; + esac + ],) + +AC_ARG_ENABLE(profile, + [ --enable-profile enable profiling [default=no]], + [ + case "${enableval}" in + yes) + if test -z "$PROF"; then + AC_MSG_WARN(No profiling program found. Assuming 'prof' exists) + TAO_CXXFLAGS="$TAO_CXXFLAGS -p" + TAO_CFLAGS="$TAO_CFLAGS -p" + else + case "$PROF" in + gprof) + echo "Building with 'gprof' support" + TAO_CXXFLAGS="$TAO_CXXFLAGS -pg" + TAO_CFLAGS="$TAO_CFLAGS -pg" + ;; + prof) + echo "Building with 'prof' support" + TAO_CXXFLAGS="$TAO_CXXFLAGS -p" + TAO_CFLAGS="$TAO_CFLAGS -p" + ;; + *) + dnl We shouldn't get here. + AC_MSG_WARN(Assuming 'prof' exists) + TAO_CXXFLAGS="$TAO_CXXFLAGS -p" + TAO_CFLAGS="$TAO_CFLAGS -p" + ;; + esac + fi + ;; + no) + dnl Do nothing + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-profile) + ;; + esac + ],) + +AC_ARG_ENABLE(purify, + [ --enable-purify Purify all executables [default=no]], + [ + case "${enableval}" in + yes) + AC_CHECK_PROG(PURIFY, purify, purify,) + if test -n "$PURIFY"; then + PURE_CACHE_BASE_DIR="/tmp/purifycache" + PURE_CACHE_DIR=${PURE_CACHE_BASE_DIR}-${LOGNAME}-${notdir ${CXX} } + PURELINK="$PURIFY -best-effort -chain-length=20 \ + -cache-dir=$PURE_CACHE_DIR \ + -fds-inuse-at-exit=no -ignore-signals=SIGINT -inuse-at-exit \ + -max_threads=100" + TAO_CXXFLAGS="$TAO_CXXFLAGS -DTAO_HAS_PURIFY" + TAO_CFLAGS="$TAO_CFLAGS -DTAO_HAS_PURIFY" + else + AC_MSG_WARN(Purify program was not found.) + AC_MSG_WARN(Disabling purify support.) + fi + ;; + no) + PURELINK="" + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-purify) + ;; + esac + ], PURELINK="") + +AC_ARG_ENABLE(quantify, + [ --enable-quantify Quantify all executables [default=no]], + [ + case "${enableval}" in + yes) + AC_CHECK_PROG(QUANTIFY, quantify, quantify,) + if test -n "$QUANTIFY"; then + PURE_CACHE_BASE_DIR="/tmp/purifycache" + PURE_CACHE_DIR=${PURE_CACHE_BASE_DIR}-${LOGNAME}-${notdir ${CXX} } + PRELINK="$QUANTIFY -best-effort -max_threads=100 \ + -cache-dir=$PURE_CACHE_DIR" + TAO_CXXFLAGS="$TAO_CXXFLAGS -DTAO_HAS_QUANTIFY" + TAO_CFLAGS="$TAO_CFLAGS -DTAO_HAS_QUANTIFY" + else + AC_MSG_WARN(Quantify program was not found.) + AC_MSG_WARN(Disabling quantify support.) + fi + ;; + no) + PRELINK="" + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-quantify) + ;; + esac + ], PRELINK="") + +AC_ARG_ENABLE(rt-corba, + [ --enable-rt-corba enable Real-Time CORBA support [default=yes]], + [ + case "${enableval}" in + yes) + ;; + no) + AC_DEFINE(TAO_DISABLE_RT_CORBA) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-rt-corba) + ;; + esac + ],) + +AC_ARG_WITH(ace-includes, + [ --with-ace-includes=DIR ACE include files are in DIR], + [ + case "${withval}" in + yes) + AC_MSG_ERROR(specify a directory where the 'ace' include directory exists.) + ;; + no) + AC_MSG_ERROR(specify a directory where the 'ace' include directory exists.) + ;; + *) + if test -d "${withval}"; then + ACE_INCLUDEDIR="${withval}" + CXXFLAGS="${CXXFLAGS} -I${ACE_INCLUDEDIR}" + else + AC_MSG_ERROR(header directory '${withval}' does not exist.) + fi + ;; + esac + ],) + +AC_ARG_WITH(ace-libs, + [ --with-ace-libs=DIR ACE library files are in DIR], + [ + case "${withval}" in + yes) + AC_MSG_ERROR(specify a directory where the ACE libraries exist.) + ;; + no) + AC_MSG_ERROR(specify a directory where the ACE libraries exist.) + ;; + *) + if test -d "${withval}"; then + ACE_LIBDIR="${withval}" + LDFLAGS="${LDFLAGS} -L${ACE_LIBDIR}" + else + AC_MSG_ERROR(library directory '${withval}' does not exist.) + fi + ;; + esac + ],) + +AC_ARG_WITH(gperf, + [ --with-gperf=PROG gperf program [default=gperf]], + [ + case "${withval}" in + yes) + AC_MSG_ERROR(Specify the gperf program.) + ;; + no) + AC_MSG_ERROR(Specify the gperf program.) + ;; + *) + AC_CHECK_PROGS(GPERF, ${withval},) dnl + if test -n "$GPERF"; then + AC_DEFINE_UNQUOTED(ACE_GPERF, "${withval}") dnl + else + AC_MSG_ERROR(gperf program ${withval} does not exist.) + fi + ;; + esac + ], + [ + AC_CHECK_PROGS(GPERF, gperf-ace gperf,) dnl + if test -n "$GPERF"; then + AC_DEFINE_UNQUOTED(ACE_GPERF, "${GPERF}") dnl + else + AC_MSG_WARN(No gperf program found. TAO will not use perfect hashing.) + fi + ]) + +dnl Check for a working ACE installation +ac_save_CXXFLAGS="$CXXFLAGS" +ac_save_LDFLAGS="$LDFLAGS" +ac_save_LIBS="$LIBS" +if test -n "$ACE_CONFIG"; then + CXXFLAGS=`$ACE_CONFIG --cxxflags ace` + LDFLAGS=`$ACE_CONFIG --libs-only-L ace` + LIBS=`$ACE_CONFIG --libs-only-l ace` +fi +CXXFLAGS="$ac_save_CXXFLAGS $CXXFLAGS" +LDFLAGS="$ac_save_LDFLAGS $LDFLAGS" +LIBS="$ac_save_LIBS -lACE $LIBS" +AC_MSG_CHECKING(for a working ACE installation) +AC_CACHE_VAL(ac_cv_lib_ace_ace_os_exit, +[ + cat > conftest.$ac_ext <<EOF + +#include <ace/OS.h> +changequote(, )dnl +int main(int argc, char *argv[]) +changequote([, ])dnl +{ + ACE_OS::exit(0); +} +EOF + + if (eval "$CXX -o conftest conftest.$ac_ext $CXXFLAGS $LDFLAGS $LIBS") 2>&5; then + ac_cv_lib_ace_ace_os_exit="yes" + rm -f conftest* + else + ac_cv_lib_ace_ace_os_exit="no" + dnl rm -f conftest* + fi +]) +if test "$ac_cv_lib_ace_ace_os_exit" = "yes"; then + AC_MSG_RESULT(yes) +else + AC_MSG_RESULT(no) + AC_MSG_WARN(no functional ACE library found) + AC_MSG_ERROR(specify needed compiler flags using CXXFLAGS variable first) +fi + +dnl We only set the following if the ace-config script doesn't exist! +if test -z "$ACE_CONFIG"; then + + dnl Check if platform supports exceptions using ACE headers + AC_MSG_CHECKING(if ACE supports exceptions) + AC_EGREP_CPP(TAO_EXCEPTIONS, + [ +#include <ace/config.h> + +#if defined (ACE_HAS_EXCEPTIONS) + TAO_EXCEPTIONS +#endif + ], + [ + AC_MSG_RESULT(yes) + ] , + [ + AC_MSG_RESULT(no) + if test -n "$GXX"; then +dnl Temporarily change M4 quotes to prevent "regex []" from being eaten +changequote(, )dnl + if g++ --version | egrep -v '^2\.[0-7]' > /dev/null; then +changequote([, ])dnl + if test -z "$ACE_CONFIG"; then + TAO_CXXFLAGS="$TAO_CXXFLAGS -fno-exceptions" + fi + fi + fi + if test -n "$GCC"; then +dnl Temporarily change M4 quotes to prevent "regex []" from being eaten +changequote(, )dnl + if gcc --version | egrep -v '^2\.[0-7]' > /dev/null; then +changequote([, ])dnl + if test -z "$ACE_CONFIG"; then + TAO_CFLAGS="$TAO_CFLAGS -fno-exceptions" + fi + fi + fi + ]) + + dnl Check if platform supports run-time type identification using ACE headers + AC_MSG_CHECKING(if ACE supports GNU C++ repositories) + AC_EGREP_CPP(TAO_GNU_REPO, + [ +#include <ace/config.h> + +#if defined (ACE_HAS_GNU_REPO) + TAO_GNU_REPO +#endif + ], + [ + AC_MSG_RESULT(yes) + if test -n "$GXX" && test -z "$ACE_CONFIG"; then + TAO_CXXFLAGS="$TAO_CXXFLAGS -frepo" + fi + ] , + [ + AC_MSG_RESULT(no) + if test -n "$GXX" && test -z "$ACE_CONFIG"; then + TAO_CXXFLAGS="$TAO_CXXFLAGS -fno-implicit-templates" + fi + ]) + + dnl Check if platform supports run-time type identification using ACE headers + AC_MSG_CHECKING(if ACE supports run-time type identification) + AC_EGREP_CPP(TAO_RTTI, + [ +#include <ace/config.h> + +#if !defined (ACE_LACKS_RTTI) + TAO_RTTI +#endif + ], + [ + AC_MSG_RESULT(yes) + if test -z "$GXX" && test -z "$ACE_CONFIG"; then + case "$target" in + *solaris*) + TAO_CXXFLAGS="$TAO_CXXFLAGS -features=rtti" + ;; + *) + ;; + esac + fi + ], + [ + AC_MSG_RESULT(no) + ]) + +fi dnl test -z "$ACE_CONFIG" + +dnl Check if templates require source on platform using ACE headers +AC_MSG_CHECKING(if ACE and TAO require template source) +AC_EGREP_CPP(TAO_TEMPLATES_SOURCE, + [ +#include <ace/config.h> + +#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) + TAO_TEMPLATES_SOURCE +#endif + ], + [ + tao_cv_feature_templates_require_source="yes" + AC_MSG_RESULT(yes) + ], + [ + tao_cv_feature_templates_require_source="no" + AC_MSG_RESULT(no) + ]) +AM_CONDITIONAL(TEMPLATES_REQUIRE_SOURCE, + test X$tao_cv_feature_templates_require_source = Xyes) + + +dnl Additional flags to set by the configure script + +if test -n "$GXX" && test -z "$ACE_CONFIG"; then + TAO_CXXFLAGS="$TAO_CXXFLAGS -W -Wall -Wpointer-arith" +fi + +if test -n "$GCC" && test -z "$ACE_CONFIG"; then + TAO_CFLAGS="$TAO_CFLAGS -W -Wall -Wpointer-arith" +fi + +dnl Combine package set flags with user's flags. +dnl User's flags go after package flags to allow user to override +dnl package defaults. +dnl X_CFLAGS comes from AC_PATH_XTRA. It may include, for example, +dnl additional include file paths or macros that need to be defined +dnl in order for X11 related files to be compiled properly. +CXXFLAGS="$TAO_CXXFLAGS $CXXFLAGS" +CFLAGS="$TAO_CFLAGS $CFLAGS" +CPPFLAGS="$TAO_CPPFLAGS $CPPFLAGS" +LDFLAGS="$TAO_LDFLAGS $LDFLAGS" + +dnl Prepend purify and quantify command lines if purify and quantify are +dnl enabled. Otherwise, PURELINK and PRELINK will just be "blank." +LD="$PURELINK $PRELINK $LD" +dnl LDFLAGS="$ACE_LDFLAGS $LDFLAGS" + +dnl AC_SUBST(LDFLAGS) +dnl AC_SUBST(LIBOBJS) + +dnl These definitions are expanded in the makefile and ace-config +TAO_LIBDIR='-L${libdir}' +TAO_LIBS="${LIBS}" +TAO_INCLUDEDIR='-I${includedir}' + +AC_SUBST(TAO_LIBDIR) +AC_SUBST(TAO_LIBS) +AC_SUBST(TAO_INCLUDEDIR) + +dnl Force CXXFLAGS to be substituted in Makefiles that don't "need" them. +AC_SUBST(CXXFLAGS) + +dnl +dnl SECTION 16: `AC_OUTPUT([FILE...])' +dnl +dnl +dnl We can finally create all the files listed here; Makefile is +dnl created from Makefile.in, etc. Top-level Makefiles should be +dnl created first. +AC_OUTPUT([ + Makefile + TAO_IDL/Makefile + TAO_IDL/ast/Makefile + TAO_IDL/be/Makefile + TAO_IDL/be_include/Makefile + TAO_IDL/driver/Makefile + TAO_IDL/fe/Makefile + TAO_IDL/include/Makefile + TAO_IDL/narrow/Makefile + TAO_IDL/util/Makefile + tao/Makefile + tao-config + ], + [ + echo "" + echo "Configuration of TAO is now complete." + echo "" + ]) |