Subversion Repositories openrisc

dnl Autoconf configure script for GDB, the GNU debugger.

dnl Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,

dnl 2005, 2006, 2007, 2008, 2009, 2010

dnl Free Software Foundation, Inc.

dnl

dnl This file is part of GDB.

dnl

dnl This program is free software; you can redistribute it and/or modify

dnl it under the terms of the GNU General Public License as published by

dnl the Free Software Foundation; either version 3 of the License, or

dnl (at your option) any later version.

dnl

dnl This program is distributed in the hope that it will be useful,

dnl but WITHOUT ANY WARRANTY; without even the implied warranty of

dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

dnl GNU General Public License for more details.

dnl

dnl You should have received a copy of the GNU General Public License

dnl along with this program.  If not, see .

dnl Process this file with autoconf to produce a configure script.

AC_PREREQ(2.59)dnl

AC_INIT(main.c)

AC_CONFIG_HEADER(config.h:config.in)

AM_MAINTAINER_MODE

AC_PROG_CC

AC_USE_SYSTEM_EXTENSIONS

gl_EARLY

ACX_LARGEFILE

AM_PROG_CC_STDC

AC_CONFIG_AUX_DIR(..)

AC_CANONICAL_SYSTEM

# Dependency checking.

ZW_CREATE_DEPDIR

ZW_PROG_COMPILER_DEPENDENCIES([CC])

# Check for the 'make' the user wants to use.

AC_CHECK_PROGS(MAKE, make)

MAKE_IS_GNU=

case "`$MAKE --version 2>&1 | sed 1q`" in

  *GNU*)

    MAKE_IS_GNU=yes

    ;;

esac

AM_CONDITIONAL(GMAKE, test "$MAKE_IS_GNU" = yes)

AC_PROG_MAKE_SET

dnl List of object files and targets accumulated by configure.

CONFIG_OBS=

CONFIG_DEPS=

CONFIG_SRCS=

ENABLE_CFLAGS=

CONFIG_ALL=

CONFIG_CLEAN=

CONFIG_INSTALL=

CONFIG_UNINSTALL=

dnl Set up for gettext.

ZW_GNU_GETTEXT_SISTER_DIR

localedir='${datadir}/locale'

AC_SUBST(localedir)

if test x"$USE_NLS" = xyes; then

   CONFIG_ALL="$CONFIG_ALL all-po"

   CONFIG_CLEAN="$CONFIG_CLEAN clean-po"

   CONFIG_INSTALL="$CONFIG_INSTALL install-po"

   CONFIG_UNINSTALL="$CONFIG_UNINSTALL uninstall-po"

fi

gl_INIT

# For Makefile dependencies.

GNULIB_STDINT_H=

if test x"$STDINT_H" != x; then

  GNULIB_STDINT_H=gnulib/$STDINT_H

fi

AC_SUBST(GNULIB_STDINT_H)

PACKAGE=gdb

AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of this package. ])

AC_SUBST(PACKAGE)

# GDB does not use automake, but gnulib does.  This line lets us

# generate its Makefile.in.

AM_INIT_AUTOMAKE(gdb, UNUSED-VERSION, [no-define])

GDB_AC_WITH_DIR(DEBUGDIR, separate-debug-dir,

    [look for global separate debug info in this path @<:@LIBDIR/debug@:>@],

    [${libdir}/debug])

# GDB's datadir relocation

GDB_AC_WITH_DIR(GDB_DATADIR, gdb-datadir,

    [look for global separate data files in this path @<:@DATADIR/gdb@:>@],

    [${datadir}/gdb])

AC_ARG_WITH(relocated-sources,

AS_HELP_STRING([--with-relocated-sources=PATH], [automatically relocate this path for source files]),

[reloc_srcdir="${withval}"

 AC_DEFINE_DIR(RELOC_SRCDIR, reloc_srcdir,

              [Relocated directory for source files. ])

])

AC_CONFIG_SUBDIRS(doc testsuite)

# Check whether to support alternative target configurations

AC_ARG_ENABLE(targets,

AS_HELP_STRING([--enable-targets=TARGETS], [alternative target configurations]),

[case "${enableval}" in

  yes | "") AC_ERROR(enable-targets option must specify target names or 'all')

            ;;

  no)       enable_targets= ;;

  *)        enable_targets=$enableval ;;

esac])

# Check whether to enable 64-bit support on 32-bit hosts

AC_ARG_ENABLE(64-bit-bfd,

AS_HELP_STRING([--enable-64-bit-bfd], [64-bit support (on hosts with narrower word sizes)]),

[case "${enableval}" in

  yes)  want64=true  ;;

  no)   want64=false ;;

  *)    AC_MSG_ERROR(bad value ${enableval} for 64-bit-bfd option) ;;

