configure.in

Pango is a library for layout and rendering of text, with an emphasis on internationalization. Pang

dnl Process this file with autoconf to create configure.
AC_PREREQ(2.56)

dnl ==========================================================================
dnl                               Versioning              
dnl ==========================================================================

dnl Making releases:
dnl   PANGO_VERSION_MICRO += 1;
dnl   PANGO_INTERFACE_AGE += 1;
dnl   PANGO_BINARY_AGE += 1;
dnl if any functions have been added, set PANGO_INTERFACE_AGE to 0.
dnl if backwards compatibility has been broken,
dnl set PANGO_BINARY_AGE _and_ PANGO_INTERFACE_AGE to 0.

dnl
dnl We do the version number components as m4 macros
dnl so that we can base configure --help output off
dnl of them.
dnl

dnl The triplet 
m4_define([pango_version_major], [1])
m4_define([pango_version_minor], [20])
m4_define([pango_version_micro], [0])
m4_define([pango_version],
          [pango_version_major.pango_version_minor.pango_version_micro])
dnl The X.Y in -lpango-X.Y line. This is expected to stay 1.0 until Pango 2.
m4_define([pango_api_version], [1.0])
dnl Number of releases since we've added interfaces
m4_define([pango_interface_age], [0])
dnl Number of releases since we've broken binary compatibility.
m4_define([pango_binary_age],
          [m4_eval(100 * pango_version_minor + pango_version_micro)])
dnl Module API version.  This should be stepped up when a change causes
dnl older modules to not work with new pango.
m4_define([pango_module_version], [1.6.0])


AC_INIT(pango, pango_version(),
        [http://bugzilla.gnome.org/enter_bug.cgi?product=pango])

AC_CONFIG_SRCDIR([ChangeLog])

AM_INIT_AUTOMAKE(1.9 gnits dist-bzip2 no-dist-gzip)
AM_CONFIG_HEADER([config.h])


PANGO_VERSION_MAJOR=pango_version_major()
PANGO_VERSION_MINOR=pango_version_minor()
PANGO_VERSION_MICRO=pango_version_micro()
PANGO_VERSION=pango_version()
PANGO_API_VERSION=pango_api_version()
PANGO_INTERFACE_AGE=pango_interface_age()
PANGO_BINARY_AGE=pango_binary_age()
PANGO_MODULE_VERSION=pango_module_version()

AC_SUBST(PANGO_VERSION_MAJOR)
AC_SUBST(PANGO_VERSION_MINOR)
AC_SUBST(PANGO_VERSION_MICRO)
AC_SUBST(PANGO_VERSION)
AC_SUBST(PANGO_API_VERSION)
AC_SUBST(PANGO_INTERFACE_AGE)
AC_SUBST(PANGO_BINARY_AGE)
AC_SUBST(PANGO_MODULE_VERSION)

AC_DEFINE(MODULE_VERSION, "pango_module_version()", [Module interface version])
AC_DEFINE(PANGO_BINARY_AGE, pango_binary_age(), [PANGO binary age])
AC_DEFINE(PANGO_INTERFACE_AGE, pango_interface_age(), [PANGO interface age])
AC_DEFINE(PANGO_VERSION_MAJOR, pango_version_major(), [PANGO major version])
AC_DEFINE(PANGO_VERSION_MINOR, pango_version_minor(), [PANGO minor version])
AC_DEFINE(PANGO_VERSION_MICRO, pango_version_micro(), [PANGO micro version])

dnl libtool versioning
m4_define([lt_current], [m4_eval(100 * pango_version_minor + pango_version_micro - pango_interface_age)])
m4_define([lt_revision], [pango_interface_age])
m4_define([lt_age], [m4_eval(pango_binary_age - pango_interface_age)])
VERSION_INFO="lt_current():lt_revision():lt_age()"
PANGO_CURRENT_MINUS_AGE=m4_eval(lt_current - lt_age)

AC_SUBST(PANGO_CURRENT_MINUS_AGE)

dnl ==========================================================================

AC_CANONICAL_HOST

AC_MSG_CHECKING([for native Win32])
case "$host" in
  *-*-mingw*)
    pango_os_win32=yes
    ;;
  *)
    pango_os_win32=no
    ;;
