dnl Process this file with autoconf to produce a configure script.
AC_INIT([OpenCASCADE], [6.8.0])
AC_CONFIG_AUX_DIR(make)
AM_INIT_AUTOMAKE([foreign])
AC_CANONICAL_HOST
dnl AM_CONFIG_SRCDIR(src/Standard/Standard.cxx)

CFLAGS="$CFLAGS"
CXXFLAGS="$CXXFLAGS"

AC_PROG_CC

AM_CONFIG_HEADER(config.h)

dnl AM_MAINTAINER_MODE

AC_AIX
AC_ISC_POSIX
AC_C_BIGENDIAN

AC_DISABLE_STATIC

dnl Checks for programs.
AM_PROG_LIBTOOL
AC_PROG_CXX
AC_PROG_CC_C_O

AC_PROG_AWK
AC_PROG_INSTALL
AC_PROG_LN_S
AC_PROG_YACC
AC_PROG_MAKE_SET

dnl Checks for header files.

AC_HEADER_STDC
AC_LANG([C])
AC_MSG_CHECKING([ for C header files ])
AC_CHECK_HEADERS(dlfcn.h dl.h ieeefp.h time.h sys/time.h pwd.h)
AC_CHECK_HEADERS(sys/statvfs.h sys/vfs.h sys/param.h osfcn.h netdb.h)
AC_CHECK_HEADERS(sys/ioctl.h net/if.h sys/systeminfo.h sys/utsname.h)
AC_CHECK_HEADERS(sysent.h unistd.h sys/unistd.h sys/socket.h)
AC_CHECK_HEADERS(ndir.h sys/ndir.h sys/dir.h signal.h sys/signal.h)
AC_CHECK_HEADERS(sigfpe.h floatingpoint.h sys/machsig.h sys/siginfo.h)
AC_CHECK_HEADERS(malloc.h strings.h sys/stat.h sys/sem.h sys/ipc.h)
AC_CHECK_HEADERS(sys/times.h dirent.h getopt.h sys/vnode.h)


AC_LANG([C++])
AC_MSG_CHECKING([ for C++ header files ])
AC_CHECK_HEADERS(istream ostream istream fstream ios iomanip iostream )
AC_CHECK_HEADERS(stream.h strstream.h istream.h ostream.h fstream.h stdlib.h ios.h iostream.h)
AC_CHECK_HEADERS(iomanip.h limits.h values.h float.h)
AC_CHECK_HEADERS(siginfo.h bits/sigset.h bstring.h sys/types.h sys/select.h)
AC_CHECK_HEADERS(X11/extensions/transovl.h X11/extensions/readdisplay.h)
AC_CHECK_HEADERS(X11/extensions/multibuf.h,[],[],[#include <X11/Xlib.h>])
AC_CHECK_HEADERS(sys/filio.h sys/mman.h libc.h)

#-----------------------------------------------------------------------------
# Posix threads library is required
#-----------------------------------------------------------------------------
AC_CHECK_HEADER([pthread.h],[],[AC_MSG_ERROR([Posix threads required])])
AC_CHECK_LIB([pthread],[pthread_create],[],[AC_MSG_ERROR([Posix threads required])])
CSF_ThreadLibs_LIB=-lpthread
AC_SUBST(CSF_ThreadLibs_LIB)

#-----------------------------------------------------------------------------
# dl library is required
#-----------------------------------------------------------------------------
AC_CHECK_LIB([dl],[dlopen],[],[AC_MSG_ERROR([dl library is required])])
CSF_SOCKETLibs_LIB=-ldl

#---------------------------------------------------------------------
#
# Test for 64-bit platforms
#  
#  
#---------------------------------------------------------------------
AC_MSG_CHECKING([if platform is 64-bit])
AC_TRY_COMPILE( [], 
 [int array[((int)sizeof(void*))-6];],
 [AC_MSG_RESULT([yes]); ARCH=64; case $platform in Linux*) CPPFLAGS="$CPPFLAGS -m64";; esac],
 [AC_MSG_RESULT([no]); ARCH=32;] )
AC_SUBST(ARCH)

if test "x${CSF_OPT_INC}" != "x"; then
   CSF_OPT_INCLUDES=
   for c in `echo ${CSF_OPT_INC} | sed 's/:/ /g'`; do
       CSF_OPT_INCLUDES="-I$c ${CSF_OPT_INCLUDES}"
   done
fi
if test "$ARCH" = "32" -a "x${CSF_OPT_LIB32}" != "x"; then
   CSF_OPT_LIB=${CSF_OPT_LIB32}
   CSF_OPT_LIBS=
   for c in `echo ${CSF_OPT_LIB32} | sed 's/:/ /g'`; do
       CSF_OPT_LIBS="-L$c ${CSF_OPT_LIBS}"
   done
fi
if test "$ARCH" = "64" -a "x${CSF_OPT_LIB64}" != "x"; then
   CSF_OPT_LIB=${CSF_OPT_LIB64}
   CSF_OPT_LIBS=
   for c in `echo ${CSF_OPT_LIB64} | sed 's/:/ /g'`; do
       CSF_OPT_LIBS="-L$c ${CSF_OPT_LIBS}"
   done
fi

AC_SUBST(CSF_OPT_INCLUDES)
AC_SUBST(CSF_OPT_LIBS)

#------------------------------------------------------------------------------
# Get Tcl and TK configuration information from tclConfig.sh.
#------------------------------------------------------------------------------

SC_TCL_CFG
SC_TK_CFG
HAVE_TCLTK=no
if test "xyes" = "x$HAVE_TCL"; then
  if test "xyes" = "x$HAVE_TK"; then
    HAVE_TCLTK=yes
    CSF_TclLibs_INCLUDES="${TCL_INCLUDE_SPEC}"
    CSF_TclTkLibs_INCLUDES="${TK_INCLUDE_SPEC}"
    CSF_TclLibs_LIB="${TCL_LIB_SPEC}"
    CSF_TclTkLibs_LIB="${TK_LIB_SPEC}"
    CSF_OPT_INC="${TCL_PREFIX}/include:${TK_PREFIX}/include:${CSF_OPT_INC}"
    CSF_OPT_LIB="${TCL_PREFIX}/lib:${TK_PREFIX}/lib:${CSF_OPT_LIB}"
  fi
fi
if test "x${HAVE_TCLTK}" != "xyes"; then
   DISABLE_TCLTK_REASON="(tcltk was not found)"
fi
AC_SUBST(TCL_VERSION)
AC_SUBST(TK_VERSION)
AC_SUBST(HAVE_TCLTK)
AC_SUBST(CSF_TclLibs_INCLUDES)
AC_SUBST(CSF_TclTkLibs_INCLUDES)
AC_SUBST(CSF_TclLibs_LIB)
AC_SUBST(CSF_TclTkLibs_LIB)

platform=`uname -s`

dnl Make sure CSFDB is defined in CXXFLAGS and CFLAGS
CXXFLAGS="$CXXFLAGS -DCSFDB -DOCC_CONVERT_SIGNALS"
CFLAGS="$CFLAGS -DCSFDB -DOCC_CONVERT_SIGNALS"

case $platform in
	Linux*) CXXFLAGS="$CXXFLAGS -DLIN -DLININTEL -D_GNU_SOURCE=1 -mmmx -msse -msse2 -mfpmath=sse -Wall"
		CFLAGS="$CFLAGS -DLIN -DLININTEL -fexceptions -mmmx -msse -msse2 -mfpmath=sse -Wall"
		LDFLAGS="$LDFLAGS -lstdc++ -lrt";;
	SunOS*) CXXFLAGS="$CXXFLAGS -Usun -DSOLARIS -instances=static"
		CFLAGS="$CFLAGS -Usun -DSOLARIS -instances=static"
		LDFLAGS="$LDFLAGS -instances=static"
		CSF_SOCKETLibs_LIB="-lnsl ${CSF_SOCKETLibs_LIB}";;
        OSF1*)  CXXFLAGS="$CXXFLAGS -DDECOSF1 -D__USE_STD_IOSTREAM -D_RWSTD_NO_EXCEPTIONS" 
                CFLAGS="$CFLAGS -std1 -DDECOSF1"
		LD=$CXX;;
	*) ;;