esac],[want64=false])dnl

# Provide defaults for some variables set by the per-host and per-target

# configuration.

gdb_host_obs=posix-hdep.o

if test "${target}" = "${host}"; then

  gdb_native=yes

else

  gdb_native=no

fi

. $srcdir/configure.host

# Accumulate some settings from configure.tgt over all enabled targets

TARGET_OBS=

all_targets=

for targ_alias in `echo $target_alias $enable_targets | sed 's/,/ /g'`

do

  if test "$targ_alias" = "all"; then

    all_targets=true

  else

    # Canonicalize the secondary target names.

    result=`$ac_config_sub $targ_alias 2>/dev/null`

    if test -n "$result"; then

        targ=$result

    else

        targ=$targ_alias

    fi

    . ${srcdir}/configure.tgt

    AS_IF([test -z "${gdb_target_obs}"],

      [AC_MSG_ERROR([configuration ${targ} is unsupported.])])

    # Target-specific object files

    for i in ${gdb_target_obs}; do

        case " $TARGET_OBS " in

        *" ${i} "*) ;;

        *)

          TARGET_OBS="$TARGET_OBS ${i}"

          ;;

        esac

    done

    # Check whether this target needs 64-bit CORE_ADDR

    if test x${want64} = xfalse; then

      . ${srcdir}/../bfd/config.bfd

    fi

  fi

done

if test x${all_targets} = xtrue; then

  # We want all 64-bit targets if we either:

  #  - run on a 64-bit host  or

  #  - already require 64-bit support for some other target  or

  #  - the --enable-64-bit-bfd option was supplied

  # Otherwise we only support all 32-bit targets.

  #

  # NOTE: This test must be in sync with the corresponding

  #       tests in BFD!

  if test x${want64} = xfalse; then

    AC_CHECK_SIZEOF(long)

    if test "x${ac_cv_sizeof_long}" = "x8"; then

      want64=true

    fi

  fi

  if test x${want64} = xtrue; then

    TARGET_OBS='$(ALL_TARGET_OBS) $(ALL_64_TARGET_OBS)'

  else

    TARGET_OBS='$(ALL_TARGET_OBS)'

  fi

fi

AC_SUBST(TARGET_OBS)

# For other settings, only the main target counts.

gdb_sim=

gdb_osabi=

build_gdbserver=

targ=$target; . ${srcdir}/configure.tgt

# Fetch the default architecture and default target vector from BFD.

targ=$target; . $srcdir/../bfd/config.bfd

# We only want the first architecture, so strip off the others if

# there is more than one.

targ_archs=`echo $targ_archs | sed 's/ .*//'`

if test "x$targ_archs" != x; then

  AC_DEFINE_UNQUOTED(DEFAULT_BFD_ARCH, $targ_archs,

    [Define to BFD's default architecture. ])

fi

if test "x$targ_defvec" != x; then

  AC_DEFINE_UNQUOTED(DEFAULT_BFD_VEC, $targ_defvec,

    [Define to BFD's default target vector. ])

fi

# The CLI cannot be disabled yet, but may be in the future.

# Enable CLI.

AC_ARG_ENABLE(gdbcli,

AS_HELP_STRING([--disable-gdbcli], [disable command-line interface (CLI)]),

  [case $enableval in

    yes)

      ;;

    no)

      AC_MSG_ERROR([the command-line interface cannot be disabled yet]) ;;

    *)

      AC_MSG_ERROR([bad value $enableval for --enable-gdbcli]) ;;

  esac],

  [enable_gdbcli=yes])

if test x"$enable_gdbcli" = xyes; then

  if test -d $srcdir/cli; then

    CONFIG_OBS="$CONFIG_OBS \$(SUBDIR_CLI_OBS)"

    CONFIG_DEPS="$CONFIG_DEPS \$(SUBDIR_CLI_DEPS)"

    CONFIG_SRCS="$CONFIG_SRCS \$(SUBDIR_CLI_SRCS)"

    ENABLE_CFLAGS="$ENABLE_CFLAGS \$(SUBDIR_CLI_CFLAGS)"

  fi

fi

# Enable MI.

AC_ARG_ENABLE(gdbmi,

AS_HELP_STRING([--disable-gdbmi], [disable machine-interface (MI)]),

  [case $enableval in

    yes | no)

      ;;

    *)

      AC_MSG_ERROR([bad value $enableval for --enable-gdbmi]) ;;

  esac],

  [enable_gdbmi=yes])