esac
AC_MSG_RESULT([$pango_os_win32])
AM_CONDITIONAL(OS_WIN32, test "$pango_os_win32" = "yes")

AC_PROG_CC
	
dnl 
dnl Check for a working C++ compiler, but do not bail out, if none is found.
dnl We use this for an automated test for C++ header correctness.
dnl 
AC_CHECK_PROGS(CXX, [$CCC c++ g++ gcc CC cxx cc++ cl], gcc)
AC_LANG_SAVE
AC_LANG_CPLUSPLUS
AC_TRY_COMPILE(,[class a { int b; } c;], ,CXX=)
AM_CONDITIONAL(HAVE_CXX, test "$CXX" != "")
AC_LANG_RESTORE

AC_LIBTOOL_WIN32_DLL
AM_DISABLE_STATIC

if test "$pango_os_win32" = "yes"; then
  if test x$enable_static = xyes -o x$enable_static = x; then
    AC_MSG_WARN([Disabling static library build, must build as DLL on Windows.])
    enable_static=no
  fi
  if test x$enable_shared = xno; then
    AC_MSG_WARN([Enabling shared library build, must build as DLL on Windows.])
  fi
  enable_shared=yes
fi

AM_PROG_LIBTOOL

AC_MSG_CHECKING([for some Win32 platform])
case "$host" in
  *-*-mingw*|*-*-cygwin*)
    pango_platform_win32=yes
    ;;
  *)
    pango_platform_win32=no
    ;;
esac
AC_MSG_RESULT([$pango_platform_win32])
AM_CONDITIONAL(PLATFORM_WIN32, test "$pango_platform_win32" = "yes")

if test "$pango_os_win32" = "yes"; then
  AC_CHECK_TOOL(WINDRES, windres, no)
  if test "$WINDRES" = no; then
    AC_MSG_ERROR([*** Could not find an implementation of windres in your PATH.])
  fi
  AC_CHECK_PROG(ms_librarian, lib.exe, yes, no)
fi
AM_CONDITIONAL(MS_LIB_AVAILABLE, test x$ms_librarian = xyes)

changequote(,)dnl
if test "x$GCC" = "xyes"; then
  case " $CFLAGS " in
  *[\ \	]-Wall[\ \	]*) ;;
  *) CFLAGS="$CFLAGS -Wall" ;;
  esac
fi
changequote([,])dnl

dnl declare --enable-* args and collect ac_help strings

m4_define([debug_default],
          m4_if(m4_eval(pango_version_minor() % 2), [1], [yes], [minimum]))

AC_ARG_ENABLE(debug,
              AC_HELP_STRING([--enable-debug=@<:@no/minimum/yes@:>@],
                             [turn on debugging @<:@default=debug_default()@:>@]),
	      ,
              enable_debug=debug_default())

if test "x$enable_debug" = "xyes"; then
  PANGO_DEBUG_FLAGS="-DPANGO_ENABLE_DEBUG"
else
  PANGO_DEBUG_FLAGS="-DG_DISABLE_CAST_CHECKS"

  if test "x$enable_debug" = "xno"; then
    PANGO_DEBUG_FLAGS="$GLIB_DEBUG_FLAGS -DG_DISABLE_ASSERT -DG_DISABLE_CHECKS $PANGO_DEBUG_FLAGS"
  fi
fi

AC_SUBST(PANGO_DEBUG_FLAGS)

AC_ARG_ENABLE(rebuilds,
              [AC_HELP_STRING([--disable-rebuilds],
                              [disable all source autogeneration rules])],,
              [enable_rebuilds=yes])

AM_CONDITIONAL(CROSS_COMPILING, [test $cross_compiling = yes])

# define a MAINT-like variable REBUILD which is set if Perl
# is found, so autogenerated sources can be rebuilt

AC_CHECK_PROGS(PERL, perl5 perl)

REBUILD=\#
if test "x$enable_rebuilds" = "xyes" && \
     test -n "$PERL" && \
     $PERL -e 'exit !($] >= 5.002)' > /dev/null 2>&1 ; then
  REBUILD=