esac
AC_SUBST(CSF_SOCKETLibs_LIB)

AC_SUBST(platform)
AC_LANG([C++])

dnl Checks for typedefs, structures, and compiler characteristics.
AC_TYPE_SIZE_T
AC_STRUCT_TM

dnl Checks for library functions.
AC_FUNC_ALLOCA
AC_FUNC_MEMCMP
AC_TYPE_SIGNAL
AC_CHECK_FUNCS(gethostname putenv re_comp regcomp strcspn strdup strtol)
AC_CHECK_FUNCS(statfs statvfs)


AC_CACHE_CHECK([if it is OK to define stream input and output],
def_cv_ios_ok,
[AC_LANG([C++])
 AC_TRY_COMPILE([#include <stream.h>
static const int input = (ios::in) | (ios::nocreate);
static const int output= (ios::out);],
[return 0;],
 def_cv_ios_ok=yes, def_cv_ios_ok=no)
])
if test "$def_cv_ios_ok" = yes; then
  AC_DEFINE(DEF_IOS_OK,,[define if the compiler allows redefinition of stream input and output])
fi


AC_CACHE_CHECK([if class ostream has member function form],
[ostream_cv_form_ok],
[AC_LANG([C++])
 AC_TRY_COMPILE([#include <iostream.h>],
[cout << cout.form("%9.3e", 3.14159627e-4) << endl;
return 0;],
 ostream_cv_form_ok=yes, ostream_cv_form_ok=no)
])
if test "$ostream_cv_form_ok" = yes; then
  AC_DEFINE(OSTREAM_FORM_OK,,[define if the class ostream has member function form])
fi


dnl Checks for typedefs, structures, and compiler characteristics.

# if the following code compiles then the union semun is
# defined in the header <sys/sem.h>

AC_CACHE_CHECK([if union semun is defined in <sys/sem.h>],
[semun_cv_defined],
[AC_LANG([C])
AC_TRY_COMPILE([#include <sys/time.h>
#include <sys/sem.h>],
[union semun c;],
 semun_cv_defined=yes, semun_cv_defined=no)
])
if test "$semun_cv_defined" = yes; then
  AC_DEFINE(SEMUN_DEFINED,,[define if the union semun is in sys/sem.h])
fi

# if the following code compiles then the union semun has
# the member __buf

if test "$semun_cv_defined" = yes; then

 AC_CACHE_CHECK(if union semun has member __buf,
 semun_cv_buf_defined,
 [AC_LANG([C])
 AC_TRY_COMPILE([#include <sys/sem.h>],
 [ union semun c; c.__buf = 0;],
 semun_cv_buf_defined=yes, semun_cv_buf_defined=no)
 ])
 if test "$sumun_buf_defined" = yes; then
  AC_DEFINE(SEMUN_BUF_DEFINED,,[define if semun has member __buf])
 fi
fi


AC_CACHE_CHECK([if function semop takes a value],
[semop_cv_no_reference],
[AC_LANG([C])
AC_TRY_COMPILE([#include <sys/sem.h>
static struct sembuf event_flag ;],
[int status;
 int *semid;
 status = semop(*semid,event_flag,1);
],
 semop_cv_no_reference=yes, semop_cv_no_reference=no)
])
if test "$semop_cv_no_reference" = yes; then
  AC_DEFINE(SEMOP_NO_REFERENCE,,[define if the function semop takes a value])
fi


AC_CACHE_CHECK([if function semctl takes a value],
[semctl_cv_no_reference],
[AC_LANG([C])
AC_TRY_COMPILE([#include <sys/sem.h>
int get_semaphore(semid,event,value)
 int *semid, *event, *value;
{
 int status;
 status = semctl((*semid),*event,GETVAL,value);
 return 0;
}
int *a,*b,*c;],
[if(get_semaphore(a,b,c))
 exit 0;],
 semctl_cv_no_reference=yes, semctl_cv_no_reference=no)
])
if test "$semctl_cv_no_reference" = yes; then
  AC_DEFINE(SEMCTL_NO_REFERENCE,,[define if the function semctl takes a value])
fi

AC_CHECK_LIB(malloc,mallinfo,[
  AC_DEFINE(HAVE_MALLINFO,,[Define if we have a function called "mallinfo" in -lmalloc.])
  LIBS="$LIBS -lmalloc"
])

AC_CHECK_LIB(sunmath,ieee_handler,[
  AC_DEFINE(HAVE_SUNMATH,,[Define if we have a function called "ieee_handler" in -lsunmath.])
  LIBS="$LIBS -lsunmath"
])

AC_CHECK_LIB(m,finite,[
  AC_DEFINE(HAVE_FINITE,,[Define if we have a function called "finite" in -lm.])
])

#---------------------------------------------------------------------
#
# Check for Java Header Files 
#  
#  
#---------------------------------------------------------------------

AC_ARG_WITH([java-include],
  [AC_HELP_STRING([--with-java-include=DIR],[Location of jni.h])],
  [java_include="${withval}"],[java_include=])
if test "xno" = "x$java_include"; then
  # user specified --without-java-include
  HAVE_JAVA=no
else
  if test "xyes" != "x$java_include" && test "x" != "x$java_include"; then
    # user specified some path
    
    # test user-specified value is a directory
    if test ! -d "$java_include"; then
      AC_MSG_ERROR([$java_include: Not a directory])
    fi
    
    # search for jni_md.h (typically in a system-specific subdir)
    AC_MSG_CHECKING([for jni_md.h in $java_include])
    extra_java_include=
    if test -f "$java_include/jni_md.h"; then
      result="$java_include/jni_md.h"
    else
      result=
      for d in "$java_include"/*; do
        if test -f "$d/jni_md.h"; then
          extra_java_include="-I$d"
          result="$d/jni_md.h"
          break
        fi
      done
      AC_MSG_RESULT([$result])
    fi
    
    # put user-specified directory and jni_mh.h directory (if found)
    # into CPPFLAGS
    CPPFLAGS="$CPPFLAGS -I$java_include $extra_java_include"
  fi
  
  # Now we check for a working jni.h that is version 1.2 or newer.
  # Note: This check is done unless user specified --without-java-include
  #       If --with-java-include wasn't specified, it will check the
  #       default compiler search path and any paths the user specified
  #       via CPPFLAGS on the command line.
  AC_CHECK_HEADER( [jni.h], [HAVE_JAVA=yes], [HAVE_JAVA=no
    AC_MSG_NOTICE("Specify --with-java-include=<DIR> to enable Java support")] )
  if test "xyes" = "x$HAVE_JAVA"; then
    AC_MSG_CHECKING([java JNI version >= 1.2])
    AC_TRY_COMPILE( [#include <jni.h>],
  [#ifndef JNI_VERSION_1_2
     choke me
   #endif], [HAVE_JAVA=yes],[HAVE_JAVA=no] )
    AC_MSG_RESULT([$HAVE_JAVA])
  fi
  
  # If user specified --with-java-include, fail if not found
  # (If user didn't specify, then we gracefully disable things that
  # require java.)
  if test "x" != "x$java_include" && test "xyes" != "x$HAVE_JAVA"; then
    AC_MSG_ERROR([working jni.h not found])
  fi
fi

CFLAGS_save="$CFLAGS"
CXXFLAGS_save="$CXXFLAGS"
CPPFLAGS_save="$CPPFLAGS"
LDFLAGS_save="$LDFLAGS"
LIBS_save="$LIBS"

#---------------------------------------------------------------------
#
# Configure X11 and check for utility library
#
#---------------------------------------------------------------------
AC_LANG([C])

AC_PATH_X
HAVE_X11=no
X_INCLUDE=""
X_LIBS=""
CSF_XmuLibs_INCLUDES=""
CSF_XmuLibs_LIB=""
if test "xyes" != "x$no_x"; then
  HAVE_X11=yes
  if test "x" != "x$x_includes"; then
    X_INCLUDE="-I$x_includes"
    CSF_XmuLibs_INCLUDES="$X_INCLUDE"
    CXXFLAGS="$CXXFLAGS -I$x_includes"
  fi
  if test "x" != "x$x_libraries"; then
    X_LIBS="-L$x_libraries"
    CSF_XmuLibs_LIB="$X_LIBS"
    LDFLAGS="$LDFLAGS -L$x_libraries"
  fi
  AC_CHECK_LIB( [X11], [XCreateWindow], [X_LIBS="${X_LIBS} -lXt -lX11"], [HAVE_X11=no] )
  AC_CHECK_HEADER( [X11/Xmu/Xmu.h], [], [HAVE_X11=no] )
  AC_CHECK_LIB( [Xmu], [XmuLookupStandardColormap], [CSF_XmuLibs_LIB="$CSF_XmuLibs_LIB -lXmu"], [HAVE_X11=no], [-lXt -lX11] )
fi

#---------------------------------------------------------------------
#
# Check for OpenGL Libraries
#  
#  
#---------------------------------------------------------------------
CSF_OpenGlLibs_INCLUDES="$X_INCLUDE"
CSF_OpenGlLibs_LIB="$X_LIBS"
if test "xno" = "x$HAVE_X11"; then
  HAVE_GL=no
else
AC_LANG([C])
  HAVE_GL=yes
  HAVE_GL_INC=yes
  AC_CHECK_HEADER( [GL/gl.h], [AC_CHECK_HEADER([GL/glu.h],[],[HAVE_GL_INC=no])], [HAVE_GL_INC=no] )
  if test "x$HAVE_GL_INC" = "xyes"; then
    AC_CHECK_TYPE(_GLUfuncptr,[],[CSF_OpenGlLibs_INCLUDES="$CSF_OpenGlLibs_INCLUDES -DNOGLUfuncptr=1"],[#include "GL/glu.h"])
  else
    HAVE_GL=no
    AC_MSG_NOTICE("Specify CPPFLAGS=-I<opengl_inc_dir> to enable OpenGL support")
  fi
  CPPFLAGS="$CSF_OpenGlLibs_INCLUDES $CPPFLAGS"
  HAVE_GL_LIB=yes
  AC_CHECK_LIB( [GL], [glClear], [AC_CHECK_LIB([GLU],[gluSphere],[CSF_OpenGlLibs_LIB="$CSF_OpenGlLibs_LIB -lGLU -lGL"],[HAVE_GL_LIB=no],[-lGL])], [HAVE_GL_LIB=no] )
  if test "xno" = "x$HAVE_GL_LIB"; then
    HAVE_GL=no
    AC_MSG_NOTICE("Specify LDFLAGS=-L<opengl_lib_dir> to enable OpenGL support")
  fi
fi
AM_CONDITIONAL( HAVE_GL, [test "xyes" = "x$HAVE_GL"] )

#---------------------------------------------------------------------
#
# Check for FREETYPE Libraries
# 
# 
#---------------------------------------------------------------------
AC_ARG_WITH([freetype],
  [AC_HELP_STRING([--with-freetype=DIR],[Location of FREETYPE])],
  [freetype="${withval}"],[freetype=yes])

CSF_FREETYPE_INCLUDES=""
CSF_FREETYPE_LIB=""
HAVE_FREETYPE=no

if test "xyes" = "x${HAVE_GL}"; then
  AC_LANG([C++])
  if test "xno" = "x${freetype}"; then
    dnl freetype check is explicitly disabled by --without-freetype or --with-freetype=no
    AC_MSG_NOTICE([freetype check is explicitly disabled])
    DISABLE_FREETYPE_REASON="(freetype check was explicitly disabled)"
  else
    if test "xyes" = "x${freetype}" -o "x/usr" = "x${freetype}"; then
      dnl try native freetype (default)
      AC_MSG_NOTICE(try system freetype)
      FREETYPE_INCLUDES="-I/usr/include/freetype2"
      FREETYPE_LIBS="-lfreetype"
      FREETYPE_OPT_INC="/usr/include/freetype2"
      FREETYPE_OPT_LIB=
    else
      AC_MSG_NOTICE(try freetype in $freetype)
      if test ! -d ${freetype}; then
    DISABLE_FREETYPE_REASON="(${freetype} directory does not exists)"
    AC_MSG_ERROR([${freetype} directory does not exists])
      fi
      FREETYPE_INCLUDES="-I${freetype}/include -I${freetype}/include/freetype2"
      FREETYPE_LIBS="-L${freetype}/lib -lfreetype"
      FREETYPE_OPT_INC="${freetype}/include:${freetype}/include/freetype2"
      FREETYPE_OPT_LIB="${freetype}/lib"
    fi
    CPPFLAGS_old=${CPPFLAGS}
    LDFLAGS_old=${LDFLAGS}
    CPPFLAGS="${FREETYPE_INCLUDES} $CPPFLAGS"
    LDFLAGS="${FREETYPE_LIBS} $LDFLAGS"
    AC_CHECK_HEADER( [ft2build.h], [HAVE_FREETYPE_INC=yes], [HAVE_FREETYPE_INC=no] )
    if test "x${HAVE_FREETYPE_INC}" = "xyes"; then
      AC_CHECK_LIB(freetype, FT_Init_FreeType,
      [
    HAVE_FREETYPE=yes
        CSF_FREETYPE_INCLUDES="${FREETYPE_INCLUDES}"
    CSF_FREETYPE_LIB="${FREETYPE_LIBS}"
        LIBS="$CSF_FREETYPE_LIB $LIBS"
        CSF_OPT_INC="${FREETYPE_OPT_INC}:${CSF_OPT_INC}"
        CSF_OPT_LIB="${FREETYPE_OPT_LIB}:${CSF_OPT_LIB}"
      ],
      [
    DISABLE_FREETYPE_REASON="(freetype was not found)"
    AC_MSG_ERROR([Unable to locate the required FreeType library])
      ])
    else
      DISABLE_FREETYPE_REASON="(freetype was not found)"
    fi
    CPPFLAGS=${CPPFLAGS_old}
    LDFLAGS=${LDFLAGS_old}
  fi
else
  DISABLE_FREETYPE_REASON="(freetype requires OpenGL support)"
fi
AM_CONDITIONAL( HAVE_FREETYPE, [test "xyes" = "x$HAVE_FREETYPE"] )

#---------------------------------------------------------------------
#
# Check for FTGL Libraries
# 
# 
#---------------------------------------------------------------------
AC_ARG_WITH([ftgl],
  [AC_HELP_STRING([--with-ftgl=DIR],[Location of FTGL])],
  [ftgl="${withval}"],[ftgl=yes])

CSF_FTGL_INCLUDES=""
CSF_FTGL_LIB=""
HAVE_FTGL=no

if test "xno" = "x${HAVE_FREETYPE}"; then
  DISABLE_FTGL_REASON=$DISABLE_FREETYPE_REASON
else
  AC_LANG([C++])
  if test "xno" = "x${ftgl}"; then
    dnl ftgl check is explicitly disabled by --without-ftgl or --with-ftgl=no
    AC_MSG_NOTICE([ftgl check is explicitly disabled])
    DISABLE_FTGL_REASON="(ftgl check was explicitly disabled)"
  else
    if test "xyes" = "x${ftgl}" -o "x/usr" = "x${ftgl}"; then
      dnl try native ftgl (default)
      ftgl=/usr
      AC_MSG_NOTICE(try system ftgl)
      FTGL_INCLUDES="-I/usr/include/FTGL"
      FTGL_LIBS="-lftgl"
      FTGL_OPT_INC="/usr/include/FTGL"
      FTGL_OPT_LIB=
    else
      AC_MSG_NOTICE(try ftgl in ${ftgl})
      if test ! -d ${ftgl}; then
    DISABLE_FTGL_REASON="(${ftgl} directory does not exists)"
    AC_MSG_ERROR([${ftgl} directory does not exists])
      fi
      FTGL_INCLUDES="-I${ftgl}/include -I${ftgl}/include/FTGL"
      FTGL_LIBS="-L${ftgl}/lib -lftgl"
      FTGL_OPT_INC="${ftgl}/include:${ftgl}/include/FTGL"
      FTGL_OPT_LIB="${ftgl}/lib"
    fi
    for hf in ftgl.h FTGL.h; do
      dnl check presence of ftgl header file in the specified directory
      test -f ${ftgl}/include/FTGL/${hf} -o -f ${ftgl}/include/${hf} && HAVE_FTGL_INC=yes
      test "xyes" = "x${HAVE_FTGL_INC}" -a "${hf}" = "FTGL.h" && HAVE_FTGL_UPPERCASE=-DHAVE_FTGL_UPPERCASE
      test "xyes" = "x${HAVE_FTGL_INC}" && break
    done
    if test "xyes" = "x${HAVE_FTGL_INC}" ; then
      CPPFLAGS_old=${CPPFLAGS}
      LDFLAGS_old=${LDFLAGS}
      CPPFLAGS="${FTGL_INCLUDES} ${HAVE_FTGL_UPPERCASE} ${CSF_FREETYPE_INCLUDES} $CPPFLAGS"
      LDFLAGS="${FTGL_LIBS} ${CSF_FREETYPE_LIB} $LDFLAGS"
      AC_CHECK_HEADERS([${hf}], 
      [
        HAVE_FTGL_INC=yes
        break
      ],
      [
        HAVE_FTGL_INC=no
      ])
      if test "x${HAVE_FTGL_INC}" = "xyes"; then
        AC_MSG_CHECKING([for FTGLTextureFont in -lftgl])
        CPPFLAGS="${FTGL_INCLUDES} ${HAVE_FTGL_UPPERCASE} ${CSF_FREETYPE_INCLUDES} ${CPPFLAGS_old}"
        AC_TRY_LINK(
        [
          #ifdef HAVE_FTGL_UPPERCASE
          #include <FTGL/FTGL.h>
          #include <FTGL/FTGLTextureFont.h>
          #else
          #include <FTGL/ftgl.h>
          #endif
        ],
        [
          FTGLTextureFont font("");
        ],
        [
          AC_MSG_RESULT(yes)
          HAVE_FTGL=yes
          CSF_FTGL_INCLUDES="${FTGL_INCLUDES} ${HAVE_FTGL_UPPERCASE}"
          CSF_FTGL_LIB="${FTGL_LIBS}"
          CSF_OPT_INC="${FTGL_OPT_INC}:${CSF_OPT_INC}"
          CSF_OPT_LIB="${FTGL_OPT_LIB}:${CSF_OPT_LIB}"
        ],
        [
          AC_MSG_RESULT(no)
          DISABLE_FTGL_REASON="(ftgl was not found)"
      AC_MSG_ERROR([Unable to locate the required ftgl library])
        ]) 
      else
        DISABLE_FTGL_REASON="(ftgl was not found)"
      fi
      CPPFLAGS=${CPPFLAGS_old}
      LDFLAGS=${LDFLAGS_old}
    else
      AC_MSG_RESULT([ftgl was not found])
      DISABLE_FTGL_REASON="(ftgl was not found)"
    fi
  fi
fi
AM_CONDITIONAL( HAVE_FTGL, [test "xyes" = "x$HAVE_FTGL"] )

#---------------------------------------------------------------------
#
# Check for GL2PS Libraries
#  
#  
#---------------------------------------------------------------------
AC_ARG_WITH([gl2ps],
  [AC_HELP_STRING([--with-gl2ps=DIR],[Location of GL2PS])],
  [gl2ps="${withval}"],[gl2ps=])

if test "xno" = "xno$gl2ps"; then
# user specified --without-gl2ps
  HAVE_GL2PS=no
  DISABLE_GL2PS_REASON="(--with-gl2ps=DIR option was not defined)"
else
  CSF_GL2PS_INCLUDES=""
  CSF_GL2PS_LIB=""

  if test "xno" = "x$HAVE_GL"; then
   	HAVE_GL2PS=no
  	DISABLE_GL2PS_REASON="(OpenGL  was not found)"
  else
	AC_LANG([C++])
	HAVE_GL2PS=no
	HAVE_GL2PS_INC=no
	CPPFLAGS="-I$gl2ps/include $CPPFLAGS";
	AC_CHECK_HEADER( [gl2ps.h], [HAVE_GL2PS_INC=yes], [HAVE_GL2PS_INC=no] )
	if test ! -d $gl2ps; then
	   DISABLE_GL2PS_REASON="($gl2ps directory is not exists)"
	   AC_MSG_ERROR([$gl2ps directory is not exists])
	elif test "x$HAVE_GL2PS_INC" = "xyes"; then
	   CSF_GL2PS_INCLUDES=""
	   CSF_OPT_INCLUDES="${CSF_OPT_INCLUDES} -I$gl2ps/include -DHAVE_GL2PS"
	   HAVE_GL2PS_LIB=yes
	   AC_MSG_CHECKING([for gl2psEndPage in -lgl2ps])
	   LDFLAGS="-L$gl2ps/lib $LDFLAGS"
	   LIBS="$CSF_OpenGlLibs_LIB $LIBS"
	   AC_CHECK_LIB( [gl2ps], [gl2psEndPage],
	   [
		CSF_GL2PS_LIB="-L$gl2ps/lib -lgl2ps"
		CSF_OPT_INC="$gl2ps/include:${CSF_OPT_INC}"
		CSF_OPT_LIB="$gl2ps/lib:${CSF_OPT_LIB}"
		HAVE_GL2PS_LIB=yes
	   ],
	   [
		HAVE_GL2PS_LIB=no
	   ])
	fi
	if test "xyes" = "x$HAVE_GL2PS_LIB"; then
	    HAVE_GL2PS=yes
	else
	    HAVE_GL2PS=no
            DISABLE_GL2PS_REASON="(gl2ps was not found)"
	fi
  fi
fi
AM_CONDITIONAL( HAVE_GL2PS, [test "xyes" = "x$HAVE_GL2PS"] )

#---------------------------------------------------------------------
#
# Check for FREEIMAGE Libraries and Includes
#  
#  
#---------------------------------------------------------------------
AC_ARG_WITH([freeimage],
  [AC_HELP_STRING([--with-freeimage=DIR],[Location of freeimage])],
  [freeimage="${withval}"],[freeimage=])

if test "xno" = "xno$freeimage"; then
  # user specified --without-freeimage
  HAVE_FREEIMAGE=no
  DISABLE_FREEIMAGE_REASON="(--with-freeimage=DIR option was not defined)"
else
  CSF_FreeImagePlus_INCLUDES=""
  CSF_FreeImagePlus_LIB=""

  AC_LANG([C++])
  HAVE_FREEIMAGE=no
  HAVE_FREEIMAGE_INC=yes
  CPPFLAGS="-I$freeimage/include $CPPFLAGS";
  AC_CHECK_HEADER( [FreeImage.h], [], [HAVE_FREEIMAGE_INC=no] )
  if test ! -d $freeimage; then
    DISABLE_FREEIMAGE_REASON="($freeimage directory is not exists)"
    AC_MSG_ERROR([$freeimage directory is not exists])
  elif test "x$HAVE_FREEIMAGE_INC" = "xyes"; then
    CSF_FreeImagePlus_INCLUDES=""
    CSF_OPT_INCLUDES="${CSF_OPT_INCLUDES} -I$freeimage/include -DHAVE_FREEIMAGE"
    HAVE_FREEIMAGE_LIB=yes
    AC_MSG_CHECKING([for FreeImage_OpenMemory in -lfreeimageplus])
    LDFLAGS="-L$freeimage/lib $LDFLAGS"
    LIBS="$CSF_FreeImagePlus_LIB $LIBS"
    AC_CHECK_LIB( [freeimageplus], [FreeImage_OpenMemory],
    [
	HAVE_FREEIMAGE_LIB=yes;
	CSF_OPT_INC="$freeimage/include:${CSF_OPT_INC}"
	CSF_OPT_LIB="$freeimage/lib:${CSF_OPT_LIB}"
	CSF_FreeImagePlus_LIB="-L$freeimage/lib -lfreeimageplus"
    ], [HAVE_FREEIMAGE_LIB=no] )
  fi
  if test "xyes" = "x$HAVE_FREEIMAGE_LIB"; then
    HAVE_FREEIMAGE=yes
  else
    HAVE_FREEIMAGE=no
    DISABLE_FREEIMAGE_REASON="(freeimage was not found)"
  fi
fi
AM_CONDITIONAL( HAVE_FREEIMAGE, [test "xyes" = "x$HAVE_FREEIMAGE"] )

#---------------------------------------------------------------------
#
# Check for TBB Includes
#  
#  
#---------------------------------------------------------------------
AC_ARG_WITH([tbb-include],
  [AC_HELP_STRING([--with-tbb-include=DIR],[Location of Intel Threading Building Blocks includes])],
  [tbb_inc="${withval}"],[tbb_inc=])

if test "xno" = "xno$tbb_inc"; then
  # user specified --without-tbb-lib
  HAVE_TBB=no
  HAVE_TBB_INC=no
  DISABLE_TBB_REASON_INC="(--with-tbb-include=DIR option was not defined)"
else
  CSF_TBB_INCLUDES=""
  AC_LANG([C++])
  HAVE_TBB_INC=yes
  if test ! -d $tbb_inc; then
    DISABLE_TBB_REASON_INC="($tbb_inc directory is not exists)"
    AC_MSG_ERROR([$tbb_inc directory is not exists])
  elif test "x$tbb_inc" != "x"; then
     CPPFLAGS="-I$tbb_inc $CPPFLAGS";
  else
     AC_MSG_NOTICE("--with-tbb-include key is not defined")
  fi
  AC_CHECK_HEADER( [tbb/tbb.h], [], [HAVE_TBB_INC=no] )
  if test "x$HAVE_TBB_INC" != "xyes"; then
     AC_MSG_NOTICE("Specify --with-tbb-include to enable TBB support")
     DISABLE_TBB_REASON_INC="(tbb includes were not found)"
  fi
fi

#---------------------------------------------------------------------
#
# Check for OpenCL SDK Includes
#  
#  
#---------------------------------------------------------------------
AC_ARG_WITH([opencl-include],
  [AC_HELP_STRING([--with-opencl-include=DIR],[Location of OpenCL SDK includes])],
  [opencl_inc="${withval}"],[opencl_inc=])

if test "xno" = "xno$opencl_inc"; then
  # user specified --without-opencl-lib
  HAVE_OPENCL=no
  HAVE_OPENCL_INC=no
  DISABLE_OPENCL_REASON_INC="(--with-opencl-include=DIR option was not defined)"
else
  CSF_OPENCL_INCLUDES=""
  AC_LANG([C++])
  HAVE_OPENCL_INC=yes
  if test ! -d $opencl_inc; then
    DISABLE_OPENCL_REASON_INC="($opencl_inc directory is not exists)"
    AC_MSG_ERROR([$opencl_inc directory is not exists])
  elif test "x$opencl_inc" != "x"; then
     CPPFLAGS="-I$opencl_inc $CPPFLAGS";
  else
     AC_MSG_NOTICE("--with-opencl-include key is not defined")
  fi
  # TODO: Add MacOS X specific header check
  AC_CHECK_HEADER( [CL/cl.h], [], [HAVE_OPENCL_INC=no] )
  if test "x$HAVE_OPENCL_INC" != "xyes"; then
     AC_MSG_NOTICE("Specify --with-opencl-include to enable OpenCL support")
     DISABLE_OPENCL_REASON_INC="(OpenCL includes were not found)"
  fi
fi

#---------------------------------------------------------------------
#
# Check for VTK Includes
#  
#  
#---------------------------------------------------------------------
AC_ARG_WITH([vtk-include],
  [AC_HELP_STRING([--with-vtk-include=DIR],[Location of VTK includes])],
  [vtk_inc="${withval}"],[vtk_inc=])

if test "xno$vtk_inc" = "xno"; then
  # user specified --without-vtk-lib
  HAVE_VTK_INC=no
  DISABLE_VTK_REASON="(--with-vtk-include=DIR option was not defined)"
else
  CSF_VTK_INCLUDES=""
  AC_LANG([C++])
  HAVE_VTK_INC=yes
  if test ! -d $vtk_inc; then
    DISABLE_VTK_REASON="($vtk_inc directory does not exists)"
    AC_MSG_ERROR([$vtk_inc directory does not exists])
  elif test ! -f $vtk_inc/vtkVersion.h; then
    DISABLE_VTK_REASON="(vtk headers are not found in $vtk_inc)"
    AC_MSG_ERROR([vtk headers are not found in $vtk_inc])
  elif test "x$vtk_inc" != "x"; then
     CPPFLAGS="-I$vtk_inc $CPPFLAGS";
  else
     HAVE_VTK_INC=no
     DISABLE_VTK_REASON="(--with-vtk-include=DIR option was not defined)"
     AC_MSG_NOTICE("--with-vtk-include=DIR option was not defined")
  fi
fi

#---------------------------------------------------------------------
#
# Check for TBB Libraries
#  
#  
#---------------------------------------------------------------------
AC_ARG_WITH([tbb-library],
  [AC_HELP_STRING([--with-tbb-library=DIR],[Location of Intel Threading Building Blocks libraries])],
  [tbb_lib="${withval}"],[tbb_lib=])

if test "xno" = "xno$tbb_lib"; then
  # user specified --without-tbb
  HAVE_TBB=no
  DISABLE_TBB_REASON_LIB="(--with-tbb-library=DIR option was not defined)"
else
  CSF_TBB_LIB=""
  HAVE_TBB=yes

  if test "x$HAVE_TBB_INC" = "xyes"; then
     if test ! -d $tbb_lib; then
     	DISABLE_TBB_REASON_LIB="($tbb_lib directory is not exists)"
    	AC_MSG_ERROR([$tbb_lib directory is not exists])
     elif test "x$tbb_lib" != "x"; then
     	LDFLAGS="-L$tbb_lib $LDFLAGS"
     fi
     AC_CHECK_LIB([tbb], [TBB_runtime_interface_version], [], [HAVE_TBB=no])
  else
     HAVE_TBB=no
  fi

  if test "x$HAVE_TBB" = "xyes"; then
     if test "x$tbb_inc" != "x"; then
      CSF_TBB_INCLUDES=""
      CSF_OPT_INCLUDES="${CSF_OPT_INCLUDES} -I$tbb_inc -DHAVE_TBB"
     else
	HAVE_TBB=no
     fi
     if test "x$tbb_lib" != "x"; then
       if test "x$enable_debug" = "xyes"; then
        CSF_TBB_LIB="-L$tbb_lib -ltbb_debug -ltbbmalloc_debug"
       else
        CSF_TBB_LIB="-L$tbb_lib -ltbb -ltbbmalloc"
       fi
     else
	HAVE_TBB=no
     fi
     if test "x$HAVE_TBB" = "xyes"; then
     	CSF_OPT_INC="$tbb_inc:${CSF_OPT_INC}"
     	CSF_OPT_LIB="$tbb_lib:${CSF_OPT_LIB}"
     else
	DISABLE_TBB_REASON="(tbb was not found)";
     fi
  else
     AC_MSG_NOTICE("Specify --with-tbb-library to enable TBB support")
     DISABLE_TBB_REASON_LIB="(tbb libraries were not found)"
  fi
fi

AM_CONDITIONAL( HAVE_TBB, [test "xyes" = "x$HAVE_TBB"] )

#---------------------------------------------------------------------
#
# Check for OpenCL SDK Libraries
#  
#  
#---------------------------------------------------------------------
AC_ARG_WITH([opencl-library],
  [AC_HELP_STRING([--with-opencl-library=DIR],[Location of OpenCL SDK libraries])],
  [opencl_lib="${withval}"],[opencl_lib=])

if test "xno" = "xno$opencl_lib"; then
  # user specified --without-opencl
  HAVE_OPENCL=no
  DISABLE_OPENCL_REASON_LIB="(--with-opencl-library=DIR option was not defined)"
else
  CSF_OPENCL_LIB=""
  HAVE_OPENCL=yes

  if test "x$HAVE_OPENCL_INC" = "xyes"; then
    if test ! -d $opencl_lib; then
      DISABLE_OPENCL_REASON_LIB="($opencl_lib directory is not exists)"
      AC_MSG_ERROR([$opencl_lib directory is not exists])
    elif test "x$opencl_lib" != "x"; then
      LDFLAGS="-L$opencl_lib $LDFLAGS"
    fi
    AC_CHECK_LIB(OpenCL, [clGetPlatformInfo], [], [HAVE_OPENCL=no])
  else
    HAVE_OPENCL=no
  fi

  if test "x$HAVE_OPENCL" = "xyes"; then
    if test "x$opencl_inc" != "x"; then
      CSF_OPENCL_INCLUDES=""
      CSF_OPT_INCLUDES="${CSF_OPT_INCLUDES} -I$opencl_inc -DHAVE_OPENCL"
    else
      HAVE_OPENCL=no
    fi
    if test "x$opencl_lib" != "x"; then
      CSF_OPENCL_LIB="-L$opencl_lib -lOpenCL"
    else
      HAVE_OPENCL=no
    fi
    
    if test "x$HAVE_OPENCL" = "xyes"; then
      CSF_OPT_INC="$opencl_inc:${CSF_OPT_INC}"
      CSF_OPT_LIB="$opencl_lib:${CSF_OPT_LIB}"
    else
      DISABLE_OPENCL_REASON="(OpenCL was not found)";
    fi
  else
    AC_MSG_NOTICE("Specify --with-opencl-library to enable OpenCL support")
    DISABLE_OPENCL_REASON_LIB="(OpenCL libraries were not found)"
  fi
fi

AM_CONDITIONAL( HAVE_OPENCL, [test "xyes" = "x$HAVE_OPENCL"] )

#---------------------------------------------------------------------
#
# Check for QT Libraries
#  
#  
#---------------------------------------------------------------------
AC_ARG_WITH([qt],
  [AC_HELP_STRING([--with-qt=QTDIR],[Location of QT])],
  [qt="${withval}"],[qt=])

if test "xno" = "xno$qt"; then
# user specified --without-qt
  HAVE_QT=no
  DISABLE_QT_REASON="(--with-qt=DIR option was not defined)"
else
  CSF_QT_INCLUDES=""
  CSF_QT_LIB=""

  if test "xno" = "x$HAVE_GL"; then
  	HAVE_QT=no
  	DISABLE_QT_REASON="(OpenGL  was not found)"
  else
  	AC_LANG([C++])
  	HAVE_QT=no
  	HAVE_QT_INC=no
	CPPFLAGS="-I$qt/include/QtGui -I$qt/include/QtCore -I$qt/include/Qt -I$qt/include $CPPFLAGS"
  	AC_CHECK_HEADER( [Qt/qpixmap.h], [HAVE_QT_INC=yes], [HAVE_QT_INC=no] )
	if test ! -d $qt; then
	   DISABLE_QT_REASON="($qt directory is not exists)"
	   AC_MSG_ERROR([$qt directory is not exists])
  	elif test "x$HAVE_QT_INC" = "xyes"; then
    	   CSF_QT_INCLUDES="-I$qt/include/QtGui -I$qt/include/QtCore -I$qt/include/Qt -I$qt/include"
    	   HAVE_QT_LIB=yes
    	   AC_MSG_CHECKING([for connect in -lQtGui])
    	   LDFLAGS="-L$qt/lib $LDFLAGS"
   	   LIBS="$CSF_OpenGlLibs_LIB $LIBS"
    	   AC_CHECK_LIB( [QtGui], [connect],
           [
		CSF_QT_LIB="-L$qt/lib -lQtGui -lQtCore"
		CSF_OPT_INC="$qt/include/QtGui:$qt/include/QtCore:$qt/include/Qt:$qt/include:${CSF_OPT_INC}"
		CSF_OPT_LIB="$qt/lib:${CSF_OPT_LIB}"
		HAVE_QT_LIB=yes
	   ],
	   [
		HAVE_QT_LIB=no
	   ])
  	fi
	if test "xyes" = "x$HAVE_QT_LIB"; then
	    HAVE_QT=yes
	else
	    HAVE_QT=no
            DISABLE_QT_REASON="(qt was not found)"
	fi
  fi
fi
AM_CONDITIONAL( HAVE_QT, [test "xyes" = "x$HAVE_QT"] )

AC_LANG([C])

CFLAGS="$CFLAGS_save"
CXXFLAGS="$CXXFLAGS_save"
CPPFLAGS="$CPPFLAGS_save"
LDFLAGS="$LDFLAGS_save"
LIBS="$LIBS_save"

AC_ARG_ENABLE([debug],
              [AC_HELP_STRING([--enable-debug],[Debug Symbols])],
              [enable_debug=${enableval}],[enable_debug=no])
AC_ARG_ENABLE([production],
              [AC_HELP_STRING([--enable-production],[Optimized build (default)])],
              [enable_prod=${enableval}],[enable_prod=])

# Enable production unless enable-default was specified
if test "x$enable_prod" = "x"; then
  if test "x$enable_debug" != "xyes"; then
    enable_prod=yes
  fi
fi

if test "x$enable_prod" = "xyes"; then
  CFLAGS="$CFLAGS -O2"
  CXXFLAGS="$CXXFLAGS -O2"
fi
if test "x$enable_debug" = "xyes"; then
  CFLAGS="$CFLAGS -g"
  CXXFLAGS="$CXXFLAGS -g"
  CPPFLAGS="$CPPFLAGS -DDEB -D_DEBUG"
else
  CPPFLAGS="$CPPFLAGS -DNDEBUG  -DNo_Exception"
fi

#---------------------------------------------------------------------
#
# Check for VTK Libraries
#  
#  
#---------------------------------------------------------------------
AC_ARG_WITH([vtk-library],
  [AC_HELP_STRING([--with-vtk-library=DIR],[Location of VTK libraries])],
  [vtk_lib="${withval}"],[vtk_lib=])

if test "xno" = "xno$vtk_lib"; then
# user specified --without-vtk
  HAVE_VTK=no
  if test "x$DISABLE_VTK_REASON" = "x" ; then
    DISABLE_VTK_REASON="(--with-vtk-library=DIR option was not defined)"
  fi
else
  CSF_VTK_LIB=""
  HAVE_VTK=yes

  #CPP_FLAGS="-I$vtk $CPPFLAGS"
  #AC_CHECK_HEADER( [Vtk/vtkConfigure.h], [HAVE_VTK_INC=yes], [HAVE_VTK_INC=no] )
  if test "x$HAVE_VTK_INC" = "xyes"; then
    if test ! -d $vtk_lib; then
      DISABLE_VTK_REASON="($vtk_lib directory does not exist)"
      AC_MSG_ERROR([$vtk_lib directory does not exist])
    elif test ! -f $vtk_lib/libvtkCommonCore-6.1.so; then
      DISABLE_VTK_REASON="(vtk libraries are not found in $vtk_lib)"
      AC_MSG_ERROR([vtk libraries are not found in $vtk_lib])
    elif test "x$vtk_lib" != "x" -a "x$vtk_inc" != "x"; then
      CSF_VTK_LIB="-L$vtk_lib -lvtkCommonCore-6.1 -lvtkCommonDataModel-6.1 -lvtkCommonExecutionModel-6.1 -lvtkCommonMath-6.1 -lvtkCommonTransforms-6.1 "
      CSF_VTK_LIB="${CSF_VTK_LIB} -lvtkRenderingCore-6.1 -lvtkRenderingOpenGL-6.1  -lvtkFiltersGeneral-6.1 -lvtkIOCore-6.1 -lvtkIOImage-6.1 -lvtkImagingCore-6.1 -lvtkInteractionStyle-6.1 "
      CSF_OPT_INC="$vtk_inc:${CSF_OPT_INC}"
      CSF_OPT_LIB="$vtk_lib:${CSF_OPT_LIB}"
      CSF_OPT_INCLUDES="${CSF_OPT_INCLUDES} -I$vtk_inc -DHAVE_VTK"
    else
      HAVE_VTK=no
      AC_MSG_NOTICE("--with-vtk-library=DIR option was not defined")
      DISABLE_VTK_REASON="(--with-vtk-library=DIR option was not defined)"
    fi
  else
    HAVE_VTK=no
  fi
fi

#CSF_VTK="$CSF_VTK_LIB"
AM_CONDITIONAL( HAVE_VTK, [test "xyes" = "x$HAVE_VTK"] )

#----------------------------------------------------------------------
#
# Enalbe/Disable Modules
#
#----------------------------------------------------------------------
__ENABLEMODULES__
# Process options from above.  The behavior we want is:
#
# ENABLE_X = yes : User specified --enable-x 
#                  print informative error and exit if it cannot be built
#
# ENABLE_X = no :  User specified --disable-x (or --enable-x=no)
#                  silently disable building of component
#
# ENABLE_X =     : User didn't specify either way
#                  Build if possible.  Warn if it cannot be build
#                  because of some missing system requirement.  Inform
#                  if disabled because some other required component 
#                  was disabled.
__CONFMODULES__
# Convert to automake conditional values
__CONDMODULES__
#----------------------------------------------------------------------
#
# Write Output Files
#
#----------------------------------------------------------------------


AC_SUBST(CPPFLAGS)
CXXCPPFLAGS="$CPPFLAGS"
AC_SUBST(CXXCPPFLAGS)
AC_SUBST(CFLAGS)
AC_SUBST(CXXFLAGS)
AC_SUBST(LIBS)
AC_SUBST(LDFLAGS)


CSF_XwLibs_LIB="$X_LIBS"
CSF_MotifLibs_LIB="$X_LIBS"

AC_SUBST(CSF_SOCKETLibs_LIB)
AC_SUBST(CSF_FPELibs_LIB)
AC_SUBST(CSF_OpenGlLibs_INCLUDES)
AC_SUBST(CSF_OpenGlLibs_LIB)
AC_SUBST(HAVE_FREETYPE)
AC_SUBST(CSF_FREETYPE_INCLUDES)
AC_SUBST(CSF_FREETYPE_LIB)
AC_SUBST(HAVE_FTGL)
AC_SUBST(CSF_FTGL_INCLUDES)
AC_SUBST(CSF_FTGL_LIB)
AC_SUBST(HAVE_GL2PS)
AC_SUBST(CSF_GL2PS_INCLUDES)
AC_SUBST(CSF_GL2PS_LIB)
AC_SUBST(HAVE_FREEIMAGE)
AC_SUBST(CSF_FreeImagePlus_INCLUDES)
AC_SUBST(CSF_FreeImagePlus_LIB)
AC_SUBST(CSF_advapi32_LIB)
AC_SUBST(CSF_gdi32_LIB)
AC_SUBST(CSF_user32_LIB)
AC_SUBST(CSF_wsock32_LIB)
AC_SUBST(CSF_XwLibs_LIB)
AC_SUBST(CSF_MotifLibs_LIB)
AC_SUBST(CSF_XmuLibs_LIB)
AC_SUBST(CSF_XmuLibs_INCLUDES)
AC_SUBST(HAVE_TBB)
AC_SUBST(CSF_TBB_INCLUDES)
AC_SUBST(CSF_TBB_LIB)
AC_SUBST(HAVE_OPENCL)
AC_SUBST(CSF_OPENCL_INCLUDES)
AC_SUBST(CSF_OPENCL_LIB)
AC_SUBST(HAVE_QT)
AC_SUBST(CSF_QT_INCLUDES)
AC_SUBST(CSF_QT_LIB)
AC_SUBST(HAVE_VTK)
AC_SUBST(CSF_VTK_INCLUDES)
AC_SUBST(CSF_VTK_LIB)

AC_SUBST(CSF_OPT_INC)
AC_SUBST(CSF_OPT_LIB)
AC_SUBST(CSF_OPT_BIN)

echo
echo "CC       = $CC"
echo "CXX      = $CXX"
echo "CFLAGS   = $CFLAGS"
echo "CXXFLAGS = $CXXFLAGS"
echo "CPPFLAGS = $CPPFLAGS"
echo "LDFLAGS  = $LDFLAGS"
echo 
echo "3rdparty mandatory products       "
echo "---------------------------------"
echo "freetype      : $HAVE_FREETYPE $DISABLE_FREETYPE_REASON"
echo "tcltk         : $HAVE_TCLTK $DISABLE_TCLTK_REASON"
echo
echo "3rdparty optional products       "
echo "---------------------------------"
echo "gl2ps         : $HAVE_GL2PS $DISABLE_GL2PS_REASON"
echo "freeimage     : $HAVE_FREEIMAGE $DISABLE_FREEIMAGE_REASON"
echo "tbb includes  : $HAVE_TBB_INC $DISABLE_TBB_REASON_INC"
echo "tbb libraries : $HAVE_TBB $DISABLE_TBB_REASON_LIB"
echo "opencl        : $HAVE_OPENCL $DISABLE_OPENCL_REASON"
echo "qt            : $HAVE_QT $DISABLE_QT_REASON"
echo "vtk           : $HAVE_VTK $DISABLE_VTK_REASON"
echo
echo "Component                   Build"
echo "--------------------------  -----"
__REPMODULES__
echo

AC_OUTPUT([Makefile adm/lin/amk/Makefile custom.sh \
__ACCONFMODULES__])