root/tags/rel-5-0-2/mapserver/configure.in

dnl **************************************************************************
dnl $Id$
dnl
dnl Project:  MapServer
dnl Purpose:  Main autoconf script ( Process this file with autoconf to 
dnl           produce a configure script.)
dnl Author:   Steve Lime and the MapServer team.
dnl
dnl **************************************************************************
dnl Copyright (c) 1996-2007 Regents of the University of Minnesota.
dnl
dnl Permission is hereby granted, free of charge, to any person obtaining a
dnl copy of this software and associated documentation files (the "Software"),
dnl to deal in the Software without restriction, including without limitation
dnl the rights to use, copy, modify, merge, publish, distribute, sublicense,
dnl and/or sell copies of the Software, and to permit persons to whom the
dnl Software is furnished to do so, subject to the following conditions:
dnl
dnl The above copyright notice and this permission notice shall be included in 
dnl all copies of this Software or works derived from this Software.
dnl
dnl THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
dnl OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
dnl FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
dnl THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
dnl LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
dnl FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
dnl DEALINGS IN THE SOFTWARE.
dnl **************************************************************************

AC_INIT(Makefile.in)

dnl Checks for programs.
AC_PROG_CC
AC_PROG_CXX
AC_PROG_RANLIB
AC_PROG_LEX
AC_PROG_YACC
AC_RUNPATH_SWITCH

dnl ---------------------------------------------------------------------
dnl Checks for libraries.
dnl ---------------------------------------------------------------------
AC_CHECK_LIB(m,exp, XTRALIBS="$XTRALIBS -lm",,)
AC_SUBST(XTRALIBS, $XTRALIBS)

AC_CHECK_LIB(stdc++,__gxx_personality_v0, XTRALIBS="$XTRALIBS -lstdc++",,)
AC_SUBST(XTRALIBS, $XTRALIBS)

LIBS="$XTRALIBS $LIBS"

dnl ---------------------------------------------------------------------
dnl Checks for header files.
dnl ---------------------------------------------------------------------
AC_HEADER_STDC

dnl ---------------------------------------------------------------------
dnl Add -fPIC to compiler flags if appropriate
dnl ---------------------------------------------------------------------
AC_COMPILER_PIC
CFLAGS="$CFLAGS $C_PIC"
CXXFLAGS="$CXXFLAGS $C_PIC"

dnl ---------------------------------------------------------------------
dnl Check for some string functions
dnl ---------------------------------------------------------------------
AC_CHECK_FUNC(strcasecmp, ,  STRINGS="-DNEED_STRCASECMP $STRINGS")
AC_CHECK_FUNC(strncasecmp, , STRINGS="-DNEED_STRNCASECMP $STRINGS")
AC_CHECK_FUNC(strdup, ,      STRINGS="-DNEED_STRDUP $STRINGS")
AC_CHECK_FUNC(strlcat, ,      STRINGS="-DNEED_STRLCAT $STRINGS")
AC_CHECK_FUNC(vsnprintf, STRINGS="-DHAVE_VSNPRINTF $STRINGS", )
AC_SUBST(STRINGS, $STRINGS)

dnl ---------------------------------------------------------------------
dnl Look for MapServer version in mapserver.h
dnl ---------------------------------------------------------------------
MS_VERSION=`grep MS_VERSION mapserver.h | grep '#define' | cut -d\" -f2`
AC_MSG_RESULT([MapServer Version from mapserver.h: '$MS_VERSION'])
AC_SUBST(MS_VERSION,    "$MS_VERSION")

dnl ---------------------------------------------------------------------
dnl Several libraries might be needed for GD: png, zlib, freetype,
dnl and jpeg (processed above).  Use where GD was found as default.
dnl ---------------------------------------------------------------------

dnl ---------------------------------------------------------------------
dnl Check where FreeType is installed
dnl ---------------------------------------------------------------------

unset ac_cv_lib_freetype_FT_Init_FreeType
unset ac_cv_lib_ttf_TT_Init_FreeType

AC_ARG_WITH(freetype,
[  --with-freetype=DIR     GD: Specify where FreeType 2.x is installed (DIR is
                              path to freetype-config program or install dir).],
    FT_DIR=$withval,FT_DIR='')

AC_EXPAND_PATH($FT_DIR, FT_DIR)
AC_CHECKING(where FreeType 2.x is installed)
FT_LIB=''
FT_BIN=''
FT_TYPE=''

test -x "$FT_DIR" -a "freetype-config" = "`basename $FT_DIR ''`" && FT_BIN="$FT_DIR"
test -x "$FT_DIR/freetype-config" && FT_BIN="$FT_DIR/freetype-config"
test -x "$FT_DIR/bin/freetype-config" && FT_BIN="$FT_DIR/bin/freetype-config"

if test "$with_freetype" = "yes" ; then
 AC_PATH_PROG(FT_BIN, freetype-config, no)
fi

if test -n "$FT_BIN" ; then
  dnl we have freetype-config program, use its values
  FT_LIB=`$FT_BIN --libs`
  FT_LIBDIR="`$FT_BIN --exec-prefix`/lib"
  AC_MSG_RESULT([        using libfreetype from $FT_LIB])
  AC_ADD_RUNPATH("$FT_LIBDIR")

else
  dnl try freetype 2.x install lib name
  test -f $FT_DIR/lib/libfreetype.a -o -f $FT_DIR/lib/libfreetype.so -o -f $FT_DIR/lib/libfreetype.sl -o -f $FT_DIR/lib/libfreetype.dylib && FT_LIBDIR="$FT_DIR/lib"
  test -f $FT_DIR/lib64/libfreetype.a -o -f $FT_DIR/lib64/libfreetype.so -o -f $FT_DIR/lib64/libfreetype.sl && FT_LIBDIR="$FT_DIR/lib64"
  test -f $FT_DIR/libfreetype.a -o -f $FT_DIR/libfreetype.so -o -f $FT_DIR/libfreetype.sl -o -f $FT_DIR/libfreetype.dylib && FT_LIBDIR="$FT_DIR"

  if test -n "$FT_LIBDIR" ; then
     FT_TYPE="-lfreetype"  
  fi
fi

if test -n "$FT_LIBDIR" -a -z "$FT_BIN" ; then
  FT_LIB="-L$FT_LIBDIR $FT_TYPE"
  AC_MSG_RESULT([        using libfreetype from $FT_LIB])
  AC_ADD_RUNPATH("$FT_LIBDIR")
else
  dnl check for lib in system libs  
  AC_CHECK_LIB(freetype, FT_Init_FreeType, FT_LIB="-lfreetype",,)

  if test -n "$FT_LIB" ; then
    AC_MSG_RESULT([        using libfreetype $FT_LIB from system libs.])
  else
    AC_MSG_RESULT([        freetype-config or libfreetype cannot be found, possibly needed for GD])
  fi
fi


dnl ---------------------------------------------------------------------
dnl Check where zlib is installed (used by libpng and by ZVG compressed output)
dnl ---------------------------------------------------------------------

unset ac_cv_lib_z_zlibVersion

AC_ARG_WITH(zlib,
[  --with-zlib=DIR         GD,SVG: Specify where zlib is installed (DIR is path
                              to zlib install dir).],
    ZLIB_DIR=$withval,ZLIB_DIR='')

AC_EXPAND_PATH($ZLIB_DIR, ZLIB_DIR)
AC_CHECKING(where Zlib is installed)
ZLIB_LIB=''

test -f $ZLIB_DIR/include/zlib.h && ZLIB_INCDIR="$ZLIB_DIR/include"

test -f $ZLIB_DIR/lib/libz.a -o -f $ZLIB_DIR/lib/libz.so -o -f $ZLIB_DIR/lib/libz.sl -o -f $ZLIB_DIR/lib/libz.dylib && ZLIB_LIBDIR="$ZLIB_DIR/lib"
test -f $ZLIB_DIR/lib64/libz.a -o -f $ZLIB_DIR/lib64/libz.so -o -f $ZLIB_DIR/lib64/libz.sl && ZLIB_LIBDIR="$ZLIB_DIR/lib64"
test -f $ZLIB_DIR/libz.a -o -f $ZLIB_DIR/libz.so -o -f $ZLIB_DIR/libz.sl && ZLIB_LIBDIR="$ZLIB_DIR"