if test x"$enable_gdbmi" = xyes; then

  if test -d $srcdir/mi; then

    CONFIG_OBS="$CONFIG_OBS \$(SUBDIR_MI_OBS)"

    CONFIG_DEPS="$CONFIG_DEPS \$(SUBDIR_MI_DEPS)"

    CONFIG_SRCS="$CONFIG_SRCS \$(SUBDIR_MI_SRCS)"

    ENABLE_CFLAGS="$ENABLE_CFLAGS \$(SUBDIR_MI_CFLAGS)"

  fi

fi

# Enable TUI.

AC_ARG_ENABLE(tui,

AS_HELP_STRING([--enable-tui], [enable full-screen terminal user interface (TUI)]),

  [case $enableval in

    yes | no | auto)

      ;;

    *)

      AC_MSG_ERROR([bad value $enableval for --enable-tui]) ;;

  esac],enable_tui=auto)

# Enable gdbtk.

AC_ARG_ENABLE(gdbtk,

AS_HELP_STRING([--enable-gdbtk], [enable gdbtk graphical user interface (GUI)]),

  [case $enableval in

    yes | no)

      ;;

    *)

      AC_MSG_ERROR([bad value $enableval for --enable-gdbtk]) ;;

  esac],

  [if test -d $srcdir/gdbtk; then

    enable_gdbtk=yes

  else

    enable_gdbtk=no

  fi])

# We unconditionally disable gdbtk tests on selected platforms.

case $host_os in

  go32* | windows*)

    AC_MSG_WARN([gdbtk isn't supported on $host; disabling])

    enable_gdbtk=no ;;

esac

# Libunwind support.

AC_ARG_WITH(libunwind,

AS_HELP_STRING([--with-libunwind], [use libunwind frame unwinding support]),

[case "${withval}" in

  yes)  enable_libunwind=yes ;;

  no)   enable_libunwind=no ;;

  *)    AC_MSG_ERROR(bad value ${withval} for GDB with-libunwind option) ;;

esac],[

  AC_CHECK_HEADERS(libunwind.h libunwind-ia64.h)

  if test x"$ac_cv_header_libunwind_h" = xyes -a x"$ac_cv_header_libunwind_ia64_h" = xyes; then

    enable_libunwind=yes;

  fi

])

if test x"$enable_libunwind" = xyes; then

  AC_CHECK_HEADERS(libunwind.h libunwind-ia64.h)

  AC_DEFINE(HAVE_LIBUNWIND, 1, [Define if libunwind library is being used.])

  CONFIG_OBS="$CONFIG_OBS libunwind-frame.o"

  CONFIG_DEPS="$CONFIG_DEPS libunwind-frame.o"

  CONFIG_SRCS="$CONFIG_SRCS libunwind-frame.c"

fi

opt_curses=no

AC_ARG_WITH(curses, AS_HELP_STRING([--with-curses], [use the curses library instead of the termcap library]), opt_curses=$withval)

prefer_curses=no

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

  prefer_curses=yes

fi

# Profiling support.

AC_ARG_ENABLE(profiling,

AS_HELP_STRING([--enable-profiling], [enable profiling of GDB]),

  [case $enableval in

    yes | no)

      ;;

    *)

      AC_MSG_ERROR([bad value $enableval for --enable-profile]) ;;

  esac],

 [enable_profiling=no])

AC_CHECK_FUNCS(monstartup _mcleanup)

AC_CACHE_CHECK([for _etext], ac_cv_var__etext,

[AC_TRY_LINK(

[#include 

extern char _etext;

],

[free (&_etext);], ac_cv_var__etext=yes, ac_cv_var__etext=no)])

if test $ac_cv_var__etext = yes; then

  AC_DEFINE(HAVE__ETEXT, 1,

            [Define to 1 if your system has the _etext variable. ])

fi

AC_CACHE_CHECK([for etext], ac_cv_var_etext,

[AC_TRY_LINK(

[#include 

extern char etext;

],

[free (&etext);], ac_cv_var_etext=yes, ac_cv_var_etext=no)])

if test $ac_cv_var_etext = yes; then

  AC_DEFINE(HAVE_ETEXT, 1,

            [Define to 1 if your system has the etext variable. ])

fi

