root/tags/gdal_1_1_5/configure.in

dnl Process this file with autoconf to produce a configure script.
AC_INIT(GDALmake.opt.in)
AC_CONFIG_HEADER(port/cpl_config.h)

dnl Checks for programs.
AC_PROG_CC
AC_PROG_CXX
AC_PROG_RANLIB

dnl We always want to check /usr/local for stuff.
LIBS="$LIBS -L/usr/local/lib"
CFLAGS="$CFLAGS -I/usr/local/include"
CPPFLAGS="$CPPFLAGS -I/usr/local/include"

dnl Checks for libraries.
AC_CHECK_LIB(dl,dlopen,,,)
AC_CHECK_LIB(dbmalloc,malloc_chain_check,,,)
AC_CHECK_LIB(m,main,,,)

dnl Checks for header files.
AC_HEADER_STDC
AC_CHECK_HEADERS(fcntl.h unistd.h dbmalloc.h dlfcn.h)

dnl Checks for library functions.
MY_TEST_BIGENDIAN
AC_FUNC_VPRINTF
AC_CHECK_FUNC(vsnprintf, AC_DEFINE(HAVE_VSNPRINTF))

dnl Check for 64 bit file API
AC_HAVE_LONG_LONG
AC_UNIX_STDIO_64

OPT_GDAL_FORMATS=
EXTRA_INCLUDES=


dnl ---------------------------------------------------------------------------
dnl Check if libz is available.
dnl ---------------------------------------------------------------------------

AC_ARG_WITH(libz,[  --with-libz[=ARG]       Include libz support (ARG=internal or libz directory)],,)

if test "$with_libz" = "external" -o "$with_libz" = "" ; then

  AC_CHECK_LIB(z,deflateInit_,LIBZ_SETTING=external,LIBZ_SETTING=internal,)

  if test "$LIBZ_SETTING" = "external" ; then   
    LIBS="-lz $LIBS"
  else
    echo "Using internal libz implementation."
  fi

elif test "$with_libz" = "internal" ; then
  LIBZ_SETTING=internal
  echo "Using internal libz implementation."

else

  LIBZ_SETTING=external
  LIBS="-L$with_libz -L$with_libz -lz $LIBS"

  echo "using $with_libz for libz."
fi

AC_SUBST(LIBZ_SETTING,$LIBZ_SETTING)

if test "$LIBZ_SETTING" = "internal" ; then
  OPT_GDAL_FORMATS="zlib $OPT_GDAL_FORMATS"
fi

dnl ---------------------------------------------------------------------------
dnl Check if GRASS library is available.
dnl ---------------------------------------------------------------------------

AC_ARG_WITH(grass,[  --with-grass[=ARG]      Include GRASS support (ARG=no or libgrass path)],,)

if test "$with_grass" = "no" ; then

  GRASS_SETTING=no

  echo "GRASS support disabled."

elif test "$with_grass" = "yes" -o "$with_grass" = "" ; then

  AC_CHECK_LIB(grass5,G_gisinit_2,GRASS_SETTING=external,GRASS_SETTING=no,)

  if test "$GRASS_SETTING" = "external" ; then   
    LIBS="-lgrass5 $LIBS"
  fi

else

  GRASS_SETTING=external
  LIBS="-L$with_grass -L$with_grass/lib -lgrass5 $LIBS"
  EXTRA_INCLUDES="-I$with_grass -I$with_grass/include $EXTRA_INCLUDES"

  echo "using libgrass from $with_grass."
fi

AC_SUBST(GRASS_SETTING,$GRASS_SETTING)

if test "$GRASS_SETTING" != "no" ; then
  OPT_GDAL_FORMATS="grass $OPT_GDAL_FORMATS"
fi

dnl ---------------------------------------------------------------------------
dnl Check if cfitsio library is available.
dnl ---------------------------------------------------------------------------

AC_ARG_WITH(cfitsio,[  --with-cfitsio[=ARG]      Include FITS support (ARG=no or libcfitsio path)],,)

if test "$with_cfitsio" = "no" ; then

  FITS_SETTING=no

  echo "FITS support disabled."

elif test "$with_cfitsio" = "yes" -o "$with_cfitsio" = "" ; then

  AC_CHECK_LIB(cfitsio,ffopen,FITS_SETTING=external,FITS_SETTING=no,)

  if test "$FITS_SETTING" = "external" ; then   
    LIBS="-lcfitsio $LIBS"
    echo "using pre-installed libcfitsio."
  else
    echo "libcfitsio not found - FITS support disabled"
  fi

