cross-compilation support for python build

configure.ac

 dnl ***********************************************
 dnl * Please run autoreconf to test your changes! *
 dnl ***********************************************
 
 # Set VERSION so we only need to edit in one place (i.e., here)
 m4_define(PYTHON_VERSION, 3.3)
 
 AC_PREREQ(2.65)
 
 AC_INIT(python, PYTHON_VERSION, http://bugs.python.org/)
@@ skipping 46 matching lines @@
 #endif
 
 #endif /*Py_PYCONFIG_H*/
 ])
 
 # We don't use PACKAGE_ variables, and they cause conflicts
 # with other autoconf-based packages that include Python.h
 grep -v 'define PACKAGE_' <confdefs.h >confdefs.h.new
 rm confdefs.h
 mv confdefs.h.new confdefs.h
+
+dnl makefile conditional (for future use)
+if test "x$cross_compiling" = xyes; then
+  CROSS_ON=''
+  CROSS_OFF='#'
+else
+  CROSS_ON='#'
+  CROSS_OFF=''
+fi
+AC_SUBST(CROSS_ON)
+AC_SUBST(CROSS_OFF)
+
+AC_PROG_LN_S
+if test "x$cross_compiling" = xyes; then
+  AC_MSG_WARN([cross-compilation is incomplete])
+
+  dnl In cross-compilation environment we need python from
+  dnl the build system (for future use)
+  AC_PATH_PROG(SYSPYTHON, python3, [none],
+    [$PATH:/usr/local/bin]
+  )
+  if test "x$PYTHON" = xnone; then
+    AC_MSG_ERROR([python program is required in cross-compilation environment])
+  fi
+  SYSPYOSNAME=`${SYSPYTHON} -c "import os; print(os.name)"`
+  case $SYSPYOSNAME in
+  posix)
+    dnl On posix distutils read variables from installed makefile.
+    dnl We will do some hacks based on distutils internals to overcome
+    dnl this limitation:
+    dnl - we link system python in build directory so that it will
+    dnl   read generated file.
+    dnl As result from sysconfig.get_config_vars we will get our
+    dnl setting (for the host system) like SO, CFLAGS, CPPFLAGS,
+    dnl LDFLAGS instead those for the build system.
+    rm -f syspython3
+    ${LN_S} ${SYSPYTHON} syspython3
+    SYSPYTHON=./syspython3
+  esac
+fi
 
 AC_SUBST(VERSION)
 VERSION=PYTHON_VERSION
 
 # Version number of Python's own shared library file.
 AC_SUBST(SOVERSION)
 SOVERSION=1.0
 
 # The later defininition of _XOPEN_SOURCE disables certain features
 # on Linux, so we need _GNU_SOURCE to re-enable them (makedev, tm_zone).
@@ skipping 204 matching lines @@
 AC_SUBST(FRAMEWORKALTINSTALLFIRST)
 AC_SUBST(FRAMEWORKALTINSTALLLAST)
 AC_SUBST(FRAMEWORKUNIXTOOLSPREFIX)
 AC_SUBST(FRAMEWORKINSTALLAPPSPREFIX)
 
 ##AC_ARG_WITH(dyld,
 ##            AS_HELP_STRING([--with-dyld],
 ##                           [Use (OpenStep|Rhapsody) dynamic linker]))
 ##
 # Set name for machine-dependent library files
+dnl Now configure script support cross-compilation and detection of host
+dnl system based on value of $ac_sys_system and/or $ac_sys_release
+dnl has to be avoided. It is superseded by "host triplet"(cpu-verdor-os).
+dnl FIXME: replace all cases based on $ac_sys_system and/or $ac_sys_release
+dnl with case based on $host ("host triplet") or $host_os.
+dnl Also cases with MACHDEP may be replaces by $host or $host_os. Note
+dnl script may not set this variable if cross compiling.
+
+dnl Next two variables are intended to be passed through makefile to other
+dnl scripts. As example setup.py check for CPU(machine) and OS(platform).
+HOST_CPU=$host_cpu
+AC_SUBST(HOST_CPU)
+HOST_OS=$host_os
+AC_SUBST(HOST_OS)
+
 AC_SUBST(MACHDEP)