if test -n "$ZLIB_LIBDIR" -a -n "$ZLIB_INCDIR" ; then

  dnl
  dnl Found libz runtime and headers. Enable USE_ZLIB (SVG compressed output)
  dnl
  ZLIB_ENABLED="-DUSE_ZLIB"
  ZLIB_INC="-I$ZLIB_INCDIR"
  ZLIB_LIB="-L$ZLIB_LIBDIR -lz"
  AC_MSG_RESULT([        using libz from $ZLIB_LIB ($ZLIB_ENABLED)])
  AC_ADD_RUNPATH("$ZLIB_DIR")

elif test -n "$ZLIB_LIBDIR" ; then

  dnl
  dnl Found only runtime but no headers (good only for libpng)
  dnl
  ZLIB_LIB="-L$ZLIB_LIBDIR -lz"
  AC_MSG_RESULT([        using runtime libz from $ZLIB_LIB])
  AC_ADD_RUNPATH("$ZLIB_DIR")

else

  dnl check for lib in system libs

  AC_CHECK_LIB(z, zlibVersion, ZLIB_LIB="-lz",,)

  if test -n "$ZLIB_LIB" ; then
    ZLIB_ENABLED="-DUSE_ZLIB"
    AC_MSG_RESULT([        using libz from system libs ($ZLIB_ENABLED).])
  else
    AC_MSG_RESULT([        Zlib (libz) library cannot be found, possibly needed for GD])
  fi

fi

dnl If we found ZLIB headers then enable it by default since SVG output
dnl is enabled by default and will take advantage of it, otherwise the 
dnl PNG code below will take care of including the runtime lib only.

AC_SUBST(ZLIB_ENABLED,$ZLIB_ENABLED)
AC_SUBST(ZLIB_INC,    $ZLIB_INC)
AC_SUBST(ZLIB_LIB,    $ZLIB_LIB)

ALL_ENABLED="$ZLIB_ENABLED $ALL_ENABLED"
ALL_INC="$ZLIB_INC $ALL_INC"
ALL_LIB="$ZLIB_LIB $ALL_LIB"

dnl ---------------------------------------------------------------------
dnl Check where PNG is installed
dnl ---------------------------------------------------------------------

unset ac_cv_lib_png_png_init_io

AC_ARG_WITH(png,
[  --with-png=DIR          GD: Specify where PNG is installed (DIR is path to
                              PNG install dir).],
    PNG_DIR=$withval,PNG_DIR='')

AC_EXPAND_PATH($PNG_DIR, PNG_DIR)
AC_CHECKING(where PNG is installed)
PNG_LIB=''

test -f $PNG_DIR/lib/libpng.a -o -f $PNG_DIR/lib/libpng.so -o -f $PNG_DIR/lib/libpng.sl -o -f $PNG_DIR/lib/libpng.dylib && PNG_LIBDIR="$PNG_DIR/lib"
test -f $PNG_DIR/lib64/libpng.a -o -f $PNG_DIR/lib64/libpng.so -o -f $PNG_DIR/lib64/libpng.sl -o -f $PNG_DIR/libpng.dylib && PNG_LIBDIR="$PNG_DIR/lib64"
test -f $PNG_DIR/libpng.a -o -f $PNG_DIR/libpng.so -o -f $PNG_DIR/libpng.sl -o -f $PNG_DIR/libpng.dylib && PNG_LIBDIR="$PNG_DIR"

if test -n "$PNG_LIBDIR" ; then

  PNG_LIB="-L$PNG_LIBDIR -lpng"
  AC_MSG_RESULT([        using libpng from $PNG_LIB])
  AC_ADD_RUNPATH("$PNG_LIBDIR")

else

  dnl check for lib in system libs

  AC_CHECK_LIB(png, png_init_io, PNG_LIB="-lpng",, $ZLIB_LIB)

  if test -n "$PNG_LIB" ; then
    AC_MSG_RESULT([        using libpng from system libs.])
  else
    AC_MSG_RESULT([        PNG (libpng) library cannot be found, possibly needed for GD])
  fi

fi

dnl ---------------------------------------------------------------------
dnl libJPEG (included by default if found on system).
dnl ---------------------------------------------------------------------

unset ac_cv_lib_jpeg_jpeg_read_header