else

  FITS_SETTING=external
  LIBS="-L$with_cfitsio -L$with_cfitsio/lib -lcfitsio $LIBS"
  EXTRA_INCLUDES="-I$with_cfitsio -I$with_cfitsio/include $EXTRA_INCLUDES"

  echo "using libcfitsio from $with_cfitsio."
fi

AC_SUBST(FITS_SETTING,$FITS_SETTING)

if test "$FITS_SETTING" != "no" ; then
  OPT_GDAL_FORMATS="fits $OPT_GDAL_FORMATS"
fi

dnl ---------------------------------------------------------------------------
dnl Select a PNG Library to use, or disable driver.
dnl ---------------------------------------------------------------------------

AC_ARG_WITH(png,[  --with-png[=ARG]        Include PNG support (ARG=internal, no or path)],,)

if test "$with_png" = "no" ; then

  PNG_SETTING=no

  echo "png support disabled."

elif test "$with_png" = "yes" -o "$with_png" = "" ; then

  AC_CHECK_LIB(png,png_set_IHDR,PNG_SETTING=external,PNG_SETTING=internal,$LIBS)
  AC_CHECK_HEADERS(png.h)

  if test "$PNG_SETTING" = "external" -a "$ac_cv_header_png_h" = "no" ; then   
    PNG_SETTING=internal
  fi
  if test "$PNG_SETTING" = "external" ; then   
    LIBS="-lpng $LIBS"
    echo "using pre-installed libpng."
  else
    echo "using internal png code."
  fi

elif test "$with_png" = "internal" ; then

  PNG_SETTING=internal

  echo "using internal png code."

else

  PNG_SETTING=external
  LIBS="-L$with_png -L$with_png/lib -lpng $LIBS"
  EXTRA_INCLUDES="-I$with_png -I$with_png/include $EXTRA_INCLUDES"

  echo "using libpng from $with_png."

fi

AC_SUBST(PNG_SETTING,$PNG_SETTING)

if test "$PNG_SETTING" != "no" ; then
  OPT_GDAL_FORMATS="png $OPT_GDAL_FORMATS"
fi

dnl ---------------------------------------------------------------------------
dnl Select a libtiff library to use.
dnl ---------------------------------------------------------------------------

AC_ARG_WITH(libtiff,[  --with-libtiff=ARG      Libtiff library to use (ARG=internal, yes or path)],,)

if test "$with_libtiff" = "yes" -o "$with_libtiff" = "" ; then

  AC_CHECK_LIB(tiff,TIFFWriteCheck,TIFF_SETTING=external,TIFF_SETTING=internal,)

  dnl Cygwin takes a somewhat restrictive view of what should be exported
  dnl from the dll, so don't use the external library if missing semi-private
  dnl functions.
  if test "$TIFF_SETTING" = "external" ; then
    AC_CHECK_LIB(tiff,_TIFFsetDoubleArray,TIFF_SETTING=external,TIFF_SETTING=internal,)
  fi

  if test "$TIFF_SETTING" = "external" ; then   
    LIBS="-ltiff $LIBS"
    echo "using pre-installed libtiff."
  else
    echo "using internal TIFF code."
  fi

elif test "$with_libtiff" = "internal" ; then

  TIFF_SETTING=internal

  echo "using internal TIFF code."

else

  TIFF_SETTING=external
  if test -r $with_libtiff/tiff.h ; then
    LIBS="-L$with_libtiff -ltiff $LIBS"
    EXTRA_INCLUDES="-I$with_libtiff $EXTRA_INCLUDES"
  else
    LIBS="-L$with_libtiff/lib -ltiff $LIBS"
    EXTRA_INCLUDES="-I$with_libtiff/include $EXTRA_INCLUDES"
  fi

  echo "using libtiff from $with_libtiff."
fi

AC_SUBST(TIFF_SETTING,$TIFF_SETTING)

dnl ---------------------------------------------------------------------------
dnl Select a libgeotiff library to use.
dnl ---------------------------------------------------------------------------

AC_ARG_WITH(geotiff,[  --with-geotiff=ARG      Libgeotiff library to use (ARG=internal, yes or path)],,)