if test "$enable_profiling" = yes ; then

  if test $ac_cv_func_monstartup = no || test $ac_cv_func__mcleanup = no; then

    AC_MSG_ERROR(--enable-profiling requires monstartup and _mcleanup)

  fi

  PROFILE_CFLAGS=-pg

  OLD_CFLAGS="$CFLAGS"

  CFLAGS="$CFLAGS $PROFILE_CFLAGS"

  AC_CACHE_CHECK([whether $CC supports -pg], ac_cv_cc_supports_pg,

    [AC_TRY_COMPILE([], [int x;], ac_cv_cc_supports_pg=yes,

     ac_cv_cc_supports_pg=no)])

  if test $ac_cv_cc_supports_pg = no; then

    AC_MSG_ERROR(--enable-profiling requires a compiler which supports -pg)

  fi

  CFLAGS="$OLD_CFLAGS"

fi

ACX_PKGVERSION([GDB])

ACX_BUGURL([http://www.gnu.org/software/gdb/bugs/])

AC_DEFINE_UNQUOTED([PKGVERSION], ["$PKGVERSION"], [Additional package description])

AC_DEFINE_UNQUOTED([REPORT_BUGS_TO], ["$REPORT_BUGS_TO"], [Bug reporting address])

# --------------------- #

# Checks for programs.  #

# --------------------- #

AC_PROG_AWK

AC_PROG_INSTALL

AC_PROG_LN_S

AC_PROG_RANLIB

AC_PROG_YACC

AC_CHECK_TOOL(AR, ar)

AC_CHECK_TOOL(DLLTOOL, dlltool)

AC_CHECK_TOOL(WINDRES, windres)

# Needed for GNU/Hurd.

AC_CHECK_TOOL(MIG, mig)

# ---------------------- #

# Checks for libraries.  #

# ---------------------- #

# We might need to link with -lm; most simulators need it.

AC_CHECK_LIB(m, main)

# We need to link with -lw to get `wctype' on Solaris before Solaris

# 2.6.  Solaris 2.6 and beyond have this function in libc, and have a

# libw that some versions of the GNU linker cannot hanle (GNU ld 2.9.1

# is known to have this problem).  Therefore we avoid libw if we can.

AC_CHECK_FUNC(wctype, [],

  [AC_CHECK_LIB(w, wctype)])

# Some systems (e.g. Solaris) have `gethostbyname' in libnsl.

AC_SEARCH_LIBS(gethostbyname, nsl)

# Some systems (e.g. Solaris) have `socketpair' in libsocket.

AC_SEARCH_LIBS(socketpair, socket)

# Link in zlib if we can.  This allows us to read compressed debug sections.

AM_ZLIB

# On HP/UX we may need libxpdl for dlgetmodinfo (used by solib-pa64.c).

AC_SEARCH_LIBS(dlgetmodinfo, [dl xpdl])

AM_ICONV

# On alpha-osf, it appears that libtermcap and libcurses are not compatible.

# There is a very specific comment in /usr/include/curses.h explaining that

# termcap routines built into libcurses must not be used.

#

# The symptoms we observed so far is GDB unexpectedly changing

# the terminal settings when tgetent is called - this is particularly

# visible as the output is missing carriage returns, and so rapidly

# becomes very hard to read.

#

# The readline configure script has already decided that libtermcap

# was enough for its purposes, and so decided to build readline using

# libtermcap.  Since the TUI mode requires curses, building GDB with

# TUI enabled results in both libraries to be used at the same time,

# which is not allowed.  This basically means that GDB with TUI is

# broken on alpha-osf.

case $host_os in

  osf* )

    if test x"$enable_tui" = xyes; then

      AC_MSG_ERROR([Building GDB with TUI mode is not supported on this host])

    fi

    if test x"$enable_tui" = xauto; then

      enable_tui=no

    fi

    ;;

esac

# For the TUI, we need enhanced curses functionality.

if test x"$enable_tui" != xno; then

  prefer_curses=yes

fi

curses_found=no

if test x"$prefer_curses" = xyes; then

  # FIXME: kettenis/20040905: We prefer ncurses over the vendor-supplied

  # curses library because the latter might not provide all the

  # functionality we need.  However, this leads to problems on systems

  # where the linker searches /usr/local/lib, but the compiler doesn't

  # search /usr/local/include, if ncurses is installed in /usr/local.  A

  # default installation of ncurses on alpha*-dec-osf* will lead to such

  # a situation.

  AC_SEARCH_LIBS(waddstr, [ncurses cursesX curses])

  if test "$ac_cv_search_waddstr" != no; then

    curses_found=yes

  fi

fi

# Check whether we should enable the TUI, but only do so if we really

# can.

if test x"$enable_tui" != xno; then

  if test -d $srcdir/tui; then

    if test "$curses_found" != no; then

      CONFIG_OBS="$CONFIG_OBS \$(SUBDIR_TUI_OBS)"

      CONFIG_DEPS="$CONFIG_DEPS \$(SUBDIR_TUI_DEPS)"

      CONFIG_SRCS="$CONFIG_SRCS \$(SUBDIR_TUI_SRCS)"

      ENABLE_CFLAGS="$ENABLE_CFLAGS \$(SUBDIR_TUI_CFLAGS)"

      CONFIG_ALL="${CONFIG_ALL} all-tui"

      CONFIG_CLEAN="${CONFIG_CLEAN} clean-tui"

      CONFIG_INSTALL="${CONFIG_INSTALL} install-tui"

      CONFIG_UNINSTALL="${CONFIG_UNINSTALL} uninstall-tui"

    else

      if test x"$enable_tui" = xyes; then

        AC_MSG_ERROR([no enhanced curses library found; disable TUI])

      else

        AC_MSG_WARN([no enhanced curses library found; disabling TUI])

      fi

    fi

  fi

fi

# Since GDB uses Readline, we need termcap functionality.  In many

# cases this will be provided by the curses library, but some systems

# have a seperate termcap library, or no curses library at all.

case $host_os in

  cygwin*)

    if test -d $srcdir/libtermcap; then

      LIBS="../libtermcap/libtermcap.a $LIBS"

      ac_cv_search_tgetent="../libtermcap/libtermcap.a"

    fi ;;

  go32* | *djgpp*)

    ac_cv_search_tgetent="none required"

    ;;

  *mingw32*)

    ac_cv_search_tgetent="none required"

    CONFIG_OBS="$CONFIG_OBS windows-termcap.o"

    ;;