+if test "x$cross_compiling" = xyes; then
+dnl Note that $host_os cannot be translated directly into python
+dnl specific $MACHDEP.
+AC_MSG_WARN([
+  May be value of MACHDEP isn't correct if cross-compiling.
+  You may tweak configure script for you host system: $host])
+fi
 AC_MSG_CHECKING(MACHDEP)
 if test -z "$MACHDEP"
 then
     # avoid using uname for cross builds
     if test "$cross_compiling" = yes; then
        # ac_sys_system and ac_sys_release are only used for setting
        # `define_xopen_source' in the case statement below. For the
        # current supported cross builds, this macro is not adjusted.
         case "$host" in
         *-*-linux*)
@@ skipping 20 matching lines @@
     ac_md_system=`echo $ac_sys_system |
                         tr -d '[/ ]' | tr '[[A-Z]]' '[[a-z]]'`
     ac_md_release=`echo $ac_sys_release |
                         tr -d '[/ ]' | sed 's/^[[A-Z]]\.//' | sed 's/\..*//'`
     MACHDEP="$ac_md_system$ac_md_release"
 
     case $MACHDEP in
         linux*) MACHDEP="linux";;
         cygwin*) MACHDEP="cygwin";;
         darwin*) MACHDEP="darwin";;
-        irix646) MACHDEP="irix6";;
+        irix646) MACHDEP="irix6";;
         '')     MACHDEP="unknown";;
     esac
 fi
         
 # Some systems cannot stand _XOPEN_SOURCE being defined at all; they
 # disable features if it is defined, without any means to access these
 # features as extensions. For these systems, we skip the definition of
 # _XOPEN_SOURCE. Before adding a system to the list to gain access to
 # some feature, make sure there is no alternative way to access this
 # feature. Also, when using wildcards, make sure you have verified the
@@ skipping 386 matching lines @@
   CYGWIN*)
     enable_shared="yes";;
   *)
     enable_shared="no";;
   esac
 fi
 AC_MSG_RESULT($enable_shared)
 
 AC_MSG_CHECKING(for --enable-profiling)
 AC_ARG_ENABLE(profiling,
-              AS_HELP_STRING([--enable-profiling], [enable C-level code profiling]),
-[ac_save_cc="$CC"
- CC="$CC -pg"
- AC_RUN_IFELSE([AC_LANG_SOURCE([[int main() { return 0; }]])],
-   [ac_enable_profiling="yes"],
-   [ac_enable_profiling="no"],
-   [ac_enable_profiling="no"])
- CC="$ac_save_cc"])
-AC_MSG_RESULT($ac_enable_profiling)
-
-case "$ac_enable_profiling" in
-    "yes")
-        BASECFLAGS="-pg $BASECFLAGS"
-        LDFLAGS="-pg $LDFLAGS"
-    ;;
-esac
+              AS_HELP_STRING([--enable-profiling], [enable C-level code profiling]))
+if test "x$enable_profiling" = xyes; then
+  py_save_CFLAGS="$CFLAGS"
+  CFLAGS="$CFLAGS -pg"
+  AC_COMPILE_IFELSE([AC_LANG_SOURCE([[]])],
+    [],
+    [enable_profiling=no])
+  CFLAGS="$py_save_CFLAGS"
+else
+  enable_profiling=no
+fi
+AC_MSG_RESULT($enable_profiling)
+
+if test "x$enable_profiling" = xyes; then
+  BASECFLAGS="-pg $BASECFLAGS"
+  LDFLAGS="-pg $LDFLAGS"
+fi
 
 AC_MSG_CHECKING(LDLIBRARY)
 
 # MacOSX framework builds need more magic. LDLIBRARY is the dynamic
 # library that we build, but we do not want to link against it (we
 # will find it with a -framework option). For this reason there is an
 # extra variable BLDLIBRARY against which Python and the extension
 # modules are linked, BLDLIBRARY. This is normally the same as
 # LDLIBRARY, but empty for MacOSX framework builds.
 if test "$enable_framework"
@@ skipping 66 matching lines @@
     CYGWIN*)
           BLDLIBRARY='$(LIBRARY)'
           LDLIBRARY='libpython$(LDVERSION).dll.a'
           ;;
   esac
 fi
 
 AC_MSG_RESULT($LDLIBRARY)
 
 AC_PROG_RANLIB
-AC_SUBST(AR)
-AC_CHECK_PROGS(AR, ar aal, ar)
+AC_CHECK_TOOLS(AR, ar aal, ar)
 
 # tweak ARFLAGS only if the user didn't set it on the command line
 AC_SUBST(ARFLAGS)
 if test -z "$ARFLAGS"
 then
         ARFLAGS="rc"
 fi
 
 AC_SUBST(DISABLE_ASDLGEN)
 DISABLE_ASDLGEN=""