if test "$with_geotiff" = "yes" -o "$with_geotiff" = "" ; then

  AC_CHECK_LIB(geotiff,GTIFGetDefn,GEOTIFF_SETTING=external,GEOTIFF_SETTING=internal,)

  if test "$GEOTIFF_SETTING" = "external" ; then   
    LIBS="-lgeotiff $LIBS"
    echo "using pre-installed libgeotiff."
  else
    echo "using internal GeoTIFF code."
  fi

elif test "$with_geotiff" = "internal" ; then

  GEOTIFF_SETTING=internal

  echo "using internal GeoTIFF code."

else

  GEOTIFF_SETTING=external
  if test -r $with_geotiff/libgeotiff.a ; then
    LIBS="-L$with_geotiff -lgeotiff $LIBS"
    EXTRA_INCLUDES="-I$with_libtiff $EXTRA_INCLUDES"
  else
    LIBS="-L$with_geotiff/lib -lgeotiff $LIBS"
    EXTRA_INCLUDES="-I$with_libtiff/include $EXTRA_INCLUDES"
  fi

  echo "using libgeotiff from $with_geotiff."
fi

AC_SUBST(GEOTIFF_SETTING,$GEOTIFF_SETTING)

dnl ---------------------------------------------------------------------------
dnl Select a JPEG Library to use, or disable driver.
dnl ---------------------------------------------------------------------------

AC_ARG_WITH(jpeg,[  --with-jpeg[=ARG]       Include JPEG support (ARG=internal, no or path)],,)

if test "$with_jpeg" = "no" ; then

  JPEG_SETTING=no

  echo "jpeg support disabled."

elif test "$with_jpeg" = "yes" -o "$with_jpeg" = "" ; then

  AC_CHECK_LIB(jpeg,jpeg_read_scanlines,JPEG_SETTING=external,JPEG_SETTING=internal,)
  AC_CHECK_HEADERS(jpeglib.h)

  if test "$JPEG_SETTING" = "external" -a "$ac_cv_header_jpeglib_h" = "no" ; then
    JPEG_SETTING=internal
  fi

  if test "$JPEG_SETTING" = "external" -a "$TIFF_SETTING" = "internal" ; then
    AC_MSG_CHECKING([for width_in_blocks in jpeglib.h])

    rm -f conftest.c
    echo '#include "jpeglib.h"' >> conftest.c
    echo 'int main() { jpeg_component_info *compptr=0; int i; i = comptr->width_in_blocks; }' >> conftest.c
    if test -z "`${CC} -o conftest conftest.c 2>&1`" ; then
      AC_MSG_RESULT([yes])
    else
      AC_MSG_RESULT([no])
      JPEG_SETTING=internal
    fi
    rm -f conftest*
  fi

  if test "$JPEG_SETTING" = "external" ; then   
    LIBS="-ljpeg $LIBS"
    echo "using pre-installed libjpeg."
  else
    echo "using internal jpeg code."
  fi

elif test "$with_jpeg" = "internal" ; then

  JPEG_SETTING=internal

  echo "using internal jpeg code."

else

  JPEG_SETTING=external
  LIBS="-L$with_jpeg -L$with_jpeg/lib -ljpeg $LIBS"
  EXTRA_INCLUDES="-I$with_jpeg -I$with_jpeg/include $EXTRA_INCLUDES"

  echo "using libjpeg from $with_jpeg."

fi

AC_SUBST(JPEG_SETTING,$JPEG_SETTING)

if test "$JPEG_SETTING" != "no" ; then
  OPT_GDAL_FORMATS="jpeg $OPT_GDAL_FORMATS"
fi

dnl ---------------------------------------------------------------------------
dnl Select a GIF Library to use, or disable driver.
dnl ---------------------------------------------------------------------------

AC_ARG_WITH(gif,[  --with-gif[=ARG]        Include GIF support (ARG=internal, no or path)],,)

if test "$with_gif" = "no" ; then

  GIF_SETTING=no

  echo "gif support disabled."

elif test "$with_gif" = "yes" -o "$with_gif" = "" ; then

  AC_CHECK_LIB(gif,DGifOpenFileName,GIF_SETTING=external,GIF_SETTING=internal,)

  if test "$GIF_SETTING" = "external" ; then   
    LIBS="-lgif $LIBS"
    echo "using pre-installed libgif."
  else
    echo "using internal gif code."
  fi