esac

# These are the libraries checked by Readline.

AC_SEARCH_LIBS(tgetent, [termcap tinfo curses ncurses])

if test "$ac_cv_search_tgetent" = no; then

  AC_MSG_ERROR([no termcap library found])

fi

AC_ARG_WITH([system-readline],

  [AS_HELP_STRING([--with-system-readline],

                  [use installed readline library])])

if test "$with_system_readline" = yes; then

  READLINE=-lreadline

  READLINE_DEPS=

  READLINE_CFLAGS=

  # readline-6.0 started to use the name `_rl_echoing_p'.

  # `$(READLINE_DIR)/' of bundled readline would not resolve in configure.

  AC_MSG_CHECKING([for readline_echoing_p])

  save_LIBS=$LIBS

  LIBS="$LIBS $READLINE"

  AC_LINK_IFELSE(AC_LANG_PROGRAM(,[[extern int readline_echoing_p;

                                    return readline_echoing_p;]]),

                 [READLINE_ECHOING_P=yes],

                 [READLINE_ECHOING_P=no

                  AC_DEFINE([readline_echoing_p], [_rl_echoing_p],

                            [readline-6.0 started to use different name.])])

  LIBS="$save_LIBS"

  AC_MSG_RESULT([$READLINE_ECHOING_P])

else

  READLINE='$(READLINE_DIR)/libreadline.a'

  READLINE_DEPS='$(READLINE)'

  READLINE_CFLAGS='-I$(READLINE_SRC)/..'

fi

AC_SUBST(READLINE)

AC_SUBST(READLINE_DEPS)

AC_SUBST(READLINE_CFLAGS)

AC_ARG_WITH(expat,

  AS_HELP_STRING([--with-expat], [include expat support (auto/yes/no)]),

  [], [with_expat=auto])

AC_MSG_CHECKING([whether to use expat])

AC_MSG_RESULT([$with_expat])

if test "${with_expat}" = no; then

  AC_MSG_WARN([expat support disabled; some features may be unavailable.])

  HAVE_LIBEXPAT=no