fi
AC_SUBST(REBUILD)

have_x=false
if test "x$pango_os_win32" != xyes; then
  AC_PATH_XTRA

  if test x$no_x = xyes ; then
    AC_MSG_WARN([X development libraries not found])
    have_x=false
  else
    X_LIBS="$X_LIBS -lX11"
    have_x=true
    AC_DEFINE(HAVE_X, 1, [Have X libraries])
  fi
fi
AM_CONDITIONAL(HAVE_X, $have_x) 

have_fontconfig=false
have_freetype=false
have_xft=false

#
# Check for fontconfig
#
PKG_CHECK_MODULES(FONTCONFIG, fontconfig >= 1.0.1, have_fontconfig=true, AC_MSG_RESULT([no]))

#
# Checks for FreeType
#
if $have_fontconfig ; then
  # The first version of freetype with a .pc file is 2.1.5.  That's recent
  # enough for all the functions we use I guess.  No version check needed.
  PKG_CHECK_MODULES(FREETYPE, freetype2, have_freetype=true, AC_MSG_RESULT([no]))
fi
if $have_freetype ; then
  AC_DEFINE(HAVE_FREETYPE, 1, [Have FreeType 2 library])
  # By freetype, we really always mean freetype+fontconfig
  FREETYPE_CFLAGS="$FREETYPE_CFLAGS $FONTCONFIG_CFLAGS"
  FREETYPE_LIBS="$FREETYPE_LIBS $FONTCONFIG_LIBS"
fi
AM_CONDITIONAL(HAVE_FREETYPE, $have_freetype)

#
# Checks for Xft/XRender
#
if $have_x && $have_freetype ; then
  PKG_CHECK_MODULES(XFT, xft >= 2.0.0 xrender, have_xft=true, AC_MSG_RESULT([no]))
fi
if $have_xft ; then
  AC_DEFINE(HAVE_XFT, 1, [Have Xft library])
fi
AM_CONDITIONAL(HAVE_XFT, $have_xft)

#
# Checks for Win32 GDI
#
have_win32=false
WIN32_LIBS=""
WIN32_CFLAGS=""
# The following doesn't work with autoconf-2.13, so we check $host instead
# AC_CHECK_LIB(gdi32, GetTextMetricsA@8, have_win32=true, : )
case "$host" in
  *-*-mingw*|*-*-cygwin*) have_win32=true ;;
esac


if test $have_win32 = true; then
  WIN32_LIBS="-lgdi32"
fi

AC_SUBST(WIN32_LIBS)
AM_CONDITIONAL(HAVE_WIN32, $have_win32) 

# Ensure MSVC-compatible struct packing convention is used when
# compiling for Win32 with gcc.
# What flag to depends on gcc version: gcc3 uses "-mms-bitfields", while
# gcc2 uses "-fnative-struct".
if test "$pango_os_win32" = "yes"; then
  if test x"$GCC" = xyes; then
    msnative_struct=''
    AC_MSG_CHECKING([how to get MSVC-compatible struct packing])
    if test -z "$ac_cv_prog_CC"; then
      our_gcc="$CC"
    else
      our_gcc="$ac_cv_prog_CC"
    fi
    case `$our_gcc --version | sed -e 's,\..*,.,' -e q` in
      2.)
	if $our_gcc -v --help 2>/dev/null | grep fnative-struct >/dev/null; then
	  msnative_struct='-fnative-struct'
	fi
	;;
      *)
	if $our_gcc -v --help 2>/dev/null | grep ms-bitfields >/dev/null; then
	  msnative_struct='-mms-bitfields'
	fi
	;;
    esac
    if test x"$msnative_struct" = x ; then
      AC_MSG_RESULT([no way])
      AC_MSG_WARN([produced libraries might be incompatible with MSVC-compiled code])
    else
      CFLAGS="$CFLAGS $msnative_struct"
      AC_MSG_RESULT([${msnative_struct}])
    fi
  fi
fi