elif test "$with_gif" = "internal" ; then

  GIF_SETTING=internal

  echo "using internal gif code."

else

  GIF_SETTING=external
  LIBS="-L$with_gif -L$with_gif/lib -lgif $LIBS"
  EXTRA_INCLUDES="-I$with_gif -I$with_gif/include $EXTRA_INCLUDES"

  echo "using libgif from $with_gif."

fi

AC_SUBST(GIF_SETTING,$GIF_SETTING)

if test "$GIF_SETTING" != "no" ; then
  OPT_GDAL_FORMATS="gif $OPT_GDAL_FORMATS"
fi

dnl ---------------------------------------------------------------------------
dnl Select an OGDI Library to use, or disable driver.
dnl ---------------------------------------------------------------------------

OGDI_INCLUDE=
export OGDI_INCLUDE

AC_ARG_WITH(ogdi,[  --with-ogdi[=ARG]       Include OGDI support (ARG=path)],,)

if test "$with_ogdi" = "no" ; then

  HAVE_OGDI=no

  echo "ogdi support disabled."

elif test "$with_ogdi" = "yes" -o "$with_ogdi" = "" ; then

  AC_CHECK_LIB(ogdi,cln_GetLayerCapabilities,HAVE_OGDI=yes,HAVE_OGDI=no,)

  if test "$HAVE_OGDI" = "yes" ; then   
    LIBS="-logdi $LIBS"
  fi

else

  HAVE_OGDI=yes
  LIBS="-L$with_ogdi -L$with_ogdi/lib -logdi $LIBS"
  OGDI_INCLUDE="-I$with_ogdi -I$with_ogdi/include"

  echo "using libogdi from $with_ogdi."

fi

AC_SUBST(HAVE_OGDI,$HAVE_OGDI)
AC_SUBST(OGDI_INCLUDE,$OGDI_INCLUDE)

if test "$HAVE_OGDI" != "no" ; then
  OPT_GDAL_FORMATS="ogdi $OPT_GDAL_FORMATS"
fi

dnl ---------------------------------------------------------------------------

AC_SUBST(OPT_GDAL_FORMATS,$OPT_GDAL_FORMATS)
AC_SUBST(EXTRA_INCLUDES,$EXTRA_INCLUDES)

dnl ---------------------------------------------------------------------------

AC_ARG_WITH(ogr,[  --without-ogr           Don't build OGR into shared library],,)

if test "$with_ogr" = yes -o x"$with_ogr" = x ; then
  echo checking for OGR ... enabled
  OGR_ENABLED=yes
else
  echo checking for OGR ... disabled by user
  OGR_ENABLED=no
fi
AC_SUBST(OGR_ENABLED,$OGR_ENABLED)

dnl ---------------------------------------------------------------------------
dnl Select an PostgreSQL Library to use, or disable driver.
dnl ---------------------------------------------------------------------------

PG_CONFIG=no

AC_ARG_WITH(pg,[  --with-pg[=ARG]         Include PostgreSQL OGR Support (ARG=path to pg_config)],,)

if test "$with_pg" = "yes" -o "$with_pg" = "" ; then
  AC_PATH_PROG(PG_CONFIG, pg_config, no)
else 
  PG_CONFIG=$with_pg
fi

AC_MSG_CHECKING([for PostgreSQL])

if test "$PG_CONFIG" = "no" ; then

  HAVE_PG=no
  PG_LIB=
  PG_INC=

  AC_MSG_RESULT([no])

else

  HAVE_PG=yes
  PG_LIB="-L`$PG_CONFIG --libdir` -lpq"
  PG_INC="-I`$PG_CONFIG --includedir`"

  AC_MSG_RESULT([yes])

fi

AC_SUBST(HAVE_PG,$HAVE_PG)
AC_SUBST(PG_INC,$PG_INC)
AC_SUBST(PG_LIB,$PG_LIB)

dnl ---------------------------------------------------------------------------

AC_COMPILER_WFLAGS
AC_COMPILER_PIC
AC_LD_SHARED

dnl ---------------------------------------------------------------------------
dnl Python Checks
dnl ---------------------------------------------------------------------------

AC_ARG_WITH(python,[  --without-python        Disable Python],,)

AM_PATH_PYTHON
AM_INIT_PYEXEC_MOD
AM_CHECK_NUMPY

AC_OUTPUT(GDALmake.opt)