else

  AC_LIB_HAVE_LINKFLAGS([expat], [], [#include "expat.h"],

                        [XML_Parser p = XML_ParserCreate (0);])

  if test "$HAVE_LIBEXPAT" != yes; then

    if test "$with_expat" = yes; then

      AC_MSG_ERROR([expat is missing or unusable])

    else

      AC_MSG_WARN([expat is missing or unusable; some features may be unavailable.])

    fi

  else

    save_LIBS=$LIBS

    LIBS="$LIBS $LIBEXPAT"

    AC_CHECK_FUNCS(XML_StopParser)

    LIBS=$save_LIBS

  fi

fi

dnl Utility to simplify finding libpython.

dnl $1 = pythonX.Y

dnl $2 = the shell variable to assign the result to

dnl      If libpython is found we store $version here.

dnl $3 = additional flags to add to CPPFLAGS

dnl $4 = additional flags to add to LIBS

AC_DEFUN([AC_TRY_LIBPYTHON],

[

  version=$1

  define([have_libpython_var],$2)

  new_CPPFLAGS=$3

  new_LIBS=$4

  AC_MSG_CHECKING([for ${version}])

  save_CPPFLAGS=$CPPFLAGS

  save_LIBS=$LIBS

  CPPFLAGS="$CPPFLAGS $new_CPPFLAGS"

  LIBS="$LIBS $new_LIBS"

  found_usable_python=no

  AC_LINK_IFELSE(AC_LANG_PROGRAM([[#include "${version}/Python.h"]],

                                 [[Py_Initialize ();]]),

                 [have_libpython_var=${version}

                  found_usable_python=yes],

                 [CPPFLAGS=$save_CPPFLAGS

                  LIBS=$save_LIBS])

  AC_MSG_RESULT([${found_usable_python}])

])

dnl There are several different values for --with-python:

dnl

dnl no -   Don't include python support.

dnl yes -  Include python support, error if it's missing.

dnl        If we find python in $PATH, use it to fetch configure options,

dnl        otherwise assume the compiler can find it with no help from us.

dnl        Python 2.7, 2.6, 2.5, and then 2.4 are tried in turn.

dnl auto - Same as "yes", but if python is missing from the system,

dnl        fall back to "no".

dnl /path/to/python/exec-prefix -

dnl        Use the python located in this directory.

dnl        If /path/to/python/exec-prefix/bin/python exists, use it to find

dnl        the compilation parameters.  Otherwise use

dnl        -I/path/to/python/exec-prefix/include,

dnl        -L/path/to/python/exec-prefix/lib.

dnl        Python 2.7, 2.6, 2.5, and then 2.4 are tried in turn.

dnl        NOTE: This case is historical.  It is what was done for 7.0/7.1

dnl        but is deprecated.

dnl /path/to/python/executable -

dnl        Run python-config.py with this version of python to fetch the

dnl        compilation parameters.

dnl        NOTE: This needn't be the real python executable.

dnl        In a cross-compilation scenario (build != host), this could be

dnl        a shell script that provides what python-config.py provides for

dnl        --ldflags, --includes, --exec-prefix.

dnl python-executable -

dnl        Find python-executable in $PATH, and then handle the same as

dnl        /path/to/python/executable.

dnl

dnl If a python program is specified, it is used to run python-config.py and

dnl is passed --ldflags, --includes, --exec-prefix.

AC_ARG_WITH(python,

  AS_HELP_STRING([--with-python@<:@=PYTHON@:>@], [include python support (auto/yes/no/)]),

  [], [with_python=auto])

AC_MSG_CHECKING([whether to use python])

AC_MSG_RESULT([$with_python])

if test "${with_python}" = no; then

  AC_MSG_WARN([python support disabled; some features may be unavailable.])

  have_libpython=no

else

  case "${with_python}" in

  /*)

    if test -d ${with_python}; then

      # Assume the python binary is ${with_python}/bin/python.

      python_prog="${with_python}/bin/python"

      python_prefix=

      if test ! -x "${python_prog}"; then

        # Fall back to gdb 7.0/7.1 behaviour.

        python_prog=missing

        python_prefix=${with_python}

      fi

    elif test -x "${with_python}"; then

      # While we can't run python compiled for $host (unless host == build),

      # the user could write a script that provides the needed information,

      # so we support that.

      python_prog=${with_python}

      python_prefix=

    else

      AC_ERROR(invalid value for --with-python)

    fi

    ;;

  */*)

    # Disallow --with-python=foo/bar.

    AC_ERROR(invalid value for --with-python)

    ;;

  *)

    # The user has either specified auto, yes, or the name of the python

    # program assumed to be in $PATH.

    python_prefix=

    case "${with_python}" in

    yes | auto)

      if test ${build} = ${host}; then

        AC_PATH_PROG(python_prog_path, python, missing)

        if test "${python_prog_path}" = missing; then

          python_prog=missing

        else

          python_prog=${python_prog_path}

        fi

      else

        # Not much we can do except assume the cross-compiler will find the

        # right files.

        python_prog=missing

      fi

      ;;

    *)

      # While we can't run python compiled for $host (unless host == build),

      # the user could write a script that provides the needed information,

      # so we support that.

      python_prog="${with_python}"

      AC_PATH_PROG(python_prog_path, ${python_prog}, missing)

      if test "${python_prog_path}" = missing; then

        AC_ERROR(unable to find python program ${python_prog})

      fi

      ;;

    esac

  esac

  if test "${python_prog}" != missing; then

    # We have a python program to use, but it may be too old.

    # Don't flag an error for --with-python=auto (the default).

    have_python_config=yes

    python_includes=`${python_prog} ${srcdir}/python/python-config.py --includes`

    if test $? != 0; then

      have_python_config=failed

      if test "${with_python}" != auto; then

        AC_ERROR(failure running python-config --includes)

      fi

    fi

    python_libs=`${python_prog} ${srcdir}/python/python-config.py --ldflags`

    if test $? != 0; then

      have_python_config=failed

      if test "${with_python}" != auto; then

        AC_ERROR(failure running python-config --ldflags)

      fi

    fi

    python_prefix=`${python_prog} ${srcdir}/python/python-config.py --exec-prefix`

    if test $? != 0; then

      have_python_config=failed

      if test "${with_python}" != auto; then

        AC_ERROR(failure running python-config --exec-prefix)

      fi

    fi

  else

    # Fall back to gdb 7.0/7.1 behaviour.

    if test -z ${python_prefix}; then

      python_includes=

      python_libs=

    else

      python_includes="-I${python_prefix}/include"

      python_libs="-L${python_prefix}/lib"

    fi

    have_python_config=no

  fi

  # Having "/pythonX.Y" in the include path is awkward.

  # All those python headers get bubbled up to the top inviting lots

  # of random collisions.  GDB originally didn't use python-config to

  # find the compilation parameters and includes "pythonX.Y/" in the

  # path of the, umm, include file.  So strip away this part of the

  # output of python-config --includes.

  python_includes=`echo "${python_includes} " \

                        | sed -e 's,/python[[0-9]]*[[.]][[0-9]]* , ,g'`

  # If we have python-config, only try the configuration it provides.

  # Otherwise fallback on the old way of trying different versions of

  # python in turn.

  have_libpython=no

  if test "${have_python_config}" = yes; then

    python_version=`echo " ${python_libs} " \

                         | sed -e 's,^.* -l\(python[[0-9]]*[[.]][[0-9]]*\) .*$,\1,'`

    case "${python_version}" in

    python*)

      AC_TRY_LIBPYTHON(${python_version}, have_libpython,

                       ${python_includes}, ${python_libs})

      ;;

    *)

      AC_MSG_ERROR([unable to determine python version from ${python_libs}])

      ;;

    esac

  elif test "${have_python_config}" != failed; then

    if test "${have_libpython}" = no; then

      AC_TRY_LIBPYTHON(python2.7, have_libpython,

                       ${python_includes}, "${python_libs} -lpython2.7")

    fi

    if test "${have_libpython}" = no; then

      AC_TRY_LIBPYTHON(python2.6, have_libpython,

                       ${python_includes}, "${python_libs} -lpython2.6")

    fi

    if test ${have_libpython} = no; then

      AC_TRY_LIBPYTHON(python2.5, have_libpython,

                       ${python_includes}, "${python_libs} -lpython2.5")

    fi

    if test ${have_libpython} = no; then

      AC_TRY_LIBPYTHON(python2.4, have_libpython,

                       ${python_includes}, "${python_libs} -lpython2.4")

    fi

  fi

  if test "${have_libpython}" = python2.7; then

    AC_DEFINE(HAVE_LIBPYTHON2_7, 1, [Define if Python 2.7 is being used.])

  elif test "${have_libpython}" = python2.6; then

    AC_DEFINE(HAVE_LIBPYTHON2_6, 1, [Define if Python 2.6 is being used.])

  elif test "${have_libpython}" = python2.5; then

    AC_DEFINE(HAVE_LIBPYTHON2_5, 1, [Define if Python 2.5 is being used.])

  elif test "${have_libpython}" = python2.4; then

    AC_DEFINE(HAVE_LIBPYTHON2_4, 1, [Define if Python 2.4 is being used.])

  fi

  if test "${have_libpython}" = no; then

    case "${with_python}" in

    yes)

      AC_MSG_ERROR([python is missing or unusable])

      ;;

    auto)

      AC_MSG_WARN([python is missing or unusable; some features may be unavailable.])

      ;;

    *)

      AC_MSG_ERROR([no usable python found at ${with_python}])

      ;;

    esac

  else

    if test -n "${python_prefix}"; then

      AC_DEFINE_UNQUOTED(WITH_PYTHON_PATH, "${python_prefix}",

                         [Define if --with-python provides a path, either directly or via python-config.py --exec-prefix.])

      GDB_AC_DEFINE_RELOCATABLE(PYTHON_PATH, python, ${python_prefix})

    fi

  fi