#
# Checks for ATSUI
#
AC_CHECK_HEADER(Carbon/Carbon.h, [have_atsui=true], [have_atsui=true])

#
# Checks for Cairo
#
have_cairo=false
have_cairo_png=false
have_cairo_ps=false
have_cairo_pdf=false
have_cairo_xlib=false
have_cairo_freetype=false
have_cairo_win32=false
have_cairo_atsui=false
cairo_required=1.2.6

PKG_CHECK_MODULES(CAIRO, cairo >= $cairo_required, have_cairo=true, AC_MSG_RESULT([no]))
   
if $have_cairo ; then
  m4_pattern_allow([PKG_CONFIG_DISABLE_UNINSTALLED])
  INSTALLED_CAIRO_LIBS=`PKG_CONFIG_DISABLE_UNINSTALLED=yes $PKG_CONFIG --libs cairo`
  pango_save_libs=$LIBS
  LIBS="$LIBS $INSTALLED_CAIRO_LIBS"
  pango_save_ldflags=$LDFLAGS
  LDFLAGS="$LDFLAGS $INSTALLED_CAIRO_LIBS"

  have_cairo=false

  if $have_win32; then
    PKG_CHECK_EXISTS(cairo-win32 >= $cairo_required, have_cairo_win32=true, :)
  fi
  if $have_cairo_win32; then
    AC_DEFINE(HAVE_CAIRO_WIN32, 1, [Whether Cairo uses the Win32 GDI for fonts])
    have_cairo=true
  fi

  if $have_freetype; then
    PKG_CHECK_EXISTS(cairo-ft >= $cairo_required, have_cairo_freetype=true, :)
  fi
  if $have_cairo_freetype; then
    AC_DEFINE(HAVE_CAIRO_FREETYPE, 1, [Whether Cairo uses FreeType for fonts])
    have_cairo=true
  fi

  if $have_atsui; then
    PKG_CHECK_EXISTS(cairo-atsui >= $cairo_required, have_cairo_atsui=true, :)
  fi
  if $have_cairo_atsui; then
    AC_DEFINE(HAVE_CAIRO_ATSUI, 1, [Whether Cairo uses ATSUI for fonts])
    have_cairo=true
  fi

  if $have_cairo ; then
    AC_DEFINE(HAVE_CAIRO, 1, [Have usable Cairo library and font backend])

    PKG_CHECK_EXISTS(cairo-png >= $cairo_required, have_cairo_png=true, :)
    if $have_cairo_png; then
      AC_DEFINE(HAVE_CAIRO_PNG, 1, [Whether Cairo has PNG support])
    fi
  
    PKG_CHECK_EXISTS(cairo-ps >= $cairo_required, have_cairo_ps=true, :)
    if $have_cairo_ps; then
      AC_DEFINE(HAVE_CAIRO_PS, 1, [Whether Cairo has PS support])
    fi
  
    PKG_CHECK_EXISTS(cairo-pdf >= $cairo_required, have_cairo_pdf=true, :)
    if $have_cairo_pdf; then
      AC_DEFINE(HAVE_CAIRO_PDF, 1, [Whether Cairo has PDF support])
    fi
  
    PKG_CHECK_EXISTS(cairo-xlib >= $cairo_required, have_cairo_xlib=true, :)
    if $have_cairo_xlib; then
      AC_DEFINE(HAVE_CAIRO_XLIB, 1, [Whether Cairo has Xlib support])
    fi
  fi

  LIBS=$pango_save_libs
  LDFLAGS=$pango_save_ldflags
fi

AM_CONDITIONAL(HAVE_CAIRO, $have_cairo)
AM_CONDITIONAL(HAVE_CAIRO_PNG, $have_cairo_png)
AM_CONDITIONAL(HAVE_CAIRO_PS, $have_cairo_ps)
AM_CONDITIONAL(HAVE_CAIRO_PDF, $have_cairo_pdf)
AM_CONDITIONAL(HAVE_CAIRO_XLIB, $have_cairo_xlib)
AM_CONDITIONAL(HAVE_CAIRO_WIN32, $have_cairo_win32)
AM_CONDITIONAL(HAVE_CAIRO_FREETYPE, $have_cairo_freetype)
AM_CONDITIONAL(HAVE_CAIRO_ATSUI, $have_cairo_atsui)

