A better solution to making the default build optimization -O3
authorSam Lantinga <slouken@libsdl.org>
Sun, 11 Oct 2009 10:38:38 +0000
changeset 3382 294fb5e6f301
parent 3381 c4d6458121db
child 3383 90935231e9b6
A better solution to making the default build optimization -O3 Cygwin32 autoconf complains about c.m4 ... of course. :)
acinclude/c.m4
configure.in
--- a/acinclude/c.m4	Sun Oct 11 10:30:47 2009 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1958 +0,0 @@
-# This file is part of Autoconf.			-*- Autoconf -*-
-# Programming languages support.
-# Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free
-# Software Foundation, Inc.
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2, or (at your option)
-# any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-# 02110-1301, USA.
-#
-# As a special exception, the Free Software Foundation gives unlimited
-# permission to copy, distribute and modify the configure scripts that
-# are the output of Autoconf.  You need not follow the terms of the GNU
-# General Public License when using or distributing such scripts, even
-# though portions of the text of Autoconf appear in them.  The GNU
-# General Public License (GPL) does govern all other use of the material
-# that constitutes the Autoconf program.
-#
-# Certain portions of the Autoconf source text are designed to be copied
-# (in certain cases, depending on the input) into the output of
-# Autoconf.  We call these the "data" portions.  The rest of the Autoconf
-# source text consists of comments plus executable code that decides which
-# of the data portions to output in any given case.  We call these
-# comments and executable code the "non-data" portions.  Autoconf never
-# copies any of the non-data portions into its output.
-#
-# This special exception to the GPL applies to versions of Autoconf
-# released by the Free Software Foundation.  When you make and
-# distribute a modified version of Autoconf, you may extend this special
-# exception to the GPL to apply to your modified version as well, *unless*
-# your modified version has the potential to copy into its output some
-# of the text that was the non-data portion of the version that you started
-# with.  (In other words, unless your change moves or copies text from
-# the non-data portions to the data portions.)  If your modification has
-# such potential, you must delete any notice of this special exception
-# to the GPL from your modified version.
-#
-# Written by David MacKenzie, with help from
-# Akim Demaille, Paul Eggert,
-# Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor,
-# Roland McGrath, Noah Friedman, david d zuhn, and many others.
-
-
-# Table of Contents:
-#
-# 1. Language selection
-#    and routines to produce programs in a given language.
-#      1a. C   1b. C++   1c. Objective C
-#
-# 2. Producing programs in a given language.
-#      2a. C   2b. C++   2c. Objective C
-#
-# 3. Looking for a compiler
-#    And possibly the associated preprocessor.
-#      3a. C   3b. C++   3c. Objective C
-#
-# 4. Compilers' characteristics.
-#      4a. C
-
-
-
-## ----------------------- ##
-## 1. Language selection.  ##
-## ----------------------- ##
-
-# -------------------- #
-# 1a. The C language.  #
-# -------------------- #
-
-
-# AC_LANG(C)
-# ----------
-# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
-m4_define([AC_LANG(C)],
-[ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-])
-
-
-# AC_LANG_C
-# ---------
-AU_DEFUN([AC_LANG_C], [AC_LANG(C)])
-
-
-# _AC_LANG_ABBREV(C)
-# ------------------
-m4_define([_AC_LANG_ABBREV(C)], [c])
-
-
-# _AC_LANG_PREFIX(C)
-# ------------------
-m4_define([_AC_LANG_PREFIX(C)], [C])
-
-
-
-# ---------------------- #
-# 1b. The C++ language.  #
-# ---------------------- #
-
-
-# AC_LANG(C++)
-# ------------
-# CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
-m4_define([AC_LANG(C++)],
-[ac_ext=cpp
-ac_cpp='$CXXCPP $CPPFLAGS'
-ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD'
-ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD'
-ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
-])
-
-
-# AC_LANG_CPLUSPLUS
-# -----------------
-AU_DEFUN([AC_LANG_CPLUSPLUS], [AC_LANG(C++)])
-
-
-# _AC_LANG_ABBREV(C++)
-# --------------------
-m4_define([_AC_LANG_ABBREV(C++)], [cxx])
-
-
-# _AC_LANG_PREFIX(C++)
-# --------------------
-m4_define([_AC_LANG_PREFIX(C++)], [CXX])
-
-
-
-# ------------------------------ #
-# 1c. The Objective C language.  #
-# ------------------------------ #
-
-
-# AC_LANG(Objective C)
-# --------------------
-m4_define([AC_LANG(Objective C)],
-[ac_ext=m
-ac_cpp='$OBJCPP $CPPFLAGS'
-ac_compile='$OBJC -c $OBJCFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD'
-ac_link='$OBJC -o conftest$ac_exeext $OBJCFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD'
-ac_compiler_gnu=$ac_cv_objc_compiler_gnu
-])
-
-
-# AC_LANG_OBJC
-# ------------
-AU_DEFUN([AC_LANG_OBJC], [AC_LANG(Objective C)])
-
-
-# _AC_LANG_ABBREV(Objective C)
-# ----------------------------
-m4_define([_AC_LANG_ABBREV(Objective C)], [objc])
-
-
-# _AC_LANG_PREFIX(Objective C)
-# ----------------------------
-m4_define([_AC_LANG_PREFIX(Objective C)], [OBJC])
-
-
-
-## ----------------------- ##
-## 2. Producing programs.  ##
-## ----------------------- ##
-
-# --------------- #
-# 2a. C sources.  #
-# --------------- #
-
-
-# AC_LANG_SOURCE(C)(BODY)
-# -----------------------
-# We can't use '#line $LINENO "configure"' here, since
-# Sun c89 (Sun WorkShop 6 update 2 C 5.3 Patch 111679-08 2002/05/09)
-# rejects $LINENO greater than 32767, and some configure scripts
-# are longer than 32767 lines.
-m4_define([AC_LANG_SOURCE(C)],
-[/* confdefs.h.  */
-_ACEOF
-cat confdefs.h >>conftest.$ac_ext
-cat >>conftest.$ac_ext <<_ACEOF
-/* end confdefs.h.  */
-$1])
-
-
-# AC_LANG_PROGRAM(C)([PROLOGUE], [BODY])
-# --------------------------------------
-m4_define([AC_LANG_PROGRAM(C)],
-[$1
-m4_ifdef([_AC_LANG_PROGRAM_C_F77_HOOKS], [_AC_LANG_PROGRAM_C_F77_HOOKS])[]dnl
-m4_ifdef([_AC_LANG_PROGRAM_C_FC_HOOKS], [_AC_LANG_PROGRAM_C_FC_HOOKS])[]dnl
-int
-main ()
-{
-dnl Do *not* indent the following line: there may be CPP directives.
-dnl Don't move the `;' right after for the same reason.
-$2
-  ;
-  return 0;
-}])
-
-
-# AC_LANG_CALL(C)(PROLOGUE, FUNCTION)
-# -----------------------------------
-# Avoid conflicting decl of main.
-m4_define([AC_LANG_CALL(C)],
-[AC_LANG_PROGRAM([$1
-m4_if([$2], [main], ,
-[/* Override any GCC internal prototype to avoid an error.
-   Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-#ifdef __cplusplus
-extern "C"
-#endif
-char $2 ();])], [return $2 ();])])
-
-
-# AC_LANG_FUNC_LINK_TRY(C)(FUNCTION)
-# ----------------------------------
-# Don't include <ctype.h> because on OSF/1 3.0 it includes
-# <sys/types.h> which includes <sys/select.h> which contains a
-# prototype for select.  Similarly for bzero.
-#
-# This test used to merely assign f=$1 in main(), but that was
-# optimized away by HP unbundled cc A.05.36 for ia64 under +O3,
-# presumably on the basis that there's no need to do that store if the
-# program is about to exit.  Conversely, the AIX linker optimizes an
-# unused external declaration that initializes f=$1.  So this test
-# program has both an external initialization of f, and a use of f in
-# main that affects the exit status.
-#
-m4_define([AC_LANG_FUNC_LINK_TRY(C)],
-[AC_LANG_PROGRAM(
-[/* Define $1 to an innocuous variant, in case <limits.h> declares $1.
-   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
-#define $1 innocuous_$1
-
-/* System header to define __stub macros and hopefully few prototypes,
-    which can conflict with char $1 (); below.
-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-    <limits.h> exists even on freestanding compilers.  */
-
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-
-#undef $1
-
-/* Override any GCC internal prototype to avoid an error.
-   Use char because int might match the return type of a GCC
-   builtin and then its argument prototype would still apply.  */
-#ifdef __cplusplus
-extern "C"
-#endif
-char $1 ();
-/* The GNU C library defines this for functions which it implements
-    to always fail with ENOSYS.  Some functions are actually named
-    something starting with __ and the normal name is an alias.  */
-#if defined __stub_$1 || defined __stub___$1
-choke me
-#endif
-], [return $1 ();])])
-
-
-# AC_LANG_BOOL_COMPILE_TRY(C)(PROLOGUE, EXPRESSION)
-# -------------------------------------------------
-# Return a program that is valid if EXPRESSION is nonzero.
-# EXPRESSION must be an integer constant expression.
-# Be sure to use this array to avoid `unused' warnings, which are even
-# errors with `-W error'.
-m4_define([AC_LANG_BOOL_COMPILE_TRY(C)],
-[AC_LANG_PROGRAM([$1], [static int test_array @<:@1 - 2 * !($2)@:>@;
-test_array @<:@0@:>@ = 0
-])])
-
-
-# AC_LANG_INT_SAVE(C)(PROLOGUE, EXPRESSION)
-# -----------------------------------------
-# We need `stdio.h' to open a `FILE' and `stdlib.h' for `exit'.
-# But we include them only after the EXPRESSION has been evaluated.
-m4_define([AC_LANG_INT_SAVE(C)],
-[AC_LANG_PROGRAM([$1
-static long int longval () { return $2; }
-static unsigned long int ulongval () { return $2; }
-@%:@include <stdio.h>
-@%:@include <stdlib.h>],
-[
-  FILE *f = fopen ("conftest.val", "w");
-  if (! f)
-    return 1;
-  if (($2) < 0)
-    {
-      long int i = longval ();
-      if (i != ($2))
-	return 1;
-      fprintf (f, "%ld", i);
-    }
-  else
-    {
-      unsigned long int i = ulongval ();
-      if (i != ($2))
-	return 1;
-      fprintf (f, "%lu", i);
-    }
-  /* Do not output a trailing newline, as this causes \r\n confusion
-     on some platforms.  */
-  return ferror (f) || fclose (f) != 0;
-])])
-
-
-
-# ----------------- #
-# 2b. C++ sources.  #
-# ----------------- #
-
-
-# AC_LANG_SOURCE(C++)(BODY)
-# -------------------------
-m4_copy([AC_LANG_SOURCE(C)], [AC_LANG_SOURCE(C++)])
-
-
-# AC_LANG_PROGRAM(C++)([PROLOGUE], [BODY])
-# ----------------------------------------
-m4_copy([AC_LANG_PROGRAM(C)], [AC_LANG_PROGRAM(C++)])
-
-
-# AC_LANG_CALL(C++)(PROLOGUE, FUNCTION)
-# -------------------------------------
-m4_copy([AC_LANG_CALL(C)], [AC_LANG_CALL(C++)])
-
-
-# AC_LANG_FUNC_LINK_TRY(C++)(FUNCTION)
-# ------------------------------------
-m4_copy([AC_LANG_FUNC_LINK_TRY(C)], [AC_LANG_FUNC_LINK_TRY(C++)])
-
-
-# AC_LANG_BOOL_COMPILE_TRY(C++)(PROLOGUE, EXPRESSION)
-# ---------------------------------------------------
-m4_copy([AC_LANG_BOOL_COMPILE_TRY(C)], [AC_LANG_BOOL_COMPILE_TRY(C++)])
-
-
-# AC_LANG_INT_SAVE(C++)(PROLOGUE, EXPRESSION)
-# -------------------------------------------
-m4_copy([AC_LANG_INT_SAVE(C)], [AC_LANG_INT_SAVE(C++)])
-
-
-
-# ------------------------- #
-# 2c. Objective C sources.  #
-# ------------------------- #
-
-
-# AC_LANG_SOURCE(Objective C)(BODY)
-# ---------------------------------
-m4_copy([AC_LANG_SOURCE(C)], [AC_LANG_SOURCE(Objective C)])
-
-
-# AC_LANG_PROGRAM(Objective C)([PROLOGUE], [BODY])
-# ------------------------------------------------
-m4_copy([AC_LANG_PROGRAM(C)], [AC_LANG_PROGRAM(Objective C)])
-
-
-# AC_LANG_CALL(Objective C)(PROLOGUE, FUNCTION)
-# ---------------------------------------------
-m4_copy([AC_LANG_CALL(C)], [AC_LANG_CALL(Objective C)])
-
-
-# AC_LANG_FUNC_LINK_TRY(Objective C)(FUNCTION)
-# --------------------------------------------
-m4_copy([AC_LANG_FUNC_LINK_TRY(C)], [AC_LANG_FUNC_LINK_TRY(Objective C)])
-
-
-# AC_LANG_BOOL_COMPILE_TRY(Objective C)(PROLOGUE, EXPRESSION)
-# -----------------------------------------------------------
-m4_copy([AC_LANG_BOOL_COMPILE_TRY(C)], [AC_LANG_BOOL_COMPILE_TRY(Objective C)])
-
-
-# AC_LANG_INT_SAVE(Objective C)(PROLOGUE, EXPRESSION)
-# ---------------------------------------------------
-m4_copy([AC_LANG_INT_SAVE(C)], [AC_LANG_INT_SAVE(Objective C)])
-
-
-
-## -------------------------------------------- ##
-## 3. Looking for Compilers and Preprocessors.  ##
-## -------------------------------------------- ##
-
-# -------------------- #
-# 3a. The C compiler.  #
-# -------------------- #
-
-
-# _AC_ARG_VAR_CPPFLAGS
-# --------------------
-# Document and register CPPFLAGS, which is used by
-# AC_PROG_{CC, CPP, CXX, CXXCPP, OBJC, OBJCPP}.
-AC_DEFUN([_AC_ARG_VAR_CPPFLAGS],
-[AC_ARG_VAR([CPPFLAGS],
-	    [C/C++/Objective C preprocessor flags, e.g. -I<include dir>
-	     if you have headers in a nonstandard directory <include dir>])])
-
-
-# _AC_ARG_VAR_LDFLAGS
-# -------------------
-# Document and register LDFLAGS, which is used by
-# AC_PROG_{CC, CXX, F77, FC, OBJC}.
-AC_DEFUN([_AC_ARG_VAR_LDFLAGS],
-[AC_ARG_VAR([LDFLAGS],
-	    [linker flags, e.g. -L<lib dir> if you have libraries in a
-	     nonstandard directory <lib dir>])])
-
-
-# _AC_ARG_VAR_LIBS
-# ----------------
-# Document and register LIBS, which is used by
-# AC_PROG_{CC, CXX, F77, FC, OBJS}.
-AC_DEFUN([_AC_ARG_VAR_LIBS],
-[AC_ARG_VAR([LIBS],
-	    [libraries to pass to the linker, e.g. -l<library>])])
-
-
-# AC_LANG_PREPROC(C)
-# -------------------
-# Find the C preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
-AC_DEFUN([AC_LANG_PREPROC(C)],
-[AC_REQUIRE([AC_PROG_CPP])])
-
-
-# _AC_PROG_PREPROC_WORKS_IFELSE(IF-WORKS, IF-NOT)
-# -----------------------------------------------
-# Check if $ac_cpp is a working preprocessor that can flag absent
-# includes either by the exit status or by warnings.
-# This macro is for all languages, not only C.
-AC_DEFUN([_AC_PROG_PREPROC_WORKS_IFELSE],
-[ac_preproc_ok=false
-for ac_[]_AC_LANG_ABBREV[]_preproc_warn_flag in '' yes
-do
-  # Use a header file that comes with gcc, so configuring glibc
-  # with a fresh cross-compiler works.
-  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-  # <limits.h> exists even on freestanding compilers.
-  # On the NeXT, cc -E runs the code through the compiler's parser,
-  # not just through cpp. "Syntax error" is here to catch this case.
-  _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@ifdef __STDC__
-@%:@ include <limits.h>
-@%:@else
-@%:@ include <assert.h>
-@%:@endif
-		     Syntax error]])],
-		     [],
-		     [# Broken: fails on valid input.
-continue])
-
-  # OK, works on sane cases.  Now check whether nonexistent headers
-  # can be detected and how.
-  _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@include <ac_nonexistent.h>]])],
-		     [# Broken: success on invalid input.
-continue],
-		     [# Passes both tests.
-ac_preproc_ok=:
-break])
-
-done
-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-rm -f conftest.err conftest.$ac_ext
-AS_IF([$ac_preproc_ok], [$1], [$2])])# _AC_PROG_PREPROC_WORKS_IFELSE
-
-
-# AC_PROG_CPP
-# -----------
-# Find a working C preprocessor.
-# We shouldn't have to require AC_PROG_CC, but this is due to the concurrency
-# between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CC.
-AN_MAKEVAR([CPP], [AC_PROG_CPP])
-AN_PROGRAM([cpp], [AC_PROG_CPP])
-AC_DEFUN([AC_PROG_CPP],
-[AC_REQUIRE([AC_PROG_CC])dnl
-AC_ARG_VAR([CPP],      [C preprocessor])dnl
-_AC_ARG_VAR_CPPFLAGS()dnl
-AC_LANG_PUSH(C)dnl
-AC_MSG_CHECKING([how to run the C preprocessor])
-# On Suns, sometimes $CPP names a directory.
-if test -n "$CPP" && test -d "$CPP"; then
-  CPP=
-fi
-if test -z "$CPP"; then
-  AC_CACHE_VAL([ac_cv_prog_CPP],
-  [dnl
-    # Double quotes because CPP needs to be expanded
-    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
-    do
-      _AC_PROG_PREPROC_WORKS_IFELSE([break])
-    done
-    ac_cv_prog_CPP=$CPP
-  ])dnl
-  CPP=$ac_cv_prog_CPP
-else
-  ac_cv_prog_CPP=$CPP
-fi
-AC_MSG_RESULT([$CPP])
-_AC_PROG_PREPROC_WORKS_IFELSE([],
-		[AC_MSG_FAILURE([C preprocessor "$CPP" fails sanity check])])
-AC_SUBST(CPP)dnl
-AC_LANG_POP(C)dnl
-])# AC_PROG_CPP
-
-# AC_PROG_CPP_WERROR
-# ------------------
-# Treat warnings from the preprocessor as errors.
-AC_DEFUN([AC_PROG_CPP_WERROR],
-[AC_REQUIRE([AC_PROG_CPP])dnl
-ac_c_preproc_warn_flag=yes])# AC_PROG_CPP_WERROR
-
-# AC_LANG_COMPILER(C)
-# -------------------
-# Find the C compiler.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
-AC_DEFUN([AC_LANG_COMPILER(C)],
-[AC_REQUIRE([AC_PROG_CC])])
-
-
-# ac_cv_prog_gcc
-# --------------
-# We used to name the cache variable this way.
-AU_DEFUN([ac_cv_prog_gcc],
-[ac_cv_c_compiler_gnu])
-
-
-# AC_PROG_CC([COMPILER ...])
-# --------------------------
-# COMPILER ... is a space separated list of C compilers to search for.
-# This just gives the user an opportunity to specify an alternative
-# search list for the C compiler.
-AN_MAKEVAR([CC],  [AC_PROG_CC])
-AN_PROGRAM([cc],  [AC_PROG_CC])
-AN_PROGRAM([gcc], [AC_PROG_CC])
-AC_DEFUN([AC_PROG_CC],
-[AC_LANG_PUSH(C)dnl
-AC_ARG_VAR([CC],     [C compiler command])dnl
-AC_ARG_VAR([CFLAGS], [C compiler flags])dnl
-_AC_ARG_VAR_LDFLAGS()dnl
-_AC_ARG_VAR_LIBS()dnl
-_AC_ARG_VAR_CPPFLAGS()dnl
-m4_ifval([$1],
-      [AC_CHECK_TOOLS(CC, [$1])],
-[AC_CHECK_TOOL(CC, gcc)
-if test -z "$CC"; then
-  dnl Here we want:
-  dnl	AC_CHECK_TOOL(CC, cc)
-  dnl but without the check for a tool without the prefix.
-  dnl Until the check is removed from there, copy the code:
-  if test -n "$ac_tool_prefix"; then
-    AC_CHECK_PROG(CC, [${ac_tool_prefix}cc], [${ac_tool_prefix}cc])
-  fi
-fi
-if test -z "$CC"; then
-  AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc)
-fi
-if test -z "$CC"; then
-  AC_CHECK_TOOLS(CC, cl.exe)
-fi
-])
-
-test -z "$CC" && AC_MSG_FAILURE([no acceptable C compiler found in \$PATH])
-
-# Provide some information about the compiler.
-_AS_ECHO_LOG([checking for _AC_LANG compiler version])
-set X $ac_compile
-ac_compiler=$[2]
-_AC_DO([$ac_compiler --version >&AS_MESSAGE_LOG_FD])
-_AC_DO([$ac_compiler -v >&AS_MESSAGE_LOG_FD])
-_AC_DO([$ac_compiler -V >&AS_MESSAGE_LOG_FD])
-
-m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
-m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
-_AC_LANG_COMPILER_GNU
-if test $ac_compiler_gnu = yes; then
-  GCC=yes
-else
-  GCC=
-fi
-_AC_PROG_CC_G
-_AC_PROG_CC_C89
-AC_LANG_POP(C)dnl
-])# AC_PROG_CC
-
-
-# _AC_PROG_CC_G
-# -------------
-# Check whether -g works, even if CFLAGS is set, in case the package
-# plays around with CFLAGS (such as to build both debugging and normal
-# versions of a library), tasteless as that idea is.
-# Don't consider -g to work if it generates warnings when plain compiles don't.
-m4_define([_AC_PROG_CC_G],
-[ac_test_CFLAGS=${CFLAGS+set}
-ac_save_CFLAGS=$CFLAGS
-AC_CACHE_CHECK(whether $CC accepts -g, ac_cv_prog_cc_g,
-  [ac_save_c_werror_flag=$ac_c_werror_flag
-   ac_c_werror_flag=yes
-   ac_cv_prog_cc_g=no
-   CFLAGS="-g"
-   _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
-     [ac_cv_prog_cc_g=yes],
-     [CFLAGS=""
-      _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
-	[],
-	[ac_c_werror_flag=$ac_save_c_werror_flag
-	 CFLAGS="-g"
-	 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
-	   [ac_cv_prog_cc_g=yes])])])
-   ac_c_werror_flag=$ac_save_c_werror_flag])
-if test "$ac_test_CFLAGS" = set; then
-  CFLAGS=$ac_save_CFLAGS
-elif test $ac_cv_prog_cc_g = yes; then
-  if test "$GCC" = yes; then
-    CFLAGS="-g -O3"
-  else
-    CFLAGS="-g"
-  fi
-else
-  if test "$GCC" = yes; then
-    CFLAGS="-O3"
-  else
-    CFLAGS=
-  fi
-fi[]dnl
-])# _AC_PROG_CC_G
-
-
-# AC_PROG_GCC_TRADITIONAL
-# -----------------------
-AC_DEFUN([AC_PROG_GCC_TRADITIONAL],
-[AC_REQUIRE([AC_PROG_CC])dnl
-if test $ac_cv_c_compiler_gnu = yes; then
-    AC_CACHE_CHECK(whether $CC needs -traditional,
-      ac_cv_prog_gcc_traditional,
-[  ac_pattern="Autoconf.*'x'"
-  AC_EGREP_CPP($ac_pattern, [#include <sgtty.h>
-Autoconf TIOCGETP],
-  ac_cv_prog_gcc_traditional=yes, ac_cv_prog_gcc_traditional=no)
-
-  if test $ac_cv_prog_gcc_traditional = no; then
-    AC_EGREP_CPP($ac_pattern, [#include <termio.h>
-Autoconf TCGETA],
-    ac_cv_prog_gcc_traditional=yes)
-  fi])
-  if test $ac_cv_prog_gcc_traditional = yes; then
-    CC="$CC -traditional"
-  fi
-fi
-])# AC_PROG_GCC_TRADITIONAL
-
-
-# AC_PROG_CC_C_O
-# --------------
-AC_DEFUN([AC_PROG_CC_C_O],
-[AC_REQUIRE([AC_PROG_CC])dnl
-if test "x$CC" != xcc; then
-  AC_MSG_CHECKING([whether $CC and cc understand -c and -o together])
-else
-  AC_MSG_CHECKING([whether cc understands -c and -o together])
-fi
-set dummy $CC; ac_cc=`AS_ECHO(["$[2]"]) |
-		      sed 's/[[^a-zA-Z0-9_]]/_/g;s/^[[0-9]]/_/'`
-AC_CACHE_VAL(ac_cv_prog_cc_${ac_cc}_c_o,
-[AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
-# Make sure it works both with $CC and with simple cc.
-# We do the test twice because some compilers refuse to overwrite an
-# existing .o file with -o, though they will create one.
-ac_try='$CC -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD'
-rm -f conftest2.*
-if _AC_DO_VAR(ac_try) &&
-   test -f conftest2.$ac_objext && _AC_DO_VAR(ac_try);
-then
-  eval ac_cv_prog_cc_${ac_cc}_c_o=yes
-  if test "x$CC" != xcc; then
-    # Test first that cc exists at all.
-    if _AC_DO_TOKENS(cc -c conftest.$ac_ext >&AS_MESSAGE_LOG_FD); then
-      ac_try='cc -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD'
-      rm -f conftest2.*
-      if _AC_DO_VAR(ac_try) &&
-	 test -f conftest2.$ac_objext && _AC_DO_VAR(ac_try);
-      then
-	# cc works too.
-	:
-      else
-	# cc exists but doesn't like -o.
-	eval ac_cv_prog_cc_${ac_cc}_c_o=no
-      fi
-    fi
-  fi
-else
-  eval ac_cv_prog_cc_${ac_cc}_c_o=no
-fi
-rm -f core conftest*
-])dnl
-if eval test \$ac_cv_prog_cc_${ac_cc}_c_o = yes; then
-  AC_MSG_RESULT([yes])
-else
-  AC_MSG_RESULT([no])
-  AC_DEFINE(NO_MINUS_C_MINUS_O, 1,
-	   [Define to 1 if your C compiler doesn't accept -c and -o together.])
-fi
-])# AC_PROG_CC_C_O
-
-
-
-# ---------------------- #
-# 3b. The C++ compiler.  #
-# ---------------------- #
-
-
-# AC_LANG_PREPROC(C++)
-# ---------------------
-# Find the C++ preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
-AC_DEFUN([AC_LANG_PREPROC(C++)],
-[AC_REQUIRE([AC_PROG_CXXCPP])])
-
-
-# AC_PROG_CXXCPP
-# --------------
-# Find a working C++ preprocessor.
-# We shouldn't have to require AC_PROG_CC, but this is due to the concurrency
-# between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CXX.
-AC_DEFUN([AC_PROG_CXXCPP],
-[AC_REQUIRE([AC_PROG_CXX])dnl
-AC_ARG_VAR([CXXCPP],   [C++ preprocessor])dnl
-_AC_ARG_VAR_CPPFLAGS()dnl
-AC_LANG_PUSH(C++)dnl
-AC_MSG_CHECKING([how to run the C++ preprocessor])
-if test -z "$CXXCPP"; then
-  AC_CACHE_VAL(ac_cv_prog_CXXCPP,
-  [dnl
-    # Double quotes because CXXCPP needs to be expanded
-    for CXXCPP in "$CXX -E" "/lib/cpp"
-    do
-      _AC_PROG_PREPROC_WORKS_IFELSE([break])
-    done
-    ac_cv_prog_CXXCPP=$CXXCPP
-  ])dnl
-  CXXCPP=$ac_cv_prog_CXXCPP
-else
-  ac_cv_prog_CXXCPP=$CXXCPP
-fi
-AC_MSG_RESULT([$CXXCPP])
-_AC_PROG_PREPROC_WORKS_IFELSE([],
-	  [AC_MSG_FAILURE([C++ preprocessor "$CXXCPP" fails sanity check])])
-AC_SUBST(CXXCPP)dnl
-AC_LANG_POP(C++)dnl
-])# AC_PROG_CXXCPP
-
-
-# AC_LANG_COMPILER(C++)
-# ---------------------
-# Find the C++ compiler.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
-AC_DEFUN([AC_LANG_COMPILER(C++)],
-[AC_REQUIRE([AC_PROG_CXX])])
-
-
-# ac_cv_prog_gxx
-# --------------
-# We used to name the cache variable this way.
-AU_DEFUN([ac_cv_prog_gxx],
-[ac_cv_cxx_compiler_gnu])
-
-
-# AC_PROG_CXX([LIST-OF-COMPILERS])
-# --------------------------------
-# LIST-OF-COMPILERS is a space separated list of C++ compilers to search
-# for (if not specified, a default list is used).  This just gives the
-# user an opportunity to specify an alternative search list for the C++
-# compiler.
-# aCC	HP-UX C++ compiler much better than `CC', so test before.
-# FCC   Fujitsu C++ compiler
-# KCC	KAI C++ compiler
-# RCC	Rational C++
-# xlC_r	AIX C Set++ (with support for reentrant code)
-# xlC	AIX C Set++
-AN_MAKEVAR([CXX],  [AC_PROG_CXX])
-AN_PROGRAM([CC],   [AC_PROG_CXX])
-AN_PROGRAM([c++],  [AC_PROG_CXX])
-AN_PROGRAM([g++],  [AC_PROG_CXX])
-AC_DEFUN([AC_PROG_CXX],
-[AC_LANG_PUSH(C++)dnl
-AC_ARG_VAR([CXX],      [C++ compiler command])dnl
-AC_ARG_VAR([CXXFLAGS], [C++ compiler flags])dnl
-_AC_ARG_VAR_LDFLAGS()dnl
-_AC_ARG_VAR_LIBS()dnl
-_AC_ARG_VAR_CPPFLAGS()dnl
-_AC_ARG_VAR_PRECIOUS([CCC])dnl
-if test -z "$CXX"; then
-  if test -n "$CCC"; then
-    CXX=$CCC
-  else
-    AC_CHECK_TOOLS(CXX,
-		   [m4_default([$1],
-			       [g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC])],
-		   g++)
-  fi
-fi
-# Provide some information about the compiler.
-_AS_ECHO_LOG([checking for _AC_LANG compiler version])
-set X $ac_compile
-ac_compiler=$[2]
-_AC_DO([$ac_compiler --version >&AS_MESSAGE_LOG_FD])
-_AC_DO([$ac_compiler -v >&AS_MESSAGE_LOG_FD])
-_AC_DO([$ac_compiler -V >&AS_MESSAGE_LOG_FD])
-
-m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
-m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
-_AC_LANG_COMPILER_GNU
-if test $ac_compiler_gnu = yes; then
-  GXX=yes
-else
-  GXX=
-fi
-_AC_PROG_CXX_G
-AC_LANG_POP(C++)dnl
-])# AC_PROG_CXX
-
-
-# _AC_PROG_CXX_G
-# --------------
-# Check whether -g works, even if CXXFLAGS is set, in case the package
-# plays around with CXXFLAGS (such as to build both debugging and
-# normal versions of a library), tasteless as that idea is.
-# Don't consider -g to work if it generates warnings when plain compiles don't.
-m4_define([_AC_PROG_CXX_G],
-[ac_test_CXXFLAGS=${CXXFLAGS+set}
-ac_save_CXXFLAGS=$CXXFLAGS
-AC_CACHE_CHECK(whether $CXX accepts -g, ac_cv_prog_cxx_g,
-  [ac_save_cxx_werror_flag=$ac_cxx_werror_flag
-   ac_cxx_werror_flag=yes
-   ac_cv_prog_cxx_g=no
-   CXXFLAGS="-g"
-   _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
-     [ac_cv_prog_cxx_g=yes],
-     [CXXFLAGS=""
-      _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
-	[],
-	[ac_cxx_werror_flag=$ac_save_cxx_werror_flag
-	 CXXFLAGS="-g"
-	 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
-	   [ac_cv_prog_cxx_g=yes])])])
-   ac_cxx_werror_flag=$ac_save_cxx_werror_flag])
-if test "$ac_test_CXXFLAGS" = set; then
-  CXXFLAGS=$ac_save_CXXFLAGS
-elif test $ac_cv_prog_cxx_g = yes; then
-  if test "$GXX" = yes; then
-    CXXFLAGS="-g -O3"
-  else
-    CXXFLAGS="-g"
-  fi
-else
-  if test "$GXX" = yes; then
-    CXXFLAGS="-O3"
-  else
-    CXXFLAGS=
-  fi
-fi[]dnl
-])# _AC_PROG_CXX_G
-
-
-# AC_PROG_CXX_C_O
-# ---------------
-# Test if the C++ compiler accepts the options `-c' and `-o'
-# simultaneously, and define `CXX_NO_MINUS_C_MINUS_O' if it does not.
-AC_DEFUN([AC_PROG_CXX_C_O],
-[AC_REQUIRE([AC_PROG_CXX])dnl
-AC_LANG_PUSH([C++])dnl
-AC_CACHE_CHECK([whether $CXX understands -c and -o together],
-               [ac_cv_prog_cxx_c_o],
-[AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
-# We test twice because some compilers refuse to overwrite an existing
-# `.o' file with `-o', although they will create one.
-ac_try='$CXX $CXXFLAGS -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD'
-rm -f conftest2.*
-if _AC_DO_VAR(ac_try) &&
-     test -f conftest2.$ac_objext &&
-     _AC_DO_VAR(ac_try); then
-  ac_cv_prog_cxx_c_o=yes
-else
-  ac_cv_prog_cxx_c_o=no
-fi
-rm -f conftest*])
-if test $ac_cv_prog_cxx_c_o = no; then
-  AC_DEFINE(CXX_NO_MINUS_C_MINUS_O, 1,
-            [Define to 1 if your C++ compiler doesn't accept
-             -c and -o together.])
-fi
-AC_LANG_POP([C++])dnl
-])# AC_PROG_CXX_C_O
-
-
-
-# ------------------------------ #
-# 3c. The Objective C compiler.  #
-# ------------------------------ #
-
-
-# AC_LANG_PREPROC(Objective C)
-# ----------------------------
-# Find the Objective C preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
-AC_DEFUN([AC_LANG_PREPROC(Objective C)],
-[AC_REQUIRE([AC_PROG_OBJCPP])])
-
-
-# AC_PROG_OBJCPP
-# --------------
-# Find a working Objective C preprocessor.
-AC_DEFUN([AC_PROG_OBJCPP],
-[AC_REQUIRE([AC_PROG_OBJC])dnl
-AC_ARG_VAR([OBJCPP],   [Objective C preprocessor])dnl
-_AC_ARG_VAR_CPPFLAGS()dnl
-AC_LANG_PUSH(Objective C)dnl
-AC_MSG_CHECKING([how to run the Objective C preprocessor])
-if test -z "$OBJCPP"; then
-  AC_CACHE_VAL(ac_cv_prog_OBJCPP,
-  [dnl
-    # Double quotes because OBJCPP needs to be expanded
-    for OBJCPP in "$OBJC -E" "/lib/cpp"
-    do
-      _AC_PROG_PREPROC_WORKS_IFELSE([break])
-    done
-    ac_cv_prog_OBJCPP=$OBJCPP
-  ])dnl
-  OBJCPP=$ac_cv_prog_OBJCPP
-else
-  ac_cv_prog_OBJCPP=$OBJCPP
-fi
-AC_MSG_RESULT([$OBJCPP])
-_AC_PROG_PREPROC_WORKS_IFELSE([],
-	  [AC_MSG_FAILURE([Objective C preprocessor "$OBJCPP" fails sanity check])])
-AC_SUBST(OBJCPP)dnl
-AC_LANG_POP(Objective C)dnl
-])# AC_PROG_OBJCPP
-
-
-# AC_LANG_COMPILER(Objective C)
-# -----------------------------
-# Find the Objective C compiler.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
-AC_DEFUN([AC_LANG_COMPILER(Objective C)],
-[AC_REQUIRE([AC_PROG_OBJC])])
-
-
-
-# AC_PROG_OBJC([LIST-OF-COMPILERS])
-# ---------------------------------
-# LIST-OF-COMPILERS is a space separated list of Objective C compilers to
-# search for (if not specified, a default list is used).  This just gives
-# the user an opportunity to specify an alternative search list for the
-# Objective C compiler.
-# objcc StepStone Objective-C compiler (also "standard" name for OBJC)
-# objc  David Stes' POC.  If you installed this, you likely want it.
-# cc    Native C compiler (for instance, Apple).
-# CC    You never know.
-AN_MAKEVAR([OBJC],  [AC_PROG_OBJC])
-AN_PROGRAM([objcc],  [AC_PROG_OBJC])
-AN_PROGRAM([objc],  [AC_PROG_OBJC])
-AC_DEFUN([AC_PROG_OBJC],
-[AC_LANG_PUSH(Objective C)dnl
-AC_ARG_VAR([OBJC],      [Objective C compiler command])dnl
-AC_ARG_VAR([OBJCFLAGS], [Objective C compiler flags])dnl
-_AC_ARG_VAR_LDFLAGS()dnl
-_AC_ARG_VAR_LIBS()dnl
-_AC_ARG_VAR_CPPFLAGS()dnl
-_AC_ARG_VAR_PRECIOUS([OBJC])dnl
-AC_CHECK_TOOLS(OBJC,
-	       [m4_default([$1], [gcc objcc objc cc CC])],
-	       gcc)
-# Provide some information about the compiler.
-_AS_ECHO_LOG([checking for _AC_LANG compiler version])
-set X $ac_compile
-ac_compiler=$[2]
-_AC_DO([$ac_compiler --version >&AS_MESSAGE_LOG_FD])
-_AC_DO([$ac_compiler -v >&AS_MESSAGE_LOG_FD])
-_AC_DO([$ac_compiler -V >&AS_MESSAGE_LOG_FD])
-
-m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
-m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
-_AC_LANG_COMPILER_GNU
-if test $ac_compiler_gnu = yes; then
-  GOBJC=yes
-else
-  GOBJC=
-fi
-_AC_PROG_OBJC_G
-AC_LANG_POP(Objective C)dnl
-])# AC_PROG_OBJC
-
-
-# _AC_PROG_OBJC_G
-# ---------------
-# Check whether -g works, even if OBJCFLAGS is set, in case the package
-# plays around with OBJCFLAGS (such as to build both debugging and
-# normal versions of a library), tasteless as that idea is.
-# Don't consider -g to work if it generates warnings when plain compiles don't.
-m4_define([_AC_PROG_OBJC_G],
-[ac_test_OBJCFLAGS=${OBJCFLAGS+set}
-ac_save_OBJCFLAGS=$OBJCFLAGS
-AC_CACHE_CHECK(whether $OBJC accepts -g, ac_cv_prog_objc_g,
-  [ac_save_objc_werror_flag=$ac_objc_werror_flag
-   ac_objc_werror_flag=yes
-   ac_cv_prog_objc_g=no
-   OBJCFLAGS="-g"
-   _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
-     [ac_cv_prog_objc_g=yes],
-     [OBJCFLAGS=""
-      _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
-	[],
-	[ac_objc_werror_flag=$ac_save_objc_werror_flag
-	 OBJCFLAGS="-g"
-	 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
-	   [ac_cv_prog_objc_g=yes])])])
-   ac_objc_werror_flag=$ac_save_objc_werror_flag])
-if test "$ac_test_OBJCFLAGS" = set; then
-  OBJCFLAGS=$ac_save_OBJCFLAGS
-elif test $ac_cv_prog_objc_g = yes; then
-  if test "$GOBJC" = yes; then
-    OBJCFLAGS="-g -O3"
-  else
-    OBJCFLAGS="-g"
-  fi
-else
-  if test "$GOBJC" = yes; then
-    OBJCFLAGS="-O3"
-  else
-    OBJCFLAGS=
-  fi
-fi[]dnl
-])# _AC_PROG_OBJC_G
-
-
-
-## ------------------------------- ##
-## 4. Compilers' characteristics.  ##
-## ------------------------------- ##
-
-# -------------------------------- #
-# 4a. C compiler characteristics.  #
-# -------------------------------- #
-
-
-# _AC_PROG_CC_C89 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
-# ----------------------------------------------------------------
-# If the C compiler is not in ANSI C89 (ISO C90) mode by default, try
-# to add an option to output variable CC to make it so.  This macro
-# tries various options that select ANSI C89 on some system or
-# another.  It considers the compiler to be in ANSI C89 mode if it
-# handles function prototypes correctly.
-AC_DEFUN([_AC_PROG_CC_C89],
-[_AC_C_STD_TRY([c89],
-[[#include <stdarg.h>
-#include <stdio.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
-struct buf { int x; };
-FILE * (*rcsopen) (struct buf *, struct stat *, int);
-static char *e (p, i)
-     char **p;
-     int i;
-{
-  return p[i];
-}
-static char *f (char * (*g) (char **, int), char **p, ...)
-{
-  char *s;
-  va_list v;
-  va_start (v,p);
-  s = g (p, va_arg (v,int));
-  va_end (v);
-  return s;
-}
-
-/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
-   function prototypes and stuff, but not '\xHH' hex character constants.
-   These don't provoke an error unfortunately, instead are silently treated
-   as 'x'.  The following induces an error, until -std is added to get
-   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
-   array size at least.  It's necessary to write '\x00'==0 to get something
-   that's true only with -std.  */
-int osf4_cc_array ['\x00' == 0 ? 1 : -1];
-
-/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
-   inside strings and character constants.  */
-#define FOO(x) 'x'
-int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
-
-int test (int i, double x);
-struct s1 {int (*f) (int a);};
-struct s2 {int (*f) (double a);};
-int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
-int argc;
-char **argv;]],
-[[return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];]],
-dnl Don't try gcc -ansi; that turns off useful extensions and
-dnl breaks some systems' header files.
-dnl AIX circa 2003	-qlanglvl=extc89
-dnl old AIX		-qlanglvl=ansi
-dnl Ultrix, OSF/1, Tru64	-std
-dnl HP-UX 10.20 and later	-Ae
-dnl HP-UX older versions	-Aa -D_HPUX_SOURCE
-dnl SVR4			-Xc -D__EXTENSIONS__
-[-qlanglvl=extc89 -qlanglvl=ansi -std \
-	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"], [$1], [$2])[]dnl
-])# _AC_PROG_CC_C89
-
-
-# _AC_C_STD_TRY(STANDARD, TEST-PROLOGUE, TEST-BODY, OPTION-LIST,
-#		ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE)
-# --------------------------------------------------------------
-# Check whether the C compiler accepts features of STANDARD (e.g `c89', `c99')
-# by trying to compile a program of TEST-PROLOGUE and TEST-BODY.  If this fails,
-# try again with each compiler option in the space-separated OPTION-LIST; if one
-# helps, append it to CC.  If eventually successful, run ACTION-IF-AVAILABLE,
-# else ACTION-IF-UNAVAILABLE.
-AC_DEFUN([_AC_C_STD_TRY],
-[AC_MSG_CHECKING([for $CC option to accept ISO ]m4_translit($1, [c], [C]))
-AC_CACHE_VAL(ac_cv_prog_cc_$1,
-[ac_cv_prog_cc_$1=no
-ac_save_CC=$CC
-AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])])
-for ac_arg in '' $4
-do
-  CC="$ac_save_CC $ac_arg"
-  _AC_COMPILE_IFELSE([], [ac_cv_prog_cc_$1=$ac_arg])
-  test "x$ac_cv_prog_cc_$1" != "xno" && break
-done
-rm -f conftest.$ac_ext
-CC=$ac_save_CC
-])# AC_CACHE_VAL
-case "x$ac_cv_prog_cc_$1" in
-  x)
-    AC_MSG_RESULT([none needed]) ;;
-  xno)
-    AC_MSG_RESULT([unsupported]) ;;
-  *)
-    CC="$CC $ac_cv_prog_cc_$1"
-    AC_MSG_RESULT([$ac_cv_prog_cc_$1]) ;;
-esac
-AS_IF([test "x$ac_cv_prog_cc_$1" != xno], [$5], [$6])
-])# _AC_C_STD_TRY
-
-
-# _AC_PROG_CC_C99 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
-# ----------------------------------------------------------------
-# If the C compiler is not in ISO C99 mode by default, try to add an
-# option to output variable CC to make it so.  This macro tries
-# various options that select ISO C99 on some system or another.  It
-# considers the compiler to be in ISO C99 mode if it handles _Bool,
-# // comments, flexible array members, inline, long long int, mixed
-# code and declarations, named initialization of structs, restrict,
-# va_copy, varargs macros, variable declarations in for loops and
-# variable length arrays.
-AC_DEFUN([_AC_PROG_CC_C99],
-[_AC_C_STD_TRY([c99],
-[[#include <stdarg.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <wchar.h>
-#include <stdio.h>
-
-// Check varargs macros.  These examples are taken from C99 6.10.3.5.
-#define debug(...) fprintf (stderr, __VA_ARGS__)
-#define showlist(...) puts (#__VA_ARGS__)
-#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
-static void
-test_varargs_macros (void)
-{
-  int x = 1234;
-  int y = 5678;
-  debug ("Flag");
-  debug ("X = %d\n", x);
-  showlist (The first, second, and third items.);
-  report (x>y, "x is %d but y is %d", x, y);
-}
-
-// Check long long types.
-#define BIG64 18446744073709551615ull
-#define BIG32 4294967295ul
-#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
-#if !BIG_OK
-  your preprocessor is broken;
-#endif
-#if BIG_OK
-#else
-  your preprocessor is broken;
-#endif
-static long long int bignum = -9223372036854775807LL;
-static unsigned long long int ubignum = BIG64;
-
-struct incomplete_array
-{
-  int datasize;
-  double data[];
-};
-
-struct named_init {
-  int number;
-  const wchar_t *name;
-  double average;
-};
-
-typedef const char *ccp;
-
-static inline int
-test_restrict (ccp restrict text)
-{
-  // See if C++-style comments work.
-  // Iterate through items via the restricted pointer.
-  // Also check for declarations in for loops.
-  for (unsigned int i = 0; *(text+i) != '\0'; ++i)
-    continue;
-  return 0;
-}
-
-// Check varargs and va_copy.
-static void
-test_varargs (const char *format, ...)
-{
-  va_list args;
-  va_start (args, format);
-  va_list args_copy;
-  va_copy (args_copy, args);
-
-  const char *str;
-  int number;
-  float fnumber;
-
-  while (*format)
-    {
-      switch (*format++)
-	{
-	case 's': // string
-	  str = va_arg (args_copy, const char *);
-	  break;
-	case 'd': // int
-	  number = va_arg (args_copy, int);
-	  break;
-	case 'f': // float
-	  fnumber = va_arg (args_copy, double);
-	  break;
-	default:
-	  break;
-	}
-    }
-  va_end (args_copy);
-  va_end (args);
-}
-]],
-[[
-  // Check bool.
-  _Bool success = false;
-
-  // Check restrict.
-  if (test_restrict ("String literal") == 0)
-    success = true;
-  char *restrict newvar = "Another string";
-
-  // Check varargs.
-  test_varargs ("s, d' f .", "string", 65, 34.234);
-  test_varargs_macros ();
-
-  // Check flexible array members.
-  struct incomplete_array *ia =
-    malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
-  ia->datasize = 10;
-  for (int i = 0; i < ia->datasize; ++i)
-    ia->data[i] = i * 1.234;
-
-  // Check named initializers.
-  struct named_init ni = {
-    .number = 34,
-    .name = L"Test wide string",
-    .average = 543.34343,
-  };
-
-  ni.number = 58;
-
-  int dynamic_array[ni.number];
-  dynamic_array[ni.number - 1] = 543;
-
-  // work around unused variable warnings
-  return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
-	  || dynamic_array[ni.number - 1] != 543);
-]],
-dnl Try
-dnl GCC		-std=gnu99 (unused restrictive modes: -std=c99 -std=iso9899:1999)
-dnl AIX		-qlanglvl=extc99 (unused restrictive mode: -qlanglvl=stdc99)
-dnl HP cc	-AC99
-dnl Intel ICC	-std=c99, -c99 (deprecated)
-dnl IRIX	-c99
-dnl Solaris	-xc99=all (Forte Developer 7 C mishandles -xc99 on Solaris 9,
-dnl		as it incorrectly assumes C99 semantics for library functions)
-dnl Tru64	-c99
-dnl with extended modes being tried first.
-[[-std=gnu99 -std=c99 -c99 -AC99 -xc99=all -qlanglvl=extc99]], [$1], [$2])[]dnl
-])# _AC_PROG_CC_C99
-
-
-# AC_PROG_CC_C89
-# --------------
-AC_DEFUN([AC_PROG_CC_C89],
-[ AC_REQUIRE([AC_PROG_CC])dnl
-  _AC_PROG_CC_C89
-])
-
-
-# AC_PROG_CC_C99
-# --------------
-AC_DEFUN([AC_PROG_CC_C99],
-[ AC_REQUIRE([AC_PROG_CC])dnl
-  _AC_PROG_CC_C99
-])
-
-
-# AC_PROG_CC_STDC
-# ---------------
-AC_DEFUN([AC_PROG_CC_STDC],
-[ AC_REQUIRE([AC_PROG_CC])dnl
-  AS_CASE([$ac_cv_prog_cc_stdc],
-    [no], [ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no],
-	  [_AC_PROG_CC_C99([ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99],
-	     [_AC_PROG_CC_C89([ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89],
-			      [ac_cv_prog_cc_stdc=no])])])dnl
-  AC_MSG_CHECKING([for $CC option to accept ISO Standard C])
-  AC_CACHE_VAL([ac_cv_prog_cc_stdc], [])
-  AS_CASE([$ac_cv_prog_cc_stdc],
-    [no], [AC_MSG_RESULT([unsupported])],
-    [''], [AC_MSG_RESULT([none needed])],
-          [AC_MSG_RESULT([$ac_cv_prog_cc_stdc])])
-])
-
-
-# AC_C_BACKSLASH_A
-# ----------------
-AC_DEFUN([AC_C_BACKSLASH_A],
-[
-  AC_CACHE_CHECK([whether backslash-a works in strings], ac_cv_c_backslash_a,
-   [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
-     [[
-#if '\a' == 'a'
-      syntax error;
-#endif
-      char buf['\a' == 'a' ? -1 : 1];
-      buf[0] = '\a';
-      return buf[0] != "\a"[0];
-     ]])],
-     [ac_cv_c_backslash_a=yes],
-     [ac_cv_c_backslash_a=no])])
-  if test $ac_cv_c_backslash_a = yes; then
-    AC_DEFINE(HAVE_C_BACKSLASH_A, 1,
-      [Define if backslash-a works in C strings.])
-  fi
-])
-
-
-# AC_C_CROSS
-# ----------
-# Has been merged into AC_PROG_CC.
-AU_DEFUN([AC_C_CROSS], [])
-
-
-# AC_C_CHAR_UNSIGNED
-# ------------------
-AC_DEFUN([AC_C_CHAR_UNSIGNED],
-[AH_VERBATIM([__CHAR_UNSIGNED__],
-[/* Define to 1 if type `char' is unsigned and you are not using gcc.  */
-#ifndef __CHAR_UNSIGNED__
-# undef __CHAR_UNSIGNED__
-#endif])dnl
-AC_CACHE_CHECK(whether char is unsigned, ac_cv_c_char_unsigned,
-[AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([AC_INCLUDES_DEFAULT([])],
-					     [((char) -1) < 0])],
-		   ac_cv_c_char_unsigned=no, ac_cv_c_char_unsigned=yes)])
-if test $ac_cv_c_char_unsigned = yes && test "$GCC" != yes; then
-  AC_DEFINE(__CHAR_UNSIGNED__)
-fi
-])# AC_C_CHAR_UNSIGNED
-
-
-# AC_C_BIGENDIAN ([ACTION-IF-TRUE], [ACTION-IF-FALSE], [ACTION-IF-UNKNOWN],
-#                 [ACTION-IF-UNIVERSAL])
-# -------------------------------------------------------------------------
-AC_DEFUN([AC_C_BIGENDIAN],
-[AH_VERBATIM([WORDS_BIGENDIAN],
-[/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
-   significant byte first (like Motorola and SPARC, unlike Intel). */
-#if defined AC_APPLE_UNIVERSAL_BUILD
-# if defined __BIG_ENDIAN__
-#  define WORDS_BIGENDIAN 1
-# endif
-#else
-# ifndef WORDS_BIGENDIAN
-#  undef WORDS_BIGENDIAN
-# endif
-#endif])dnl
- AC_CACHE_CHECK([whether byte ordering is bigendian], [ac_cv_c_bigendian],
-   [ac_cv_c_bigendian=unknown
-    # See if we're dealing with a universal compiler.
-    AC_COMPILE_IFELSE(
-	 [AC_LANG_SOURCE(
-	    [[#ifndef __APPLE_CC__
-	       not a universal capable compiler
-	     #endif
-	     typedef int dummy;
-	    ]])],
-	 [
-	# Check for potential -arch flags.  It is not universal unless
-	# there are some -arch flags.  Note that *ppc* also matches
-	# ppc64.  This check is also rather less than ideal.
-	case "${CC} ${CFLAGS} ${CPPFLAGS} ${LDFLAGS}" in  #(
-	  *-arch*ppc*|*-arch*i386*|*-arch*x86_64*) ac_cv_c_bigendian=universal;;
-	esac])
-    if test $ac_cv_c_bigendian = unknown; then
-      # See if sys/param.h defines the BYTE_ORDER macro.
-      AC_COMPILE_IFELSE(
-	[AC_LANG_PROGRAM(
-	   [[#include <sys/types.h>
-	     #include <sys/param.h>
-	   ]],
-	   [[#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \
-		     && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
-		     && LITTLE_ENDIAN)
-	      bogus endian macros
-	     #endif
-	   ]])],
-	[# It does; now see whether it defined to BIG_ENDIAN or not.
-	 AC_COMPILE_IFELSE(
-	   [AC_LANG_PROGRAM(
-	      [[#include <sys/types.h>
-		#include <sys/param.h>
-	      ]],
-	      [[#if BYTE_ORDER != BIG_ENDIAN
-		 not big endian
-		#endif
-	      ]])],
-	   [ac_cv_c_bigendian=yes],
-	   [ac_cv_c_bigendian=no])])
-    fi
-    if test $ac_cv_c_bigendian = unknown; then
-      # See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
-      AC_COMPILE_IFELSE(
-	[AC_LANG_PROGRAM(
-	   [[#include <limits.h>
-	   ]],
-	   [[#if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
-	      bogus endian macros
-	     #endif
-	   ]])],
-	[# It does; now see whether it defined to _BIG_ENDIAN or not.
-	 AC_COMPILE_IFELSE(
-	   [AC_LANG_PROGRAM(
-	      [[#include <limits.h>
-	      ]],
-	      [[#ifndef _BIG_ENDIAN
-		 not big endian
-		#endif
-	      ]])],
-	   [ac_cv_c_bigendian=yes],
-	   [ac_cv_c_bigendian=no])])
-    fi
-    if test $ac_cv_c_bigendian = unknown; then
-      # Compile a test program.
-      AC_RUN_IFELSE(
-	[AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT],
-	   [[
-	     /* Are we little or big endian?  From Harbison&Steele.  */
-	     union
-	     {
-	       long int l;
-	       char c[sizeof (long int)];
-	     } u;
-	     u.l = 1;
-	     return u.c[sizeof (long int) - 1] == 1;
-	   ]])],
-	[ac_cv_c_bigendian=no],
-	[ac_cv_c_bigendian=yes],
-	[# Try to guess by grepping values from an object file.
-	 AC_COMPILE_IFELSE(
-	   [AC_LANG_PROGRAM(
-	      [[short int ascii_mm[] =
-		  { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
-		short int ascii_ii[] =
-		  { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
-		int use_ascii (int i) {
-		  return ascii_mm[i] + ascii_ii[i];
-		}
-		short int ebcdic_ii[] =
-		  { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
-		short int ebcdic_mm[] =
-		  { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
-		int use_ebcdic (int i) {
-		  return ebcdic_mm[i] + ebcdic_ii[i];
-		}
-		extern int foo;
-	      ]],
-	      [[return use_ascii (foo) == use_ebcdic (foo);]])],
-	   [if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
-	      ac_cv_c_bigendian=yes
-	    fi
-	    if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
-	      if test "$ac_cv_c_bigendian" = unknown; then
-		ac_cv_c_bigendian=no
-	      else
-		# finding both strings is unlikely to happen, but who knows?
-		ac_cv_c_bigendian=unknown
-	      fi
-	    fi])])
-    fi])
- case $ac_cv_c_bigendian in #(
-   yes)
-     m4_default([$1],
-       [AC_DEFINE([WORDS_BIGENDIAN], 1)]);; #(
-   no)
-     $2 ;; #(
-   universal)
-dnl Note that AC_APPLE_UNIVERSAL_BUILD sorts less than WORDS_BIGENDIAN;
-dnl this is a necessity for proper config header operation.  Warn if
-dnl the user did not specify a config header but is relying on the
-dnl default behavior for universal builds.
-     m4_default([$4],
-       [AC_CONFIG_COMMANDS_PRE([m4_ifset([AH_HEADER], [],
-         [AC_DIAGNOSE([obsolete],
-           [AC_C_BIGENDIAN should be used with AC_CONFIG_HEADERS])])])dnl
-        AC_DEFINE([AC_APPLE_UNIVERSAL_BUILD],1,
-          [Define if building universal (internal helper macro)])])
-     ;; #(
-   *)
-     m4_default([$3],
-       [AC_MSG_ERROR([unknown endianness
- presetting ac_cv_c_bigendian=no (or yes) will help])]) ;;
- esac
-])# AC_C_BIGENDIAN
-
-
-# AC_C_INLINE
-# -----------
-# Do nothing if the compiler accepts the inline keyword.
-# Otherwise define inline to __inline__ or __inline if one of those work,
-# otherwise define inline to be empty.
-#
-# HP C version B.11.11.04 doesn't allow a typedef as the return value for an
-# inline function, only builtin types.
-#
-AN_IDENTIFIER([inline], [AC_C_INLINE])
-AC_DEFUN([AC_C_INLINE],
-[AC_CACHE_CHECK([for inline], ac_cv_c_inline,
-[ac_cv_c_inline=no
-for ac_kw in inline __inline__ __inline; do
-  AC_COMPILE_IFELSE([AC_LANG_SOURCE(
-[#ifndef __cplusplus
-typedef int foo_t;
-static $ac_kw foo_t static_foo () {return 0; }
-$ac_kw foo_t foo () {return 0; }
-#endif
-])],
-		    [ac_cv_c_inline=$ac_kw])
-  test "$ac_cv_c_inline" != no && break
-done
-])
-AH_VERBATIM([inline],
-[/* Define to `__inline__' or `__inline' if that's what the C compiler
-   calls it, or to nothing if 'inline' is not supported under any name.  */
-#ifndef __cplusplus
-#undef inline
-#endif])
-case $ac_cv_c_inline in
-  inline | yes) ;;
-  *)
-    case $ac_cv_c_inline in
-      no) ac_val=;;
-      *) ac_val=$ac_cv_c_inline;;
-    esac
-    cat >>confdefs.h <<_ACEOF
-#ifndef __cplusplus
-#define inline $ac_val
-#endif
-_ACEOF
-    ;;
-esac
-])# AC_C_INLINE
-
-
-# AC_C_CONST
-# ----------
-AC_DEFUN([AC_C_CONST],
-[AC_CACHE_CHECK([for an ANSI C-conforming const], ac_cv_c_const,
-[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
-[[/* FIXME: Include the comments suggested by Paul. */
-#ifndef __cplusplus
-  /* Ultrix mips cc rejects this.  */
-  typedef int charset[2];
-  const charset cs;
-  /* SunOS 4.1.1 cc rejects this.  */
-  char const *const *pcpcc;
-  char **ppc;
-  /* NEC SVR4.0.2 mips cc rejects this.  */
-  struct point {int x, y;};
-  static struct point const zero = {0,0};
-  /* AIX XL C 1.02.0.0 rejects this.
-     It does not let you subtract one const X* pointer from another in
-     an arm of an if-expression whose if-part is not a constant
-     expression */
-  const char *g = "string";
-  pcpcc = &g + (g ? g-g : 0);
-  /* HPUX 7.0 cc rejects these. */
-  ++pcpcc;
-  ppc = (char**) pcpcc;
-  pcpcc = (char const *const *) ppc;
-  { /* SCO 3.2v4 cc rejects this.  */
-    char *t;
-    char const *s = 0 ? (char *) 0 : (char const *) 0;
-
-    *t++ = 0;
-    if (s) return 0;
-  }
-  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
-    int x[] = {25, 17};
-    const int *foo = &x[0];
-    ++foo;
-  }
-  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
-    typedef const int *iptr;
-    iptr p = 0;
-    ++p;
-  }
-  { /* AIX XL C 1.02.0.0 rejects this saying
-       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
-    struct s { int j; const int *ap[3]; };
-    struct s *b; b->j = 5;
-  }
-  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
-    const int foo = 10;
-    if (!foo) return 0;
-  }
-  return !cs[0] && !zero.x;
-#endif
-]])],
-		   [ac_cv_c_const=yes],
-		   [ac_cv_c_const=no])])
-if test $ac_cv_c_const = no; then
-  AC_DEFINE(const,,
-	    [Define to empty if `const' does not conform to ANSI C.])
-fi
-])# AC_C_CONST
-
-
-# AC_C_RESTRICT
-# -------------
-# based on acx_restrict.m4, from the GNU Autoconf Macro Archive at:
-# http://autoconf-archive.cryp.to/acx_restrict.html
-#
-# Determine whether the C/C++ compiler supports the "restrict" keyword
-# introduced in ANSI C99, or an equivalent.  Define "restrict" to the alternate
-# spelling, if any; these are more likely to work in both C and C++ compilers of
-# the same family, and in the presence of varying compiler options.  If only
-# plain "restrict" works, do nothing.  Here are some variants:
-# - GCC supports both __restrict and __restrict__
-# - older DEC Alpha C compilers support only __restrict
-# - _Restrict is the only spelling accepted by Sun WorkShop 6 update 2 C
-# Otherwise, define "restrict" to be empty.
-AN_IDENTIFIER([restrict], [AC_C_RESTRICT])
-AC_DEFUN([AC_C_RESTRICT],
-[AC_CACHE_CHECK([for C/C++ restrict keyword], ac_cv_c_restrict,
-  [ac_cv_c_restrict=no
-   # The order here caters to the fact that C++ does not require restrict.
-   for ac_kw in __restrict __restrict__ _Restrict restrict; do
-     AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
-      [[typedef int * int_ptr;
-	int foo (int_ptr $ac_kw ip) {
-	return ip[0];
-       }]],
-      [[int s[1];
-	int * $ac_kw t = s;
-	t[0] = 0;
-	return foo(t)]])],
-      [ac_cv_c_restrict=$ac_kw])
-     test "$ac_cv_c_restrict" != no && break
-   done
-  ])
- AH_VERBATIM([restrict],
-[/* Define to the equivalent of the C99 'restrict' keyword, or to
-   nothing if this is not supported.  Do not define if restrict is
-   supported directly.  */
-#undef restrict
-/* Work around a bug in Sun C++: it does not support _Restrict, even
-   though the corresponding Sun C compiler does, which causes
-   "#define restrict _Restrict" in the previous line.  Perhaps some future
-   version of Sun C++ will work with _Restrict; if so, it'll probably
-   define __RESTRICT, just as Sun C does.  */
-#if defined __SUNPRO_CC && !defined __RESTRICT
-# define _Restrict
-#endif])
- case $ac_cv_c_restrict in
-   restrict) ;;
-   no) AC_DEFINE([restrict], []) ;;
-   *)  AC_DEFINE_UNQUOTED([restrict], [$ac_cv_c_restrict]) ;;
- esac
-])# AC_C_RESTRICT
-
-
-# AC_C_VOLATILE
-# -------------
-# Note that, unlike const, #defining volatile to be the empty string can
-# actually turn a correct program into an incorrect one, since removing
-# uses of volatile actually grants the compiler permission to perform
-# optimizations that could break the user's code.  So, do not #define
-# volatile away unless it is really necessary to allow the user's code
-# to compile cleanly.  Benign compiler failures should be tolerated.
-AC_DEFUN([AC_C_VOLATILE],
-[AC_CACHE_CHECK([for working volatile], ac_cv_c_volatile,
-[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
-volatile int x;
-int * volatile y = (int *) 0;
-return !x && !y;])],
-		   [ac_cv_c_volatile=yes],
-		   [ac_cv_c_volatile=no])])
-if test $ac_cv_c_volatile = no; then
-  AC_DEFINE(volatile,,
-	    [Define to empty if the keyword `volatile' does not work.
-	     Warning: valid code using `volatile' can become incorrect
-	     without.  Disable with care.])
-fi
-])# AC_C_VOLATILE
-
-
-# AC_C_STRINGIZE
-# --------------
-# Checks if `#' can be used to glue strings together at the CPP level.
-# Defines HAVE_STRINGIZE if positive.
-AC_DEFUN([AC_C_STRINGIZE],
-[AC_CACHE_CHECK([for preprocessor stringizing operator],
-		[ac_cv_c_stringize],
-[AC_EGREP_CPP([@%:@teststring],
-	      [@%:@define x(y) #y
-
-char *s = x(teststring);],
-	      [ac_cv_c_stringize=no],
-	      [ac_cv_c_stringize=yes])])
-if test $ac_cv_c_stringize = yes; then
-  AC_DEFINE(HAVE_STRINGIZE, 1,
-	    [Define to 1 if cpp supports the ANSI @%:@ stringizing operator.])
-fi
-])# AC_C_STRINGIZE
-
-
-# AC_C_PROTOTYPES
-# ---------------
-# Check if the C compiler supports prototypes, included if it needs
-# options.
-AC_DEFUN([AC_C_PROTOTYPES],
-[AC_REQUIRE([AC_PROG_CC])dnl
-AC_MSG_CHECKING([for function prototypes])
-if test "$ac_cv_prog_cc_c89" != no; then
-  AC_MSG_RESULT([yes])
-  AC_DEFINE(PROTOTYPES, 1,
-	    [Define to 1 if the C compiler supports function prototypes.])
-  AC_DEFINE(__PROTOTYPES, 1,
-	    [Define like PROTOTYPES; this can be used by system headers.])
-else
-  AC_MSG_RESULT([no])
-fi
-])# AC_C_PROTOTYPES
-
-
-# AC_C_FLEXIBLE_ARRAY_MEMBER
-# --------------------------
-# Check whether the C compiler supports flexible array members.
-AC_DEFUN([AC_C_FLEXIBLE_ARRAY_MEMBER],
-[
-  AC_CACHE_CHECK([for flexible array members],
-    ac_cv_c_flexmember,
-    [AC_COMPILE_IFELSE(
-       [AC_LANG_PROGRAM(
-	  [[#include <stdlib.h>
-	    #include <stdio.h>
-	    #include <stddef.h>
-	    struct s { int n; double d[]; };]],
-	  [[int m = getchar ();
-	    struct s *p = malloc (offsetof (struct s, d)
-				  + m * sizeof (double));
-	    p->d[0] = 0.0;
-	    return p->d != (double *) NULL;]])],
-       [ac_cv_c_flexmember=yes],
-       [ac_cv_c_flexmember=no])])
-  if test $ac_cv_c_flexmember = yes; then
-    AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], [],
-      [Define to nothing if C supports flexible array members, and to
-       1 if it does not.  That way, with a declaration like `struct s
-       { int n; double d@<:@FLEXIBLE_ARRAY_MEMBER@:>@; };', the struct hack
-       can be used with pre-C99 compilers.
-       When computing the size of such an object, don't use 'sizeof (struct s)'
-       as it overestimates the size.  Use 'offsetof (struct s, d)' instead.
-       Don't use 'offsetof (struct s, d@<:@0@:>@)', as this doesn't work with
-       MSVC and with C++ compilers.])
-  else
-    AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], 1)
-  fi
-])
-
-
-# AC_C_VARARRAYS
-# --------------
-# Check whether the C compiler supports variable-length arrays.
-AC_DEFUN([AC_C_VARARRAYS],
-[
-  AC_CACHE_CHECK([for variable-length arrays],
-    ac_cv_c_vararrays,
-    [AC_COMPILE_IFELSE(
-       [AC_LANG_PROGRAM([],
-	  [[static int x; char a[++x]; a[sizeof a - 1] = 0; return a[0];]])],
-       [ac_cv_c_vararrays=yes],
-       [ac_cv_c_vararrays=no])])
-  if test $ac_cv_c_vararrays = yes; then
-    AC_DEFINE([HAVE_C_VARARRAYS], 1,
-      [Define to 1 if C supports variable-length arrays.])
-  fi
-])
-
-
-# AC_C_TYPEOF
-# -----------
-# Check if the C compiler supports GCC's typeof syntax.
-# The test case provokes incompatibilities in the Sun C compilers
-# (both Solaris 8 and Solaris 10).
-AC_DEFUN([AC_C_TYPEOF],
-[
-  AC_CACHE_CHECK([for typeof syntax and keyword spelling], ac_cv_c_typeof,
-    [ac_cv_c_typeof=no
-     for ac_kw in typeof __typeof__ no; do
-       test $ac_kw = no && break
-       AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
-	 [[
-	   int value;
-	   typedef struct {
-		   char a [1
-			   + ! (($ac_kw (value))
-				(($ac_kw (value)) 0 < ($ac_kw (value)) -1
-				 ? ($ac_kw (value)) - 1
-				 : ~ (~ ($ac_kw (value)) 0
-				      << sizeof ($ac_kw (value)))))]; }
-	      ac__typeof_type_;
-	   return
-	     (! ((void) ((ac__typeof_type_ *) 0), 0));
-	 ]])],
-	 [ac_cv_c_typeof=$ac_kw])
-       test $ac_cv_c_typeof != no && break
-     done])
-  if test $ac_cv_c_typeof != no; then
-    AC_DEFINE([HAVE_TYPEOF], 1,
-      [Define to 1 if typeof works with your compiler.])
-    if test $ac_cv_c_typeof != typeof; then
-      AC_DEFINE_UNQUOTED([typeof], [$ac_cv_c_typeof],
-	[Define to __typeof__ if your compiler spells it that way.])
-    fi
-  fi
-])
-
-
-# _AC_LANG_OPENMP
-# ---------------
-# Expands to some language dependent source code for testing the presence of
-# OpenMP.
-AC_DEFUN([_AC_LANG_OPENMP],
-[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])
-
-# _AC_LANG_OPENMP(C)
-# ------------------
-m4_define([_AC_LANG_OPENMP(C)],
-[
-#ifndef _OPENMP
- choke me
-#endif
-#include <omp.h>
-int main () { return omp_get_num_threads (); }
-])
-
-# _AC_LANG_OPENMP(C++)
-# --------------------
-m4_copy([_AC_LANG_OPENMP(C)], [_AC_LANG_OPENMP(C++)])
-
-# _AC_LANG_OPENMP(Fortran 77)
-# ---------------------------
-m4_define([_AC_LANG_OPENMP(Fortran 77)],
-[AC_LANG_FUNC_LINK_TRY([omp_get_num_threads])])
-
-# _AC_LANG_OPENMP(Fortran)
-# ---------------------------
-m4_copy([_AC_LANG_OPENMP(Fortran 77)], [_AC_LANG_OPENMP(Fortran)])
-
-# AC_OPENMP
-# ---------
-# Check which options need to be passed to the C compiler to support OpenMP.
-# Set the OPENMP_CFLAGS / OPENMP_CXXFLAGS / OPENMP_FFLAGS variable to these
-# options.
-# The options are necessary at compile time (so the #pragmas are understood)
-# and at link time (so the appropriate library is linked with).
-# This macro takes care to not produce redundant options if $CC $CFLAGS already
-# supports OpenMP. It also is careful to not pass options to compilers that
-# misinterpret them; for example, most compilers accept "-openmp" and create
-# an output file called 'penmp' rather than activating OpenMP support.
-AC_DEFUN([AC_OPENMP],
-[
-  OPENMP_[]_AC_LANG_PREFIX[]FLAGS=
-  AC_ARG_ENABLE([openmp],
-    [AS_HELP_STRING([--disable-openmp], [do not use OpenMP])])
-  if test "$enable_openmp" != no; then
-    AC_CACHE_CHECK([for $CC option to support OpenMP],
-      [ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp],
-      [AC_LINK_IFELSE([_AC_LANG_OPENMP],
-	 [ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp='none needed'],
-	 [ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp='unsupported'
-	  dnl Try these flags:
-	  dnl   GCC >= 4.2           -fopenmp
-	  dnl   SunPRO C             -xopenmp
-	  dnl   Intel C              -openmp
-	  dnl   SGI C, PGI C         -mp
-	  dnl   Tru64 Compaq C       -omp
-	  dnl   IBM C (AIX, Linux)   -qsmp=omp
-	  dnl If in this loop a compiler is passed an option that it doesn't
-	  dnl understand or that it misinterprets, the AC_LINK_IFELSE test
-	  dnl will fail (since we know that it failed without the option),
-	  dnl therefore the loop will continue searching for an option, and
-	  dnl no output file called 'penmp' or 'mp' is created.
-	  for ac_option in -fopenmp -xopenmp -openmp -mp -omp -qsmp=omp; do
-	    ac_save_[]_AC_LANG_PREFIX[]FLAGS=$[]_AC_LANG_PREFIX[]FLAGS
-	    _AC_LANG_PREFIX[]FLAGS="$[]_AC_LANG_PREFIX[]FLAGS $ac_option"
-	    AC_LINK_IFELSE([_AC_LANG_OPENMP],
-	      [ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp=$ac_option])
-	    _AC_LANG_PREFIX[]FLAGS=$ac_save_[]_AC_LANG_PREFIX[]FLAGS
-	    if test "$ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp" != unsupported; then
-	      break
-	    fi
-	  done])])
-    case $ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp in #(
-      "none needed" | unsupported)
-        ;; #(
-      *)
-        OPENMP_[]_AC_LANG_PREFIX[]FLAGS=$ac_cv_prog_[]_AC_LANG_ABBREV[]_openmp ;;
-    esac
-  fi
-  AC_SUBST([OPENMP_]_AC_LANG_PREFIX[FLAGS])
-])
--- a/configure.in	Sun Oct 11 10:30:47 2009 +0000
+++ b/configure.in	Sun Oct 11 10:38:38 2009 +0000
@@ -4,6 +4,9 @@
 AC_GNU_SOURCE
 AC_CONFIG_AUX_DIRS($srcdir/build-scripts)
 
+dnl Save the CFLAGS to see whether they were passed in or generated
+orig_CFLAGS="$CFLAGS"
+
 dnl Set various version strings - taken gratefully from the GTk sources
 #
 # Making releases:
@@ -87,6 +90,10 @@
         ;;
 esac
 BUILD_CFLAGS="$CFLAGS $CPPFLAGS"
+# The default optimization for SDL 1.3 is -O3 (Bug #31)
+if test x$orig_CFLAGS = x; then
+    BUILD_CFLAGS=`echo $BUILD_CFLAGS | sed 's/-O2/-O3/'`
+fi
 EXTRA_CFLAGS="$INCLUDE $BASE_CFLAGS"
 BUILD_LDFLAGS="$LDFLAGS"
 EXTRA_LDFLAGS="$BASE_LDFLAGS"