fi

if test "${have_libpython}" != no; then

  AC_DEFINE(HAVE_PYTHON, 1, [Define if Python interpreter is being linked in.])

  CONFIG_OBS="$CONFIG_OBS \$(SUBDIR_PYTHON_OBS)"

  CONFIG_DEPS="$CONFIG_DEPS \$(SUBDIR_PYTHON_DEPS)"

  CONFIG_SRCS="$CONFIG_SRCS \$(SUBDIR_PYTHON_SRCS)"

  CONFIG_INSTALL="$CONFIG_INSTALL install-python"

  ENABLE_CFLAGS="$ENABLE_CFLAGS \$(SUBDIR_PYTHON_CFLAGS)"

  # Flags needed to compile Python code (taken from python-config --cflags).

  # We cannot call python-config directly because it will output whatever was

  # used when compiling the Python interpreter itself, including flags which

  # would make the python-related objects be compiled differently from the

  # rest of GDB (e.g., -O2 and -fPIC).

  if test "${GCC}" = yes; then

    tentative_python_cflags="-fno-strict-aliasing -DNDEBUG -fwrapv"

  fi

  if test "x${tentative_python_cflags}" != x; then

    AC_MSG_CHECKING(compiler flags for python code)

    for flag in ${tentative_python_cflags}; do

      # Check that the compiler accepts it

      saved_CFLAGS="$CFLAGS"

      CFLAGS="$CFLAGS $flag"

      AC_TRY_COMPILE([],[],PYTHON_CFLAGS="${PYTHON_CFLAGS} $flag",)

      CFLAGS="$saved_CFLAGS"

    done

    AC_MSG_RESULT(${PYTHON_CFLAGS})

  fi