#
# We must have some backend defined, in order for the pango-querymodules
# rule in pango/Makefile.am to work correctly. If you are up to writing
# a new Pango backend outside of Pango, you are up to sending the necessary
# patch to fix that rule. :-)
#
if $have_freetype || $have_x || $have_xft || $have_cairo; then : ; else
  AC_MSG_ERROR([*** Could not enable any of FreeType, X11, Cairo, or Win32 backends.
*** Must have at least one backend to build Pango.])
fi

#
# Checks for GLib
#
GLIB_REQUIRED_VERSION=2.14.0
GLIB_MODULES="glib-2.0 >= $GLIB_REQUIRED_VERSION gobject-2.0 gmodule-no-export-2.0"

PKG_CHECK_MODULES(GLIB, $GLIB_MODULES, :,
  AC_MSG_ERROR([
*** Glib $GLIB_REQUIRED_VERSION or better is required. The latest version of 
*** Glib is always available from ftp://ftp.gtk.org/.]))

# Add in gthread-2.0 to CFLAGS but not to LIBS so we get any
# necesary defines for thread-safety.
GLIB_CFLAGS=`$PKG_CONFIG --cflags $GLIB_MODULES gthread-2.0`

# See if it's safe to turn G_DISABLE_DEPRECATED on.
GLIB_VERSION_MAJOR_MINOR=`$PKG_CONFIG --modversion glib-2.0 | sed "s/\.@<:@^.@:>@*\$//"`
GLIB_REQUIRED_VERSION_MAJOR_MINOR=`echo $GLIB_REQUIRED_VERSION | sed "s/\.@<:@^.@:>@*\$//"`
if test "x$GLIB_VERSION_MAJOR_MINOR" = "x$GLIB_REQUIRED_VERSION_MAJOR_MINOR"; then
  GLIB_CFLAGS="-DG_DISABLE_DEPRECATED $GLIB_CFLAGS"
fi

#
# Checks for LibThai
#
have_libthai=false
LIBTHAI_REQUIRED_VERSION=0.1.9
PKG_CHECK_MODULES(LIBTHAI, libthai >= $LIBTHAI_REQUIRED_VERSION, have_libthai=true, AC_MSG_RESULT([no]))

#
# Modules to build
#
arabic_modules="arabic-fc,arabic-lang"
basic_modules="basic-fc,basic-win32,basic-x,basic-atsui"
hangul_modules="hangul-fc"
hebrew_modules="hebrew-fc"
indic_modules="indic-fc,indic-lang"
khmer_modules="khmer-fc"
syriac_modules="syriac-fc"
thai_modules="thai-fc"
tibetan_modules="tibetan-fc"

if $have_libthai ; then
  thai_modules="$thai_modules,thai-lang"
fi

all_modules="$arabic_modules,$basic_modules,$hangul_modules,$hebrew_modules,$indic_modules,$khmer_modules,$syriac_modules,$thai_modules,$tibetan_modules"

#
# Allow building some or all modules included
#
AC_MSG_CHECKING(modules to link statically)

AC_ARG_WITH(included_modules,
   AC_HELP_STRING([--with-included-modules=no/yes/MODULE1 MODULE2 ...],
                  [build the given modules included @<:@default=no@:>@]))

included_modules=""
case x$with_included_modules in
	xyes)	included_modules=$all_modules ;;
	xno|x)	included_modules="" ;;
	*)	included_modules=$with_included_modules ;;
esac
AC_MSG_RESULT($included_modules)
AM_CONDITIONAL(HAVE_INCLUDED_MODULES, test "x$included_modules" != x)

#
# Allow building only some or none of modules dynamic
#
AC_MSG_CHECKING(dynamic modules to build)

AC_ARG_WITH(dynamic_modules,
   AC_HELP_STRING([--with-dynamic-modules=no/yes/MODULE1 MODULE2 ...],
                  [build the given dynamic modules @<:@default=yes@:>@]))