AC_CHECKING(whether we should include JPEG support)
AC_ARG_WITH(jpeg,
[  --with-jpeg[[=DIR]]       Include JPEG support (DIR is LibJPEG's install dir).],,)

if test -n "$with_jpeg" -a "$with_jpeg" != "yes" ; then

  AC_EXPAND_PATH($with_jpeg, JPEG_DIR)
  test -f $JPEG_DIR/include/jpeg/jpeglib.h && JPEG_INCLUDE="$JPEG_DIR/include/jpeg"
  test -f $JPEG_DIR/include/jpeglib.h && JPEG_INCLUDE="$JPEG_DIR/include"
  test -f $JPEG_DIR/lib/jpeglib.h && JPEG_INCLUDE="$JPEG_DIR/lib"
  test -f $JPEG_DIR/jpeglib.h && JPEG_INCLUDE="$JPEG_DIR"

  test -f $JPEG_DIR/lib/libjpeg.a && JPEG_LIBDIR="$JPEG_DIR/lib"
  test -f $JPEG_DIR/lib64/libjpeg.a && JPEG_LIBDIR="$JPEG_DIR/lib64"
  test -f $JPEG_DIR/libjpeg.a && JPEG_LIBDIR="$JPEG_DIR"

  test -f $JPEG_DIR/lib/libjpeg.so -o -f $JPEG_DIR/lib/libjpeg.sl -o -f $JPEG_DIR/lib/libjpeg.dylib && JPEG_LIBDIR="$JPEG_DIR/lib"
  test -f $JPEG_DIR/lib64/libjpeg.so -o -f $JPEG_DIR/lib64/libjpeg.sl && JPEG_LIBDIR="$JPEG_DIR/lib64"
  test -f $JPEG_DIR/libjpeg.so -o -f $JPEG_DIR/libjpeg.sl -o -f $JPEG_DIR/libjpeg.dylib && JPEG_LIBDIR="$JPEG_DIR"

  if test -n "$JPEG_INCLUDE" -a -n "$JPEG_LIBDIR" ; then
      JPEG_ENABLED="-DUSE_JPEG"
      JPEG_INC=-I$JPEG_INCLUDE
      JPEG_LIB="-L$JPEG_LIBDIR -ljpeg"
      AC_ADD_RUNPATH("$JPEG_LIBDIR")
  else
      if test "$with_jpeg" != "no" ; then
        AC_MSG_RESULT("Could not find jpeglib.h or libjpeg.a/libjpeg.so/libjpeg.dylib in $JPEG_DIR.")
      fi
  fi

  dnl if --without-jpeg was requested, disable mapserver from using it, but
  dnl libjpeg may still be needed by GD

  if test "$with_jpeg" = "no" ; then
    AC_MSG_RESULT([        disabled by --without-jpeg])
  else
    JPEG_ENABLED="-DUSE_JPEG"
  fi

  if test -z "$JPEG_LIB" ; then

    AC_CHECK_LIB(jpeg, jpeg_read_header, JPEG_LIB="-ljpeg",,,)

    if test -n "$JPEG_LIB" ; then
        JPEG_LIB="-ljpeg"
        AC_MSG_RESULT([        using libjpeg from system libs.])
    else
        AC_MSG_RESULT([        libjpeg not found. JPEG support not included, possibly needed for GD.])
    fi
  else
     AC_MSG_RESULT([        using libjpeg from system $JPEG_LIB])
  fi

else

  AC_CHECK_LIB(jpeg, jpeg_read_header, JPEG_ENABLED=-DUSE_JPEG,,,)

  if test -n "$JPEG_ENABLED" ; then
      JPEG_LIB="-ljpeg"
      AC_MSG_RESULT([        using libjpeg from system libs.])
  else
      AC_MSG_RESULT([        libjpeg not found. JPEG support not included, possibly needed for GD.])
  fi

fi

AC_SUBST(JPEG_ENABLED,$JPEG_ENABLED)
AC_SUBST(JPEG_INC,    $JPEG_INC)
AC_SUBST(JPEG_LIB,    $JPEG_LIB)

dnl ---------------------------------------------------------------------
dnl Look for X11 and XPM libs used by GD
dnl ---------------------------------------------------------------------

unset ac_cv_lib_Xpm_XpmFreeXpmImage

AC_ARG_WITH(xpm,
[  --with-xpm=DIR          GD: Specify where libXpm is installed (DIR it the 
                              libXpm install prefix).],
    XPM_DIR=$withval,XPM_DIR='')

if test "$with_xpm" != "no" ; then

  AC_EXPAND_PATH($XPM_DIR, XPM_DIR)
  AC_CHECKING(where libXpm is installed)
  XPM_LIB=''

  test -f $XPM_DIR/lib/libXpm.a -o -f $XPM_DIR/lib/libXpm.so -o -f $XPM_DIR/lib/libXpm.sl -o -f $XPM_DIR/lib/libXpm.dylib && XPM_LIBDIR="$XPM_DIR/lib"
  test -f $XPM_DIR/lib64/libXpm.a -o -f $XPM_DIR/lib64/libXpm.so -o -f $XPM_DIR/lib64/libXpm.sl && XPM_LIBDIR="$XPM_DIR/lib64"
  test -f $XPM_DIR/libXpm.a -o -f $XPM_DIR/libXpm.so -o -f $XPM_DIR/libXpm.sl -o -f $XPM_DIR/libXpm.dylib && XPM_LIBDIR="$XPM_DIR"

  if test -n "$XPM_LIBDIR" ; then

    XPM_LIB="-L$XPM_LIBDIR -lXpm -lX11"
    AC_MSG_RESULT([        using libXpm from $XPM_LIB])
    AC_ADD_RUNPATH("$XPM_LIBDIR")

  else
  
    dnl check for lib in system libs

    AC_CHECK_LIB(Xpm, XpmFreeXpmImage, XPM_LIB="-lXpm -lX11",,-lX11)

    if test -n "$XPM_LIB" ; then
      AC_MSG_RESULT([        using libXpm from system libs.])
    else
      AC_MSG_RESULT([        XPM (libXpm) library cannot be found, possibly needed for GD])
    fi
  fi

fi

dnl Note: don't include iconv by default in GD_XTRA_LIBS as it may not
dnl       be required by GD.

GD_XTRA_LIBS="$JPEG_LIB $FT_LIB $PNG_LIB $ZLIB_LIB $XPM_LIB"


dnl ---------------------------------------------------------------------
dnl Check where libiconv is installed. We always look for it, even if not
dnl explicitly requested since GD may require it for linking.
dnl Iconv can come either as libiconv.so or as part of glibc
dnl ---------------------------------------------------------------------

unset ac_cv_lib_iconv_libiconv_open
unset ac_cv_lib_c_iconv_open

AC_ARG_WITH(libiconv,
[  --with-libiconv=DIR     Specify where libiconv is installed (DIR is path
                          to libiconv install dir (prefix)).],
    ICONV_DIR=$withval,ICONV_DIR='')

AC_CHECKING(where libiconv is installed)

ICONV_LIB=''

if test -n "$ICONV_DIR" ; then

  AC_EXPAND_PATH($ICONV_DIR, ICONV_DIR)

  test -f $ICONV_DIR/include/iconv.h && ICONV_LIBDIR="$ICONV_DIR/lib" && ICONV_INCDIR="$ICONV_DIR/include"
  test -f $ICONV_DIR/lib/libiconv.a -o -f $ICONV_DIR/lib/libiconv.so -o -f $ICONV_DIR/lib/libiconv.sl -o -f $ICONV_DIR/lib/libiconv.dylib && ICONV_LIBDIR="$ICONV_DIR/lib" && ICONV_INCDIR="$ICONV_DIR/include"
  test -f $ICONV_DIR/lib64/libiconv.a -o -f $ICONV_DIR/lib64/libiconv.so -o -f $ICONV_DIR/lib64/libiconv.sl && ICONV_LIBDIR="$ICONV_DIR/lib64" && ICONV_INCDIR="$ICONV_DIR/include"

  dnl If we have both the glibc and a local libiconv, then the local libiconv
  dnl will be included in the link line no matter what. This shouldn't hurt
  dnl programs that don't need it, and saves us from having to figure some
  dnl black magic to detect what was used to build GD, etc.
  dnl Just doing the AC_CHECK_LIB(iconv ...) last does the trick.
  AC_CHECK_LIB(c, iconv_open, ICONV_LIB="-L$ICONV_LIBDIR -lc",,"-L$ICONV_LIBDIR")
  AC_CHECK_LIB(iconv, libiconv_open, ICONV_LIB="-L$ICONV_LIBDIR -liconv",,"-L$ICONV_LIBDIR")

fi

if test -n "$ICONV_LIB" ; then
  if test -n "$ICONV_INCDIR"; then 
     ICONV_INC="-I$ICONV_INCDIR"
  fi
  AC_MSG_RESULT([        using libiconv from $ICONV_LIB])
  AC_ADD_RUNPATH("$ICONV_DIR")

else

  dnl check for lib in system libs

  unset ac_cv_lib_iconv_libiconv_open
  unset ac_cv_lib_c_iconv_open
  AC_CHECK_LIB(c, iconv_open, ICONV_LIB="-lc",,)
  AC_CHECK_LIB(iconv, libiconv_open, ICONV_LIB="-liconv",,)

  if test -n "$ICONV_LIB" ; then
    AC_MSG_RESULT([        using libiconv from system libs.])
  else
    AC_MSG_RESULT([        libiconv library cannot be found, possibly needed for GD])
  fi

fi

if test -n "$ICONV_LIB" ; then
  ICONV_ENABLED="-DUSE_ICONV"
  AC_MSG_RESULT([        libiconv found. Enabling internationalization ($ICONV_ENABLED)])
fi


AC_SUBST(ICONV_ENABLED, $ICONV_ENABLED)
AC_SUBST(ICONV_INC,     $ICONV_INC)
AC_SUBST(ICONV_LIB,     $ICONV_LIB)

ALL_ENABLED="$ICONV_ENABLED $ALL_ENABLED"
ALL_INC="$ICONV_INC $ALL_INC"
ALL_LIB="$ICONV_LIB $ALL_LIB"


dnl ---------------------------------------------------------------------
dnl Find GD library
dnl
dnl If --with-gd not given, then check in system libs.
dnl ---------------------------------------------------------------------

dnl We don't want LIBS updated by all the GD stuff, so we save it and
dnl restore later.

ms_saved_LIBS="$LIBS"
IS_GD2="false";

dnl Clear some cache variables
unset ac_cv_lib_gd_gdImageCreate
unset ac_cv_lib_gd_gdImageString16
unset ac_cv_lib_gd_gdImageGif
unset ac_cv_lib_gd_gdImagePng
unset ac_cv_lib_gd_gdImageJpeg
unset ac_cv_lib_gd_gdImageWBMP
unset ac_cv_lib_gd_gdImageStringFT
unset ac_cv_lib_gd_gdImageGifPtr
unset ac_cv_lib_gd_gdFontGetTiny
unset ac_cv_lib_c_gdImageCreate
unset ac_cv_lib_c_gdImageString16
unset ac_cv_lib_c_gdImageGif
unset ac_cv_lib_c_gdImagePng
unset ac_cv_lib_c_gdImageJpeg
unset ac_cv_lib_c_gdImageWBMP
unset ac_cv_lib_c_gdImageStringFT
unset ac_cv_lib_c_gdImageGifPtr
unset ac_cv_lib_c_gdFontGetTiny
unset ac_cv_lib_gd_gdFontCacheSetup

AC_CHECKING(for GD 2.0.16 or higher)
AC_ARG_WITH(gd,
[  --with-gd[[=[static,]DIR]] Specify which version of GD to use (DIR is GD's
                          install dir).],,)

if test "$with_gd" = "no" ; then
  AC_MSG_ERROR(GD library cannot be disabled)
elif test -n "$with_gd" -a "$with_gd" != "yes" ; then
  dnl
  dnl --with-gd was specified explicitly... 
  dnl
  AC_PARSE_WITH_LIB_STATIC($with_gd, GD_DIR, GD_STATIC)
  AC_EXPAND_PATH($GD_DIR, GD_DIR)
  test -f $GD_DIR/include/gd.h && GD_INCLUDE="$GD_DIR/include"
  test -f $GD_DIR/include/gd/gd.h && GD_INCLUDE="$GD_DIR/include/gd"
  test -f $GD_DIR/gd.h && GD_INCLUDE="$GD_DIR"

  test -f $GD_DIR/lib/libgd.a && GD_LIBDIR="$GD_DIR/lib"
  test -f $GD_DIR/lib64/libgd.a && GD_LIBDIR="$GD_DIR/lib64"
  test -f $GD_DIR/.libs/libgd.a && GD_LIBDIR="$GD_DIR/.libs"
  test -f $GD_DIR/_libs/libgd.a && GD_LIBDIR="$GD_DIR/_libs"
  test -f $GD_DIR/libgd.a && GD_LIBDIR="$GD_DIR"

  test -f $GD_DIR/lib/libgd.so -o -f $GD_DIR/lib/libgd.sl -o -f $GD_DIR/lib/libgd.dylib && GD_LIBDIR="$GD_DIR/lib"
  test -f $GD_DIR/lib64/libgd.so -o -f $GD_DIR/lib/libgd.sl && GD_LIBDIR="$GD_DIR/lib64"
  test -f $GD_DIR/.libs/libgd.so -o -f $GD_DIR/.libs/libgd.sl -o -f $GD_DIR/.libs/libgd.dylib && GD_LIBDIR="$GD_DIR/.libs"
  test -f $GD_DIR/_libs/libgd.so -o -f $GD_DIR/_libs/libgd.sl -o -f $GD_DIR/_libs/libgd.dylib && GD_LIBDIR="$GD_DIR/_libs"
  test -f $GD_DIR/libgd.so -o -f $GD_DIR/libgd.sl -o -f $GD_DIR/libgd.dylib && GD_LIBDIR="$GD_DIR"

  dnl make sure it is GD 2.0.16+ with antialias and gdFontCacheSetup() support
  AC_CHECK_LIB(gd, gdFontCacheSetup,IS_GD2="true",,$GD_XTRA_LIBS -L$GD_LIBDIR)

  if test "$IS_GD2" = "false" -a -n "$ICONV_LIB"; then
    dnl try again including libiconv this time
    unset ac_cv_lib_gd_gdFontCacheSetup
    AC_CHECKING(whether GD needs libiconv)
    AC_CHECK_LIB(gd, gdFontCacheSetup,IS_GD2="true",,$GD_XTRA_LIBS -L$GD_LIBDIR $ICONV_LIB)
    GD_NEED_ICONV_LIB="$ICONV_LIB"
  fi

  if test -n "$GD_INCLUDE" -a -n "$GD_LIBDIR" -a "$IS_GD2" = "true"; then
      GD_INC=-I$GD_INCLUDE
      GD_LIB="-L$GD_LIBDIR -lgd"
      GD_XTRA_LIBS="$GD_XTRA_LIBS $GD_NEED_ICONV_LIB"
      AC_MSG_RESULT([        using libgd 2.0.16 (or higher) from $GD_LIB $GD_XTRA_LIBS])
      AC_ADD_RUNPATH("$GD_LIBDIR")
  else
      AC_MSG_ERROR([Could not find gd.h or libgd.a/libgd.so in $GD_DIR.  Make sure GD 2.0.16 or higher is compiled before calling configure. You may also get this error if you didn't specify the appropriate location for one of GD's dependencies (freetype, libpng, libjpeg or libiconv).])
  fi
else
  dnl  --with-gd specified without a DIR, look for gd in system dirs /usr or /usr/local
  FOUND_GD="false"
  for GD_DIR in /usr /usr/local
  do
    test -f $GD_DIR/include/gd.h && GD_INCLUDE="$GD_DIR/include"
    test -f $GD_DIR/lib/libgd.a && GD_LIBDIR="$GD_DIR/lib"
    test -f $GD_DIR/lib64/libgd.a && GD_LIBDIR="$GD_DIR/lib64"
    test -f $GD_DIR/lib/libgd.so -o -f $GD_DIR/lib/libgd.sl -o -f $GD_DIR/lib/libgd.dylib && GD_LIBDIR="$GD_DIR/lib"
    test -f $GD_DIR/lib64/libgd.so -o -f $GD_DIR/lib/libgd.sl && GD_LIBDIR="$GD_DIR/lib64"

    dnl make sure it is GD 2.0.16 or higher
    AC_CHECK_LIB(gd, gdFontCacheSetup, IS_GD2="true",,$GD_XTRA_LIBS)
 
    if test "$IS_GD2" = "false" -a -n "$ICONV_LIB"; then
      dnl try again including libiconv this time
      AC_CHECKING(whether GD needs libiconv)
      unset ac_cv_lib_gd_gdFontCacheSetup
      AC_CHECK_LIB(gd, gdFontCacheSetup,IS_GD2="true",,$GD_XTRA_LIBS $ICONV_LIB)
      GD_NEED_ICONV_LIB="$ICONV_LIB"
    fi

    if test -n "$GD_INCLUDE" -a -n "$GD_LIBDIR" -a "$IS_GD2" = "true"; then
      GD_INC=-I$GD_INCLUDE
      GD_LIB="-L$GD_LIBDIR -lgd"
      GD_XTRA_LIBS="$GD_XTRA_LIBS $GD_NEED_ICONV_LIB"
      AC_MSG_RESULT([        using libgd 2.0.16 (or higher) from system libs ($GD_LIB $GD_XTRA_LIBS).])
      AC_ADD_RUNPATH("$GD_LIBDIR")
      FOUND_GD="true"
      break;
    fi
  done

  if test "$FOUND_GD" = "false" ; then
    AC_MSG_ERROR([Could not find gd.h or libgd.a/libgd.so in $GD_DIR.  Make sure GD 2.0.16 or higher is compiled before calling configure. You may also get this error if you didn't specify the appropriate location for one of GD's dependencies (freetype, libpng, libjpeg or libiconv).])
  fi
fi

dnl ----------------------------------------------------------------------
dnl Continue with GD processing - determine GD formats and other features
dnl ----------------------------------------------------------------------

if test -n "$with_gd" -a "$with_gd" != "yes" ; then

  dnl check gd lib that was found on --with-gd=

  if test "$GD_STATIC" = "yes" ; then
    dnl To test against static GD, do AC_CHECK_LIB calls against -lc and
    dnl include libgd.a in GD_LIB param
    GD_CHECKLIB=c
    GD_LIB=""
    GD_STATIC=$GD_LIBDIR/libgd.a
    AC_MSG_RESULT([static linkage of $GD_STATIC requested... testing supported formats...])
  else
    GD_CHECKLIB=c
    # GD_LIB was already set above
    GD_STATIC=""
  fi

  AC_CHECK_LIB($GD_CHECKLIB, gdImageGif, GD_DEF="$GD_DEF -DUSE_GD_GIF",, $GD_STATIC $GD_LIB $GD_XTRA_LIBS)
  AC_CHECK_LIB($GD_CHECKLIB, gdImagePng, GD_DEF="$GD_DEF -DUSE_GD_PNG",, $GD_STATIC $GD_LIB $GD_XTRA_LIBS)
  AC_CHECK_LIB($GD_CHECKLIB, gdImageJpeg, GD_DEF="$GD_DEF -DUSE_GD_JPEG",, $GD_STATIC $GD_LIB $GD_XTRA_LIBS)
  AC_CHECK_LIB($GD_CHECKLIB, gdImageWBMP, GD_DEF="$GD_DEF -DUSE_GD_WBMP",, $GD_STATIC $GD_LIB $GD_XTRA_LIBS)

  dnl check for Freetype 2.x support  
  AC_CHECK_LIB($GD_CHECKLIB, gdImageStringFT, GD_DEF="$GD_DEF -DUSE_GD_FT",, $GD_STATIC $GD_LIB $GD_XTRA_LIBS)

  dnl check for gdImageOpenPolygon (means GD version 2.0.29 or higher)
  AC_CHECK_LIB($GD_CHECKLIB, gdImageOpenPolygon, GD_DEF="$GD_DEF -DGD_HAS_FTEX_XSHOW",, $GD_STATIC $GD_LIB $GD_XTRA_LIBS)

  dnl gdImageGifPtr is there only in GIF-patched GD versions
  AC_CHECK_LIB($GD_CHECKLIB, gdImageGifPtr, GD_DEF="$GD_DEF -DGD_HAS_GDIMAGEGIFPTR",, $GD_STATIC $GD_LIB $GD_XTRA_LIBS)

  dnl GD 2.0.22 and more recent replaced the static font pointers with 
  dnl getter functions.
  AC_CHECK_LIB($GD_CHECKLIB, gdFontGetTiny, GD_DEF="$GD_DEF -DGD_HAS_GETBITMAPFONTS",, $GD_STATIC $GD_LIB $GD_XTRA_LIBS)

  AC_MSG_RESULT([        using GD ($GD_DEF) from $GD_DIR.])

else

  dnl
  dnl --with-gd was not given... then look in system libs
  dnl

  dnl Make sure GD is at least there!
  AC_CHECK_LIB(gd, gdImageCreate, GD_FOUND=yes , ,$GD_XTRA_LIBS)
  if test -z "$GD_FOUND" ; then
      AC_MSG_ERROR([GD is required but was not found... use --with-gd=DIR to specify its location.])
  fi

  dnl Check supported formats
  AC_CHECK_LIB(gd, gdImageGif, GD_DEF="$GD_DEF -DUSE_GD_GIF",, $GD_LIB $GD_XTRA_LIBS)
  AC_CHECK_LIB(gd, gdImagePng, GD_DEF="$GD_DEF -DUSE_GD_PNG",, $GD_LIB $GD_XTRA_LIBS)
  AC_CHECK_LIB(gd, gdImageJpeg, GD_DEF="$GD_DEF -DUSE_GD_JPEG",, $GD_LIB $GD_XTRA_LIBS)
  AC_CHECK_LIB(gd, gdImageWBMP, GD_DEF="$GD_DEF -DUSE_GD_WBMP",, $GD_LIB $GD_XTRA_LIBS)

  dnl Check for Freetype 2 support
  AC_CHECK_LIB(gd, gdImageStringFT, GD_DEF="$GD_DEF -DUSE_GD_FT",, $GD_LIB $GD_XTRA_LIBS)

  dnl check for gdImageOpenPolygon (means GD version 2.0.29 or higher)
  AC_CHECK_LIB(gd, gdImageOpenPolygon, GD_DEF="$GD_DEF -DGD_HAS_FTEX_XSHOW",, $GD_STATIC $GD_LIB $GD_XTRA_LIBS)

  dnl gdImageGifPtr is there only in GIF-patched GD versions
  AC_CHECK_LIB(gd, gdImageGifPtr, GD_DEF="$GD_DEF -DGD_HAS_GDIMAGEGIFPTR",, $GD_LIB $GD_XTRA_LIBS)

  dnl GD 2.0.22 and more recent replaced the static font pointers with 
  dnl getter functions.
  AC_CHECK_LIB(gd, gdFontGetTiny, GD_DEF="$GD_DEF -DGD_HAS_GETBITMAPFONTS",, $GD_LIB $GD_XTRA_LIBS)

  if test -n "$GD_DEF" ; then
      GD_LIB="-lgd $GD_LIB"
      AC_MSG_RESULT([        using GD ($GD_DEF) from system libs.])
  fi
fi

GD_LIB="$GD_LIB $GD_XTRA_LIBS"

AC_SUBST(GD_DEF, $GD_DEF)
AC_SUBST(GD_INC, $GD_INC)
AC_SUBST(GD_LIB, $GD_LIB)
AC_SUBST(GD_STATIC, $GD_STATIC)
AC_SUBST(MAKE_GD, $MAKE_GD)
AC_SUBST(MAKE_GD_CLEAN, $MAKE_GD_CLEAN)

ALL_ENABLED="$GD_DEF $ALL_ENABLED"
ALL_INC="$GD_INC $ALL_INC"
ALL_LIB="$GD_LIB $ALL_LIB"
ALL_STATIC_LIB="$GD_STATIC $ALL_STATIC_LIB"

dnl Restore LIBS environment to state at beginning of gd tests.
LIBS="$ms_saved_LIBS"

dnl ---------------------------------------------------------------------
dnl Find PDFlib library
dnl
dnl If --with-pdflib not given, then check in system libs.
dnl ---------------------------------------------------------------------

dnl We don't want LIBS updated by all the PDF stuff, so we save it and
dnl restore later.

ms_saved_LIBS="$LIBS"

dnl Clear some cache variables
unset ac_cv_lib_pdf_PDF_setlinewidth
unset ac_cv_lib_pdf_PDF_setrgbcolor
unset ac_cv_lib_pdf_PDF_moveto
unset ac_cv_lib_pdf_PDF_curveto
unset ac_cv_lib_pdf_PDF_show_xy
unset ac_cv_lib_pdf_PDF_load_font

AC_CHECKING(whether we should include PDF support)
AC_ARG_WITH(pdf,
[  --without-pdf           Disable PDF support.
  --with-pdf[[=DIR]]        Include PDF support (DIR is PDFlib's install dir).],,)
if test "$with_pdf" = "no" ; then
  AC_MSG_RESULT([        disabled by --without-pdf])
elif test -n "$with_pdf" -a "$with_pdf" != "yes" ; then

  AC_EXPAND_PATH($with_pdf, PDF_DIR)
  test -f $PDF_DIR/include/pdflib.h && PDF_INCLUDE="$PDF_DIR/include"
  test -f $PDF_DIR/libpdf/pdflib.h && PDF_INCLUDE="$PDF_DIR/libpdf"
  test -f $PDF_DIR/include/libpdf/pdflib.h && PDF_INCLUDE="$PDF_DIR/include/libpdf"
  test -f $PDF_DIR/pdflib.h && PDF_INCLUDE="$PDF_DIR"

  test -f $PDF_DIR/lib/libpdf.a && PDF_LIBDIR="$PDF_DIR/lib"
  test -f $PDF_DIR/lib64/libpdf.a && PDF_LIBDIR="$PDF_DIR/lib64"
  test -f $PDF_DIR/libpdf/libpdf.a && PDF_LIBDIR="$PDF_DIR/libpdf"
  test -f $PDF_DIR/libpdf.a && PDF_LIBDIR="$PDF_DIR"

  test -f $PDF_DIR/lib/libpdf.so -o -f $PDF_DIR/lib/libpdf.sl -o -f $PDF_DIR/lib/libpdf.dylib && PDF_LIBDIR="$PDF_DIR/lib"
  test -f $PDF_DIR/lib64/libpdf.so -o -f $PDF_DIR/lib64/libpdf.sl && PDF_LIBDIR="$PDF_DIR/lib64"
  test -f $PDF_DIR/libpdf/libpdf.so -o -f $PDF_DIR/libpdf/libpdf.sl -o -f $PDF_DIR/libpdf/libpdf.dylib && PDF_LIBDIR="$PDF_DIR/libpdf"
  test -f $PDF_DIR/libpdf.so -o -f $PDF_DIR/libpdf.sl -o -f $PDF_DIR/libpdf.dylib && PDF_LIBDIR="$PDF_DIR"

  if test -n "$PDF_INCLUDE" -a -n "$PDF_LIBDIR" ; then

      PDF_LIB="-L$PDF_LIBDIR -lpdf"
      PDF_INC=-I$PDF_INCLUDE
      AC_ADD_RUNPATH("$PDF_LIBDIR")
  else
      AC_MSG_ERROR("Could not find pdflib.h or libpdf.a/libpdf.so in $PDF_DIR.")
  fi

  PDF_VERSION_CHECK="pass"
  AC_CHECK_LIB(pdf,PDF_setlinewidth,,PDF_VERSION_CHECK="fail",$PDF_LIB)
  AC_CHECK_LIB(pdf,PDF_setrgbcolor,,PDF_VERSION_CHECK="fail",$PDF_LIB)
  AC_CHECK_LIB(pdf,PDF_moveto,,PDF_VERSION_CHECK="fail",$PDF_LIB)
  AC_CHECK_LIB(pdf,PDF_curveto,,PDF_VERSION_CHECK="fail",$PDF_LIB)
  AC_CHECK_LIB(pdf,PDF_show_xy,,PDF_VERSION_CHECK="fail",$PDF_LIB)
  AC_CHECK_LIB(pdf,PDF_load_font,,PDF_VERSION_CHECK="fail",$PDF_LIB)

  if test "$PDF_VERSION_CHECK" = "fail" ; then
      AC_MSG_ERROR([libpdf in $PDF_DIR missing some required functions. Please upgrade to a more recent version of libpdf.])
  fi

  PDF_ENABLED="-DUSE_PDF"
  AC_MSG_RESULT([        using libpdf from $PDF_LIB.])

else

  AC_CHECK_LIB(pdf,PDF_setlinewidth,PDF_LIB="-lpdf",,)
  AC_CHECK_LIB(pdf,PDF_setrgbcolor,PDF_LIB="-lpdf",,)
  AC_CHECK_LIB(pdf,PDF_moveto,PDF_LIB="-lpdf",,)
  AC_CHECK_LIB(pdf,PDF_curveto,PDF_LIB="-lpdf",,)
  AC_CHECK_LIB(pdf,PDF_show_xy,PDF_LIB="-lpdf",,)
  AC_CHECK_LIB(pdf,PDF_load_font,PDF_LIB="-lpdf",,)
  if test -n "$PDF_LIB" ; then
      PDF_ENABLED=-DUSE_PDF
      AC_MSG_RESULT([        using libpdf from system libs.])
  else
      AC_MSG_RESULT([        libpdf not found or too old... PDF support not included.])
  fi

fi

dnl
dnl libpdf may need the same libs (libz, libjpeg) that are included with GD
dnl
PDF_LIB="$PDF_LIB"

AC_SUBST(PDF_ENABLED,$PDF_ENABLED)
AC_SUBST(PDF_INC,    $PDF_INC)
AC_SUBST(PDF_LIB,    $PDF_LIB)

ALL_ENABLED="$PDF_ENABLED $ALL_ENABLED"
ALL_INC="$PDF_INC $ALL_INC"
ALL_LIB="$PDF_LIB $ALL_LIB"

dnl Restore LIBS environment to state at beginning of PDF tests.
LIBS="$ms_saved_LIBS"

dnl ---------------------------------------------------------------------
dnl Optional AGG Support.
dnl ---------------------------------------------------------------------

AC_MSG_CHECKING(if AGG support requested)
AC_ARG_WITH(agg,
[  --with-agg[[=DIR]]        Include AGG support (DIR is AGG's install dir).],,)

if test "$with_agg" = "yes" ; then

  if test -n "$FT_BIN" ; then
     FT_INC=`$FT_BIN --cflags`
  else
     AC_MSG_ERROR([freetype required for agg support - please configure --with-freetype.])
  fi
  
  with_agg="/usr"
  AC_MSG_RESULT([looking for agg libs in /usr])
fi
if test -n "$with_agg" -a "$with_agg" != "no" ; then

  if test -n "$FT_BIN" ; then
     FT_INC=`$FT_BIN --cflags`
  else
     AC_MSG_ERROR([freetype required for agg support - please configure --with-freetype.])
  fi
  
  AC_EXPAND_PATH($with_agg, AGG_DIR)

  test -f $AGG_DIR/include/agg_rendering_buffer.h && AGG_INCLUDE="-I$AGG_DIR/include"
  test -f $AGG_DIR/include/agg/agg_rendering_buffer.h && AGG_INCLUDE="-I$AGG_DIR/include/agg"
  test -f $AGG_DIR/include/agg2/agg_rendering_buffer.h && AGG_INCLUDE="-I$AGG_DIR/include/agg2"

  # Include font_freetype directory if we are building from source tree.
  test -f $AGG_DIR/font_freetype/agg_font_freetype.h && AGG_INCLUDE="$AGG_INCLUDE -I$AGG_DIR/font_freetype"

  if test -z "$AGG_INCLUDE" ; then
      AC_MSG_ERROR("could not find agg_rendering_buffer.h in $AGG_DIR.")
  fi

  test -f $AGG_DIR/lib/libagg.a && AGG_LIBDIR="$AGG_DIR/lib"
  test -f $AGG_DIR/lib/libagg.so && AGG_LIBDIR="$AGG_DIR/lib"
  test -f $AGG_DIR/lib64/libagg.a && AGG_LIBDIR="$AGG_DIR/lib64"
  test -f $AGG_DIR/lib64/libagg.so && AGG_LIBDIR="$AGG_DIR/lib64"
  test -f $AGG_DIR/src/libagg.a && AGG_LIBDIR="$AGG_DIR/src"
  test -f $AGG_DIR/src/libagg.so && AGG_LIBDIR="$AGG_DIR/src"

  if test -z "$AGG_LIBDIR" ; then
      AC_MSG_ERROR("could not find libagg.a or libagg.so in $AGG_DIR.")
  fi

  AC_MSG_RESULT([using libagg from $AGG_DIR])

  dnl Check whether libaggfontfreetype is available, if yes then we'll use it, 
  dnl if not then we'll build agg_font_freetype.o from source.
  test -f $AGG_LIBDIR/libaggfontfreetype.a && AGG_FT_LIB="-laggfontfreetype"
  test -f $AGG_LIBDIR/libaggfontfreetype.so && AGG_FT_LIB="-laggfontfreetype"

  if test -n "$AGG_FT_LIB" ; then
    AC_MSG_RESULT([using libaggfontfreetype from $AGG_DIR])
  else
    dnl Build agg_font_freetype.o from source.
    test -f $AGG_DIR/font_freetype/agg_font_freetype.cpp && AGG_FT_DIR="$AGG_DIR/font_freetype"

    if test -z "$AGG_FT_DIR" ; then
      AC_MSG_ERROR([could not find libaggfontfreetype or agg_font_freetype.cpp in $AGG_DIR. Please download and compile an AGG source package from http://antigrain.com/download/index.html, and then specify the location of the AGG source tree using --with-agg.])
    fi

    AGG_FT_OBJ=agg_font_freetype.o
    AC_MSG_RESULT([libaggfontfreetype not found, building/linking agg_font_freetype.o from source])
  fi

  dnl If we got this far all is well!
  AGG_ENABLED="-DUSE_AGG"
  AGG_INC="$AGG_INCLUDE $FT_INC"
  AGG_LIB="-L$AGG_LIBDIR -lagg $AGG_FT_LIB"
  AC_ADD_RUNPATH("$AGG_LIBDIR")

else

  AC_MSG_RESULT([no])

fi

AC_SUBST(AGG_ENABLED,$AGG_ENABLED)
AC_SUBST(AGG_INC,    $AGG_INC)
AC_SUBST(AGG_LIB,    $AGG_LIB)
AC_SUBST(AGG_FT_DIR, $AGG_FT_DIR)
AC_SUBST(AGG_FT_OBJ, $AGG_FT_OBJ)

ALL_ENABLED="$AGG_ENABLED $ALL_ENABLED"
ALL_INC="$AGG_INC $ALL_INC"
ALL_LIB="$AGG_LIB $ALL_LIB"

dnl ---------------------------------------------------------------------
dnl EPPL7 support (included by default)
dnl ---------------------------------------------------------------------

AC_CHECKING(whether we should include EPPL7 support)
AC_ARG_WITH(eppl,
[  --without-eppl          Disable EPPL7 support.
  --with-eppl             Include EPPL7 support.],,)
if test "$with_eppl" = "no" ; then
  AC_MSG_RESULT([        disabled by --without-eppl])
else

  EPPL_OBJ="epplib.o"
  EPPL_ENABLED="-DUSE_EPPL"

  AC_MSG_RESULT([        including EPPL7 support.])

fi

AC_SUBST(EPPL_ENABLED,$EPPL_ENABLED)
AC_SUBST(EPPL_OBJ,    $EPPL_OBJ)

ALL_ENABLED="$EPPL_ENABLED $ALL_ENABLED"

dnl ---------------------------------------------------------------------
dnl Find PROJ.4 ONLY IF REQUESTED.
dnl ---------------------------------------------------------------------

dnl Clear some cache variables
unset ac_cv_lib_proj_pj_init
unset ac_cv_lib_proj_pj_transform
unset ac_cv_lib_proj_pj_latlong_from_proj

AC_CHECKING(whether we should include PROJ.4 support)
AC_ARG_WITH(proj,
[  --with-proj[[=DIR]]       Include PROJ.4 support (DIR is PROJ.4's install dir).],,)

if test "$with_proj" = "yes" ; then

  AC_CHECK_LIB(proj,pj_init,PROJ_ENABLED=-DUSE_PROJ,,,)
  AC_CHECK_LIB(proj,pj_transform,PJ_TRANSFORM=yes,PJ_TRANSFORM=no,,)

  if test -n "$PROJ_ENABLED" -a "$PJ_TRANSFORM" = "no"; then
      AC_MSG_ERROR([This version of PROJ is too old.  PROJ4.4.2 or later is required.])
  elif test -n "$PROJ_ENABLED" -a "$PJ_TRANSFORM" = "yes"; then
      PROJ_LIBS="-lproj"
      AC_MSG_RESULT([        using PROJ.4 from system libs.])
  else
      AC_MSG_WARN([        PROJ.4 not found in system libs... use --with-proj=DIR.])
  fi

elif test -n "$with_proj" -a "$with_proj" != "no" ; then

  AC_EXPAND_PATH($with_proj, PROJ_DIR)
  test -f $PROJ_DIR/include/proj_api.h && PROJ_INCLUDE="$PROJ_DIR/include"
  test -f $PROJ_DIR/include/proj/proj_api.h && PROJ_INCLUDE="$PROJ_DIR/include/proj"
  test -f $PROJ_DIR/src/proj_api.h && PROJ_INCLUDE="$PROJ_DIR/src"
  test -f $PROJ_DIR/proj_api.h && PROJ_INCLUDE="$PROJ_DIR"

  test -f $PROJ_DIR/src/.libs/libproj.a && PROJ_LIBDIR="$PROJ_DIR/src/.libs"
  test -f $PROJ_DIR/lib/libproj.a && PROJ_LIBDIR="$PROJ_DIR/lib"
  test -f $PROJ_DIR/lib64/libproj.a && PROJ_LIBDIR="$PROJ_DIR/lib64"
  test -f $PROJ_DIR/libproj.a && PROJ_LIBDIR="$PROJ_DIR"

  test -f $PROJ_DIR/src/.libs/libproj.so -o -f $PROJ_DIR/src/.libs/libproj.sl -o -f $PROJ_DIR/src/.libs/libproj.dylib && PROJ_LIBDIR="$PROJ_DIR/src/.libs"
  test -f $PROJ_DIR/lib/libproj.so -o -f $PROJ_DIR/lib/libproj.sl -o -f $PROJ_DIR/lib/libproj.dylib && PROJ_LIBDIR="$PROJ_DIR/lib"
  test -f $PROJ_DIR/lib64/libproj.so -o -f $PROJ_DIR/lib64/libproj.sl && PROJ_LIBDIR="$PROJ_DIR/lib64"
  test -f $PROJ_DIR/libproj.so -o -f $PROJ_DIR/libproj.sl -o -f $PROJ_DIR/libproj.dylib && PROJ_LIBDIR="$PROJ_DIR"

  if test -n "$PROJ_INCLUDE" -a -n "$PROJ_LIBDIR" ; then
      PROJ_INC=-I$PROJ_INCLUDE
      PROJ_LIBS="-L$PROJ_LIBDIR -lproj"
      AC_ADD_RUNPATH("$PROJ_LIBDIR")
  else
      AC_MSG_ERROR("Could not find proj_api.h or libproj.a/libproj.so in $PROJ_DIR.")
  fi

  AC_CHECK_LIB(proj,pj_transform,PJ_TRANSFORM=yes,PJ_TRANSFORM=no,$PROJ_LIBS)
  if test "$PJ_TRANSFORM" = "no"; then
      AC_MSG_ERROR([This version of PROJ is too old.  PROJ4.4.2 or later is required.])
  fi

  PROJ_ENABLED=-DUSE_PROJ
  AC_MSG_RESULT([        using PROJ.4 from $PROJ_DIR.])

else

  AC_MSG_RESULT([        PROJ.4 support not requested.])
fi

AC_SUBST(PROJ_ENABLED,$PROJ_ENABLED)
AC_SUBST(PROJ_INC,    $PROJ_INC)
AC_SUBST(PROJ_LIBS,   $PROJ_LIBS)

ALL_ENABLED="$PROJ_ENABLED $ALL_ENABLED"
ALL_INC="$PROJ_INC $ALL_INC"
ALL_LIB="$PROJ_LIBS $ALL_LIB"

dnl ---------------------------------------------------------------------
dnl ENABLE THREADS ONLY IF REQUESTED.
dnl ---------------------------------------------------------------------

THREAD_LIB=""
THREAD_FLAG=""

AC_CHECKING(whether we should include thread safe support)
AC_ARG_WITH(threads,
[  --with-threads[[=linkopt]]Include thread safe support],,)

if test "$with_threads" = "yes" ; then

  AC_CHECK_LIB(pthread,pthread_create,THREAD_FLAG=-DUSE_THREAD,,,)

  if test -n "$THREAD_FLAG" ; then
      THREAD_LIB="-lpthread"
      AC_MSG_RESULT([        using -lpthread from system libs.])
  else
      AC_MSG_ERROR([        -lpthread not found, use --with-thread=<pthread link options>])
  fi

elif test -n "$with_threads" -a "$with_threads" != "no" ; then

  THREAD_FLAG=-DUSE_THREAD
  THREAD_LIB="$with_threads"  

  AC_MSG_RESULT([        using threads with link options "$THREAD_LIB".])

else
  AC_MSG_RESULT([        thread safe support disabled.])
fi

AC_SUBST(THREAD_FLAG,$THREAD_FLAG)
AC_SUBST(THREAD_LIB,$THREAD_LIB)

ALL_ENABLED="$THREAD_FLAG $ALL_ENABLED"
ALL_LIB="$THREAD_LIB $ALL_LIB"

dnl ---------------------------------------------------------------------
dnl Find ESRI SDE ONLY IF REQUESTED.
dnl ---------------------------------------------------------------------

AC_CHECKING(whether we should include ESRI SDE support)
AC_ARG_WITH(sde,
[  --with-sde[[=DIR]]        Include ESRI SDE support (DIR is SDE's install dir).],,)

AC_ARG_WITH(sde-version,
[  --with-sde-version[[=VERSION NUMBER]]  Set ESRI SDE version number (Default
                          is 91).],SDE_VERSION=$with_sde_version,SDE_VERSION=91)

if test -z "$SDE_VERSION" -o `expr "$SDE_VERSION" \>\= 92` = 1; then
SDE_VERSION=""
fi
if test "$with_sde" = "yes" ; then

  AC_CHECK_LIB(sde$SDE_VERSION,SE_connection_create,SDE_ENABLED=-DUSE_SDE,,,)

  if test -n "$SDE_ENABLED" ; then
      SDE_LIB="-lsde$SDE_VERSION -lpe$SDE_VERSION -lsg$SDE_VERSION"
      AC_CHECK_LIB(pthread, main, SDE_LIB="$SDE_LIB -lpthread",,)
      AC_CHECK_LIB(socket, main, SDE_LIB="$SDE_LIB -lsocket",,)
      AC_CHECK_LIB(dl, main, SDE_LIB="$SDE_LIB -ldl",,)
      AC_MSG_RESULT([        using ESRI SDE from system libs.])
  else
      AC_MSG_WARN([        ESRI SDE not found in system libs... use --with-sde=DIR.])
  fi

elif test -n "$with_sde" -a "$with_sde" != "no" ; then

  AC_EXPAND_PATH($with_sde, SDE_DIR)

  test -f $SDE_DIR/arcsde/coverages/include/sdetype.h && SDE_INCDIR="$SDE_DIR/arcsde/coverages/include"
  test -f $SDE_DIR/include/sdetype.h && SDE_INCDIR="$SDE_DIR/include"
  test -f $SDE_DIR/sdetype.h && SDE_INCDIR="$SDE_DIR"

  test -f $SDE_DIR/lib/libsde$SDE_VERSION.a && SDE_LIBDIR="$SDE_DIR/lib"
  test -f $SDE_DIR/lib64/libsde$SDE_VERSION.a && SDE_LIBDIR="$SDE_DIR/lib64"
  test -f $SDE_DIR/libsde$SDE_VERSION.a && SDE_LIBDIR="$SDE_DIR"

  test -f $SDE_DIR/lib/libsde$SDE_VERSION.so -o -f $SDE_DIR/lib/libsde$SDE_VERSION.sl && SDE_LIBDIR="$SDE_DIR/lib"
  test -f $SDE_DIR/lib64/libsde$SDE_VERSION.so -o -f $SDE_DIR/lib64/libsde$SDE_VERSION.sl && SDE_LIBDIR="$SDE_DIR/lib64"
  test -f $SDE_DIR/libsde$SDE_VERSION.so -o -f $SDE_DIR/libsde$SDE_VERSION.sl && SDE_LIBDIR="$SDE_DIR"

  if test -n "$SDE_INCDIR" -a -n "$SDE_LIBDIR" ; then
      SDE_INC=-I$SDE_INCDIR
      SDE_LIB="-L$SDE_LIBDIR -lsde$SDE_VERSION -lpe$SDE_VERSION -lsg$SDE_VERSION"
      AC_CHECK_LIB(pthread, main, SDE_LIB="$SDE_LIB -lpthread",,)
      AC_CHECK_LIB(socket, main, SDE_LIB="$SDE_LIB -lsocket",,)
      AC_CHECK_LIB(dl, main, SDE_LIB="$SDE_LIB -ldl",,)
      AC_ADD_RUNPATH("$SDE_LIBDIR")
  else
      AC_MSG_ERROR("Could not find sdetype.h or libsde$SDE_VERSION.a/libsde$SDE_VERSION.so in $SDE_DIR.")
  fi

  SDE_ENABLED=-DUSE_SDE
  AC_MSG_RESULT([        using ESRI SDE from $SDE_DIR.])

else

  AC_MSG_RESULT([        ESRI SDE support not requested.])
fi

AC_SUBST(SDE_ENABLED,$SDE_ENABLED)
AC_SUBST(SDE_INC,    $SDE_INC)
AC_SUBST(SDE_LIB,    $SDE_LIB)

ALL_ENABLED="$SDE_ENABLED $ALL_ENABLED"
ALL_INC="$SDE_INC $ALL_INC"
ALL_LIB="$SDE_LIB $ALL_LIB"

dnl ---------------------------------------------------------------------
dnl Find GEOS ONLY IF REQUESTED.
dnl ---------------------------------------------------------------------

AC_MSG_CHECKING(if GEOS support requested)

AC_ARG_WITH(geos,
[  --with-geos[[=PATH]]      Include GEOS support (PATH is path to geos-config)],,)

if test -n "$with_geos" -a "$with_geos" != "no" ; then

  AC_MSG_RESULT([yes])

  GEOS_CONFIG=$with_geos

  if test "$GEOS_CONFIG" = "yes" ; then

    AC_PATH_PROG(GEOS_CONFIG, geos-config, no)

    if test "$GEOS_CONFIG" = "no" ; then
      AC_MSG_ERROR([couldn't find geos-config in default path. Please specify full path to geos-config])
    fi

  elif test -f "$GEOS_CONFIG" -a -x "$GEOS_CONFIG" ; then
    AC_MSG_RESULT([user supplied geos-config ($GEOS_CONFIG)])
  else
    AC_MSG_ERROR(['$GEOS_CONFIG' is not an executable.  Make sure you use --with-geos=/path/to/geos-config])
  fi

  dnl
  dnl Test that we have at least version 2.2.2
  dnl (Version check code borrowed from GDAL's geos.m4)
  dnl

  min_geos_version=2.2.2

  AC_MSG_CHECKING(for GEOS version >= $min_geos_version)

  geos_major_version=`$GEOS_CONFIG --version | \
       sed 's/\([[0-9]]*\)\.\([[0-9]]*\)\.\([[0-9]]*\).*/\1/'`
  geos_minor_version=`$GEOS_CONFIG --version | \
       sed 's/\([[0-9]]*\)\.\([[0-9]]*\)\.\([[0-9]]*\).*/\2/'`
  geos_micro_version=`$GEOS_CONFIG --version | \
       sed 's/\([[0-9]]*\)\.\([[0-9]]*\)\.\([[0-9]]*\).*/\3/'`

  req_major=`echo $min_geos_version | \
       sed 's/\([[0-9]]*\)\.\([[0-9]]*\)\.\([[0-9]]*\).*/\1/'`
  req_minor=`echo $min_geos_version | \
       sed 's/\([[0-9]]*\)\.\([[0-9]]*\)\.\([[0-9]]*\).*/\2/'`
  req_micro=`echo $min_geos_version | \
       sed 's/\([[0-9]]*\)\.\([[0-9]]*\)\.\([[0-9]]*\).*/\3/'`
      
  ac_req_version=`expr $req_major \* 100000 \+  $req_minor \* 100 \+ $req_micro`
  ac_geos_version=`expr $geos_major_version \* 100000 \+  $geos_minor_version \* 100 \+ $geos_micro_version`

  if test $ac_req_version -le $ac_geos_version; then
     AC_MSG_RESULT([yes. Found version ${geos_major_version}.${geos_minor_version}.${geos_micro_version}])
  else 
     AC_MSG_RESULT(no)
     AC_MSG_ERROR([geos-config reports version ${geos_major_version}.${geos_minor_version}.${geos_micro_version}, need at least $min_geos_version or configure --without-geos])
  fi

  
  dnl
  dnl All checks passed. Set compile flags
  dnl

  GEOS_ENABLED=-DUSE_GEOS

  GEOS_INCDIR=`$GEOS_CONFIG --includes`
  GEOS_INC="-I$GEOS_INCDIR"
  GEOS_LIB="`$GEOS_CONFIG --libs`_c"

  AC_SUBST(GEOS_ENABLED,$GEOS_ENABLED)
  AC_SUBST(GEOS_INC,    $GEOS_INC)
  AC_SUBST(GEOS_LIB,    $GEOS_LIB)

  ALL_ENABLED="$GEOS_ENABLED $ALL_ENABLED"
  ALL_INC="$GEOS_INC $ALL_INC"
  ALL_LIB="$GEOS_LIB $ALL_LIB"

else

  AC_MSG_RESULT([no])

fi

dnl ---------------------------------------------------------------------
dnl Find OGR ONLY IF REQUESTED.
dnl ---------------------------------------------------------------------

AC_CHECKING(whether we should include OGR support)
AC_ARG_WITH(ogr,
[  --with-ogr[[=PATH]]       Include OGR support (PATH is path to gdal-config).],,)

if test "`basename xx/$with_ogr`" = "gdal-config" ; then
  GDAL_CONFIG="$with_ogr"
fi

if test "$with_ogr" = "yes" ; then
 AC_PATH_PROG(GDAL_CONFIG, gdal-config, no)

  if test "$GDAL_CONFIG" = "no" ; then
    AC_MSG_ERROR([couldn't find gdal-config])
  fi
fi

if test -n "