else

  # Even if Python support is not compiled in, we need to have these files

  # included.

  CONFIG_OBS="$CONFIG_OBS python.o py-value.o py-prettyprint.o py-auto-load.o"

  CONFIG_SRCS="$CONFIG_SRCS python/python.c python/py-value.c \

        python/py-prettyprint.c python/py-auto-load.c"

fi

AC_SUBST(PYTHON_CFLAGS)

# ------------------------- #

# Checks for header files.  #

# ------------------------- #

AC_HEADER_DIRENT

AC_HEADER_STAT

AC_HEADER_STDC

# elf_hp.h is for HP/UX 64-bit shared library support.

# FIXME: kettenis/20030102: In most cases we include these (ctype.h, time.h)

# unconditionally, so what's the point in checking these?

AC_CHECK_HEADERS([nlist.h machine/reg.h poll.h sys/poll.h proc_service.h \

                  thread_db.h gnu/libc-version.h signal.h stddef.h \

                  stdlib.h string.h memory.h strings.h sys/fault.h \

                  sys/file.h sys/filio.h sys/ioctl.h sys/param.h \

                  sys/resource.h sys/procfs.h sys/ptrace.h ptrace.h \

                  sys/reg.h sys/debugreg.h sys/select.h sys/syscall.h \

                  sys/types.h sys/wait.h wait.h termios.h termio.h \

                  sgtty.h unistd.h elf_hp.h ctype.h time.h locale.h])

AC_CHECK_HEADERS(link.h, [], [],

[#if HAVE_SYS_TYPES_H

# include 

#endif

#if HAVE_NLIST_H

# include 

#endif

])

AC_CHECK_HEADERS(sys/proc.h, [], [],

[#if HAVE_SYS_PARAM_H

# include 

#endif

])

AC_CHECK_HEADERS(sys/user.h, [], [],

[#if HAVE_SYS_PARAM_H

# include 

#endif

])

# On Solaris 2.[789], we need to define _MSE_INT_H to avoid a clash

# between  and  that would cause AC_CHECK_HEADERS to

# think that we don't have  if we're using GCC.

case $host_os in

  solaris2.[[789]])

    if test "$GCC" = yes; then

      AC_DEFINE(_MSE_INT_H, 1,

        [Define to 1 to avoid a clash between  and  on

   Solaris 2.[789] when using GCC. ])

    fi ;;

esac

AC_CHECK_HEADERS(curses.h cursesX.h ncurses.h ncurses/ncurses.h ncurses/term.h)

AC_CHECK_HEADERS(term.h, [], [],

[#if HAVE_CURSES_H

# include 

#endif

])

# ------------------------- #

# Checks for declarations.  #

# ------------------------- #

AC_CHECK_DECLS([free, malloc, realloc, strerror, strstr, getopt,

                snprintf, vsnprintf])

AM_LC_MESSAGES

# ----------------------- #

# Checks for structures.  #

# ----------------------- #

AC_CHECK_MEMBERS([struct stat.st_blocks, struct stat.st_blksize])

# ------------------ #

# Checks for types.  #