@@ skipping 417 matching lines @@
 fi
 
 if test $ac_cv_kthread = no -a $ac_cv_pthread_is_default = no
 then
 # -pthread, if available, provides the right #defines
 # and linker options to make pthread_create available
 # Some compilers won't report that they do not support -pthread,
 # so we need to run a program to see whether it really made the
 # function available.
 AC_MSG_CHECKING(whether $CC accepts -pthread)
-AC_CACHE_VAL(ac_cv_thread,
+AC_CACHE_VAL(ac_cv_pthread,
 [ac_save_cc="$CC"
 CC="$CC -pthread"
 AC_RUN_IFELSE([AC_LANG_SOURCE([[
 #include <pthread.h>
 
 void* routine(void* p){return NULL;}
 
 int main(){
   pthread_t p;
   if(pthread_create(&p,NULL,routine,NULL)!=0)
@@ skipping 286 matching lines @@
 # if have pthread_t then define SIZEOF_PTHREAD_T
 ac_save_cc="$CC"
 if test "$ac_cv_kpthread" = "yes"
 then CC="$CC -Kpthread"
 elif test "$ac_cv_kthread" = "yes"
 then CC="$CC -Kthread"
 elif test "$ac_cv_pthread" = "yes"
 then CC="$CC -pthread"
 fi
 
-AC_MSG_CHECKING(for pthread_t)
-have_pthread_t=no
-AC_COMPILE_IFELSE([
-  AC_LANG_PROGRAM([[#include <pthread.h>]], [[pthread_t x; x = *(pthread_t*)0;]])
-],[have_pthread_t=yes],[])
-AC_MSG_RESULT($have_pthread_t)
-if test "$have_pthread_t" = yes ; then
+dnl NOTE: avoid duplicate check for pthread_t(it is done in AC_CHECK_SIZEOF(pthread_t...) )
+dnl AC_MSG_CHECKING(for pthread_t)
+dnl have_pthread_t=no
+dnl AC_COMPILE_IFELSE([
+dnl   AC_LANG_PROGRAM([[#include <pthread.h>]], [[pthread_t x; x = *(pthread_t*)0;]])
+dnl ],[have_pthread_t=yes],[])
+dnl AC_MSG_RESULT($have_pthread_t)
+dnl if test "$have_pthread_t" = yes ; then
   AC_CHECK_SIZEOF(pthread_t, [], [
 #ifdef HAVE_PTHREAD_H
 #include <pthread.h>
 #endif
   ])
-fi
+dnl fi
 CC="$ac_save_cc"
 
 AC_SUBST(OTHER_LIBTOOL_OPT)
 case $ac_sys_system/$ac_sys_release in
   Darwin/@<:@01567@:>@\..*) 
     OTHER_LIBTOOL_OPT="-prebind -seg1addr 0x10000000"
     ;;
   Darwin/*)
     OTHER_LIBTOOL_OPT=""
     ;;
@@ skipping 897 matching lines @@
 [AC_MSG_RESULT(no)])
 
 # Check for Python-specific malloc support
 AC_MSG_CHECKING(for --with-pymalloc)
 AC_ARG_WITH(pymalloc,
             AS_HELP_STRING([--with(out)-pymalloc], [disable/enable specialized mallocs]))
 
 if test -z "$with_pymalloc"
 then
     with_pymalloc="yes"
-    ABIFLAGS="${ABIFLAGS}m"
 fi
 if test "$with_pymalloc" != "no"
 then
     AC_DEFINE(WITH_PYMALLOC, 1, 
      [Define if you want to compile in Python-specific mallocs])
+    ABIFLAGS="${ABIFLAGS}m"
 fi
 AC_MSG_RESULT($with_pymalloc)
 
 # Check for Valgrind support
 AC_MSG_CHECKING([for --with-valgrind])
 AC_ARG_WITH([valgrind],
   AS_HELP_STRING([--with-valgrind], [Enable Valgrind support]),,
   with_valgrind=no)
 AC_MSG_RESULT([$with_valgrind])
 if test "$with_valgrind" != no; then
@@ skipping 48 matching lines @@
 # MACHDEP_OBJS can be set to platform-specific object files needed by Python
 
 AC_SUBST(MACHDEP_OBJS)
 AC_MSG_CHECKING(MACHDEP_OBJS)
 if test -z "$MACHDEP_OBJS"
 then
         MACHDEP_OBJS=$extra_machdep_objs
 else
         MACHDEP_OBJS="$MACHDEP_OBJS $extra_machdep_objs"
 fi
-AC_MSG_RESULT(MACHDEP_OBJS)
+if test -z "$MACHDEP_OBJS"; then
+  AC_MSG_RESULT([none])
+else
+  AC_MSG_RESULT([$MACHDEP_OBJS])
+fi
 
 # checks for library functions
 AC_CHECK_FUNCS(alarm accept4 setitimer getitimer bind_textdomain_codeset chown \
  clock confstr ctermid execv faccessat fchmod fchmodat fchown fchownat \
  fexecve fdopendir fork fpathconf fstatat ftime ftruncate futimesat \
  futimens futimes gai_strerror \
  getgrouplist getgroups getlogin getloadavg getpeername getpgid getpid \
  getpriority getresuid getresgid getpwent getspnam getspent getsid getwd \
  if_nameindex \
  initgroups kill killpg lchmod lchown lockf linkat lstat lutimes mmap \
@@ skipping 439 matching lines @@
 [
 if test "${enable_ipv6+set}" = set; then
   ac_cv_buggy_getaddrinfo="no -- configured with --(en|dis)able-ipv6"
 else
   ac_cv_buggy_getaddrinfo=yes
 fi]))
 fi
 
 AC_MSG_RESULT($ac_cv_buggy_getaddrinfo)
 
-if test $have_getaddrinfo = no -o "$ac_cv_buggy_getaddrinfo" = yes
+if test $have_getaddrinfo = no || test "$ac_cv_buggy_getaddrinfo" = yes
 then
         if test $ipv6 = yes
         then
                 echo 'Fatal: You must get working getaddrinfo() function.'
                 echo '       or you can specify "--disable-ipv6"'.
                 exit 1
         fi
 else
         AC_DEFINE(HAVE_GETADDRINFO, 1, [Define if you have the getaddrinfo function.])
 fi
@@ skipping 531 matching lines @@
 [ac_cv_posix_semaphores_enabled=yes])
 )
 AC_MSG_RESULT($ac_cv_posix_semaphores_enabled)
 if test $ac_cv_posix_semaphores_enabled = no
 then
   AC_DEFINE(POSIX_SEMAPHORES_NOT_ENABLED, 1,
             [Define if POSIX semaphores aren't enabled on your system])
 fi
 
 # Multiprocessing check for broken sem_getvalue
+if test $ac_cv_func_sem_getvalue = yes; then
 AC_MSG_CHECKING(for broken sem_getvalue)
 AC_CACHE_VAL(ac_cv_broken_sem_getvalue,
 AC_RUN_IFELSE([AC_LANG_SOURCE([[
 #include <unistd.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <semaphore.h>
 #include <sys/stat.h>
 
 int main(void){
@@ skipping 13 matching lines @@
 ]])],
 [ac_cv_broken_sem_getvalue=no],
 [ac_cv_broken_sem_getvalue=yes],
 [ac_cv_broken_sem_getvalue=yes])
 )
 AC_MSG_RESULT($ac_cv_broken_sem_getvalue)
 if test $ac_cv_broken_sem_getvalue = yes
 then
   AC_DEFINE(HAVE_BROKEN_SEM_GETVALUE, 1,
   [define to 1 if your sem_getvalue is broken.])
+fi
 fi
 
 # determine what size digit to use for Python's longs
 AC_MSG_CHECKING([digit size for Python's longs])
 AC_ARG_ENABLE(big-digits,
 AS_HELP_STRING([--enable-big-digits@<:@=BITS@:>@],[use big digits for Python longs [[BITS=30]]]),
 [case $enable_big_digits in
 yes)
   enable_big_digits=30 ;;
 no)
@@ skipping 167 matching lines @@
 
 # check where readline lives
 # save the value of LIBS so we don't actually link Python with readline
 LIBS_no_readline=$LIBS
 
 # On some systems we need to link readline to a termcap compatible
 # library.  NOTE: Keep the precedence of listed libraries synchronised
 # with setup.py.
 py_cv_lib_readline=no
 AC_MSG_CHECKING([how to link readline libs])
-for py_libtermcap in "" ncursesw ncurses curses termcap; do
+for py_libtermcap in "" tinfo ncursesw ncurses curses termcap; do
   if test -z "$py_libtermcap"; then
     READLINE_LIBS="-lreadline"
   else
     READLINE_LIBS="-lreadline -l$py_libtermcap"
   fi
   LIBS="$READLINE_LIBS $LIBS_no_readline"
   AC_LINK_IFELSE(
     [AC_LANG_CALL([],[readline])],
     [py_cv_lib_readline=yes])
   if test $py_cv_lib_readline = yes; then
     break
   fi
+  READLINE_LIBS=
 done
-# Uncomment this line if you want to use READINE_LIBS in Makefile or scripts
-#AC_SUBST([READLINE_LIBS])
+AC_SUBST([READLINE_LIBS])
 if test $py_cv_lib_readline = no; then
   AC_MSG_RESULT([none])
 else
   AC_MSG_RESULT([$READLINE_LIBS])
   AC_DEFINE(HAVE_LIBREADLINE, 1,
     [Define if you have the readline library (-lreadline).])
 fi
 
 # check for readline 2.1
 AC_CHECK_LIB(readline, rl_callback_handler_install,
@@ skipping 225 matching lines @@
 [ac_cv_mvwdelch_is_expression=no]))
 AC_MSG_RESULT($ac_cv_mvwdelch_is_expression)
 
 if test "$ac_cv_mvwdelch_is_expression" = yes
 then
   AC_DEFINE(MVWDELCH_IS_EXPRESSION, 1,
   [Define if mvwdelch in curses.h is an expression.])
 fi
 
 AC_MSG_CHECKING(whether WINDOW has _flags)
-AC_CACHE_VAL(ac_cv_window_has_flags,
 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[
   WINDOW *w;
   w->_flags = 0;
 ]])],
 [ac_cv_window_has_flags=yes],
-[ac_cv_window_has_flags=no]))
+[ac_cv_window_has_flags=no])
 AC_MSG_RESULT($ac_cv_window_has_flags)
 
+py_curses_window_is_opaque=no
+if test no = $ac_cv_window_has_flags; then
+  AC_MSG_CHECKING([whether WINDOW has _flags in non-opaque structure])
+  AC_COMPILE_IFELSE([
+  AC_LANG_PROGRAM([[
+    #define NCURSES_OPAQUE 0
+    #include <curses.h>
+  ]],[[
+    WINDOW *w;
+    w->_flags = 0;
+  ]])],
+  [py_curses_window_is_opaque=yes])
+  AC_MSG_RESULT([$py_curses_window_is_opaque])
+fi
+if test yes = $py_curses_window_is_opaque; then
+  ac_cv_window_has_flags=yes
+  AC_DEFINE([NCURSES_OPAQUE], [0], [Define to 0 if you have WINDOW _flags in non-opaque structure.])
+fi
+
+py_curses_window_is_internal=no
+if test no = $ac_cv_window_has_flags; then
+  AC_MSG_CHECKING([whether WINDOW has _flags as internal structure])
+  AC_COMPILE_IFELSE([
+  AC_LANG_PROGRAM([[
+    #define NCURSES_INTERNALS 1
+    #include <curses.h>
+  ]],[[
+    WINDOW *w;
+    w->_flags = 0;
+  ]])],
+  [py_curses_window_is_internal=yes])
+  AC_MSG_RESULT([$py_curses_window_is_internal])
+fi
+if test yes = $py_curses_window_is_internal; then
+  ac_cv_window_has_flags=yes
+  AC_DEFINE([NCURSES_INTERNALS], [1], [Define to 1 if you have WINDOW _flags as internal structure.])
+fi
 
 if test "$ac_cv_window_has_flags" = yes
 then
   AC_DEFINE(WINDOW_HAS_FLAGS, 1, 
   [Define if WINDOW in curses.h offers a field _flags.])
 fi
 
 AC_MSG_CHECKING(for is_term_resized)
 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[void *x=is_term_resized]])],
   [AC_DEFINE(HAVE_CURSES_IS_TERM_RESIZED, 1, Define if you have the 'is_term_resized' function.)
    AC_MSG_RESULT(yes)],
   [AC_MSG_RESULT(no)]
 )
 
 AC_MSG_CHECKING(for resize_term)
 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[void *x=resize_term]])],
   [AC_DEFINE(HAVE_CURSES_RESIZE_TERM, 1, Define if you have the 'resize_term' function.)
    AC_MSG_RESULT(yes)],
   [AC_MSG_RESULT(no)]
 )
 
 AC_MSG_CHECKING(for resizeterm)
 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <curses.h>]], [[void *x=resizeterm]])],
   [AC_DEFINE(HAVE_CURSES_RESIZETERM, 1, Define if you have the 'resizeterm' function.)
    AC_MSG_RESULT(yes)],
   [AC_MSG_RESULT(no)]
 )
 
-AC_MSG_CHECKING(for /dev/ptmx)
-
-if test -r /dev/ptmx
-then
-  AC_MSG_RESULT(yes)
+AC_MSG_NOTICE([checking for device files])
+
+dnl NOTE: Inform user how to proceed with files when cross compiling.
+if test "x$cross_compiling" = xyes; then
+  if test "${ac_cv_file__dev_ptmx+set}" != set; then
+    AC_MSG_CHECKING([for /dev/ptmx])
+    AC_MSG_RESULT([not set])
+    AC_MSG_ERROR([set ac_cv_file__dev_ptmx to yes/no in your CONFIG_SITE file when cross compiling])
+  fi
+  if test "${ac_cv_file__dev_ptc+set}" != set; then
+    AC_MSG_CHECKING([for /dev/ptc])
+    AC_MSG_RESULT([not set])
+    AC_MSG_ERROR([set ac_cv_file__dev_ptc to yes/no in your CONFIG_SITE file when cross compiling])
+  fi
+fi
+
+# FIXME: autoconf macro AC_CHECK_FILES is better but require additional
+# changes in posixmodule.c : 's/HAVE_DEV_/HAVE__DEV_/g'
+# To keep patch minimal I left defines as before.
+AC_CHECK_FILE(/dev/ptmx, [], [])
+if test "x$ac_cv_file__dev_ptmx" = xyes; then
   AC_DEFINE(HAVE_DEV_PTMX, 1,
-  [Define if we have /dev/ptmx.])
-else
-  AC_MSG_RESULT(no)
-fi
-
-AC_MSG_CHECKING(for /dev/ptc)
-
-if test -r /dev/ptc
-then
-  AC_MSG_RESULT(yes)
+  [Define to 1 if you have the /dev/ptmx device file.])
+fi
+AC_CHECK_FILE(/dev/ptc, [], [])
+if test "x$ac_cv_file__dev_ptc" = xyes; then
   AC_DEFINE(HAVE_DEV_PTC, 1,
-  [Define if we have /dev/ptc.])
-else
-  AC_MSG_RESULT(no)
+  [Define to 1 if you have the /dev/ptc device file.])
 fi
 
 if test "$have_long_long" = yes
 then
   AC_MSG_CHECKING(for %lld and %llu printf() format support)
   AC_CACHE_VAL(ac_cv_have_long_long_format,
   AC_RUN_IFELSE([AC_LANG_SOURCE([[[
   #include <stdio.h>
   #include <stddef.h>
   #include <string.h>
@@ skipping 285 matching lines @@
             AC_MSG_RESULT($have_ipa_pure_const_bug)
             if test "$have_ipa_pure_const_bug" = yes; then
                 AC_DEFINE(HAVE_IPA_PURE_CONST_BUG, 1,
                           [Define if gcc has the ipa-pure-const bug.])
             fi
         ;;
     esac
 fi
 
 # generate output files
-AC_CONFIG_FILES(Makefile.pre Modules/Setup.config Misc/python.pc)
-AC_CONFIG_FILES([Modules/ld_so_aix], [chmod +x Modules/ld_so_aix])
-AC_OUTPUT
-
-echo "creating Modules/Setup"
+AC_CONFIG_COMMANDS_PRE([
+AC_MSG_NOTICE([creating Modules/Setup])
 if test ! -f Modules/Setup
 then
         cp $srcdir/Modules/Setup.dist Modules/Setup
 fi
 
-echo "creating Modules/Setup.local"
+AC_MSG_NOTICE([creating Modules/Setup.local])
 if test ! -f Modules/Setup.local
 then
         echo "# Edit this file for local setup changes" >Modules/Setup.local
 fi
-
-echo "creating Makefile"
+])
+
+AC_CONFIG_COMMANDS([Makefile],[
 $SHELL $srcdir/Modules/makesetup -c $srcdir/Modules/config.c.in \
                         -s Modules Modules/Setup.config \
                         Modules/Setup.local Modules/Setup
-mv config.c Modules
+mv config.c Modules])
+
+AC_CONFIG_FILES([setup_info])
+AC_CONFIG_FILES([Makefile.pre Modules/Setup.config Misc/python.pc])
+AC_CONFIG_FILES([Modules/ld_so_aix], [chmod +x Modules/ld_so_aix])
+AC_OUTPUT