dnl AC_PROG_CC_GNU

ifdef([AC_PROG_CC_GNU],,[AC_DEFUN([AC_PROG_CC_GNU],)])

dnl PAC_PROG_CC - reprioritize the C compiler search order

AC_DEFUN([PAC_PROG_CC],[

        dnl Many standard autoconf/automake/libtool macros, such as LT_INIT,

        dnl perform an AC_REQUIRE([AC_PROG_CC]).  If this macro (PAC_PROG_CC)

        dnl comes after LT_INIT (or similar) then the default compiler search

        dnl path will be used instead.  This AC_BEFORE macro ensures that a

        dnl warning will be emitted at autoconf-time (autogen.sh-time) to help

        dnl developers notice this case.

        AC_BEFORE([$0],[AC_PROG_CC])

	PAC_PUSH_FLAG([CFLAGS])

	AC_PROG_CC([icc pgcc xlc xlC pathcc gcc clang cc])

	PAC_POP_FLAG([CFLAGS])

])

dnl

dnl/*D

dnl PAC_C_CHECK_COMPILER_OPTION - Check that a compiler option is accepted

dnl without warning messages

dnl

dnl Synopsis:

dnl PAC_C_CHECK_COMPILER_OPTION(optionname,action-if-ok,action-if-fail)

dnl

dnl Output Effects:

dnl

dnl If no actions are specified, a working value is added to 'COPTIONS'

dnl

dnl Notes:

dnl This is now careful to check that the output is different, since 

dnl some compilers are noisy.

dnl 

dnl We are extra careful to prototype the functions in case compiler options

dnl that complain about poor code are in effect.

dnl

dnl Because this is a long script, we have ensured that you can pass a 

dnl variable containing the option name as the first argument.

dnl

dnl D*/

AC_DEFUN([PAC_C_CHECK_COMPILER_OPTION],[

AC_MSG_CHECKING([whether C compiler accepts option $1])

pac_opt="$1"

AC_LANG_PUSH([C])

CFLAGS_orig="$CFLAGS"

CFLAGS_opt="$pac_opt $CFLAGS"

pac_result="unknown"

AC_LANG_CONFTEST([

	AC_LANG_PROGRAM([[#include <stdio.h>

                          const char hw[] = "Hello, World\n";]],

		[[fputs (hw, stdout);]])

])

CFLAGS="$CFLAGS_orig"

rm -f pac_test1.log

PAC_LINK_IFELSE_LOG([pac_test1.log], [], [

    CFLAGS="$CFLAGS_opt"

    rm -f pac_test2.log

    PAC_LINK_IFELSE_LOG([pac_test2.log], [], [

        PAC_RUNLOG_IFELSE([diff -b pac_test1.log pac_test2.log],

                          [pac_result=yes],[pac_result=no])

    ],[

        pac_result=no

    ])

], [

    pac_result=no

])

AC_MSG_RESULT([$pac_result])

dnl Delete the conftest created by AC_LANG_CONFTEST.

rm -f conftest.$ac_ext

# gcc 4.2.4 on 32-bit does not complain about the -Wno-type-limits option 

# even though it doesn't support it.  However, when another warning is 

# triggered, it gives an error that the option is not recognized.  So we 

# need to test with a conftest file that will generate warnings.

# 

# add an extra switch, pac_c_check_compiler_option_prototest, to

# disable this test just in case some new compiler does not like it.

#

# Linking with a program with an invalid prototype to ensure a compiler warning.

if test "$pac_result" = "yes" \

     -a "$pac_c_check_compiler_option_prototest" != "no" ; then

    AC_MSG_CHECKING([whether C compiler option $1 works with an invalid prototype program])

    AC_LINK_IFELSE([

        dnl We want a warning, but we don't want to inadvertently disable

        dnl special warnings like -Werror-implicit-function-declaration (e.g.,

        dnl in PAC_CC_STRICT) by compiling something that might actually be

        dnl treated as an error by the compiler.  So we try to elicit an

        dnl "unused variable" warning and/or an "uninitialized" warning with the

        dnl test program below.

        dnl

        dnl The old sanity program was:

        dnl   void main() {return 0;}

        dnl which clang (but not GCC) would treat as an *error*, invalidating

        dnl the test for any given parameter.

        AC_LANG_SOURCE([int main(int argc, char **argv){ int foo, bar = 0; foo += 1; return foo; }])

    ],[pac_result=yes],[pac_result=no])

    AC_MSG_RESULT([$pac_result])

fi

#

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

    AC_MSG_CHECKING([whether routines compiled with $pac_opt can be linked with ones compiled without $pac_opt])

    pac_result=unknown

    CFLAGS="$CFLAGS_orig"

    rm -f pac_test3.log

    PAC_COMPILE_IFELSE_LOG([pac_test3.log], [

        AC_LANG_SOURCE([

            int foo(void);

            int foo(void){return 0;}

        ])

    ],[

        PAC_RUNLOG([mv conftest.$OBJEXT pac_conftest.$OBJEXT])

        saved_LIBS="$LIBS"

        LIBS="pac_conftest.$OBJEXT $LIBS"

        rm -f pac_test4.log

        PAC_LINK_IFELSE_LOG([pac_test4.log], [AC_LANG_PROGRAM()], [

            CFLAGS="$CFLAGS_opt"

            rm -f pac_test5.log

            PAC_LINK_IFELSE_LOG([pac_test5.log], [AC_LANG_PROGRAM()], [

                PAC_RUNLOG_IFELSE([diff -b pac_test4.log pac_test5.log],

                                  [pac_result=yes], [pac_result=no])

            ],[

                pac_result=no

            ])

        ],[

            pac_result=no

        ])

        LIBS="$saved_LIBS"

        rm -f pac_conftest.$OBJEXT

    ],[

        pac_result=no

    ])

    AC_MSG_RESULT([$pac_result])

    rm -f pac_test3.log pac_test4.log pac_test5.log

fi

rm -f pac_test1.log pac_test2.log

dnl Restore CFLAGS before 2nd/3rd argument commands are executed,

dnl as 2nd/3rd argument command could be modifying CFLAGS.

CFLAGS="$CFLAGS_orig"

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

     ifelse([$2],[],[COPTIONS="$COPTIONS $1"],[$2])

else

     ifelse([$3],[],[:],[$3])

fi

AC_LANG_POP([C])

])

dnl

dnl/*D

dnl PAC_C_OPTIMIZATION - Determine C options for producing optimized code

dnl

dnl Synopsis

dnl PAC_C_OPTIMIZATION([action if found])

dnl

dnl Output Effect:

dnl Adds options to 'COPTIONS' if no other action is specified

dnl 

dnl Notes:

dnl This is a temporary standin for compiler optimization.

dnl It should try to match known systems to known compilers (checking, of

dnl course), and then falling back to some common defaults.

dnl Note that many compilers will complain about -g and aggressive

dnl optimization.  

dnl D*/

AC_DEFUN([PAC_C_OPTIMIZATION],[

    for copt in "-O4 -Ofast" "-Ofast" "-fast" "-O3" "-xO3" "-O" ; do

        PAC_C_CHECK_COMPILER_OPTION($copt,found_opt=yes,found_opt=no)

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

	    ifelse($1,,COPTIONS="$COPTIONS $copt",$1)

	    break

        fi

    done

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

	for copt in "-fomit-frame-pointer" "-finline-functions" \

		 "-funroll-loops" ; do

	    PAC_C_CHECK_COMPILER_OPTION($copt,found_opt=yes,found_opt=no)

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

	        ifelse($1,,COPTIONS="$COPTIONS $copt",$1)

	        # no break because we're trying to add them all

	    fi

	done

	# We could also look for architecture-specific gcc options

    fi

])

dnl/*D

dnl PAC_PROG_C_UNALIGNED_DOUBLES - Check that the C compiler allows unaligned

dnl doubles

dnl

dnl Synopsis:

dnl   PAC_PROG_C_UNALIGNED_DOUBLES(action-if-true,action-if-false,

dnl       action-if-unknown)

dnl

dnl Notes:

dnl 'action-if-unknown' is used in the case of cross-compilation.

dnl D*/

AC_DEFUN([PAC_PROG_C_UNALIGNED_DOUBLES],[

AC_CACHE_CHECK([whether C compiler allows unaligned doubles],

pac_cv_prog_c_unaligned_doubles,[

AC_TRY_RUN([

void fetch_double( v )

double *v;

{

*v = 1.0;

}

int main( argc, argv )

int argc;

char **argv;

{

int p[4];

double *p_val;

fetch_double( (double *)&(p[0]) );

p_val = (double *)&(p[0]);

if (*p_val != 1.0) return 1;

fetch_double( (double *)&(p[1]) );

p_val = (double *)&(p[1]);

if (*p_val != 1.0) return 1;

return 0;

}

],pac_cv_prog_c_unaligned_doubles="yes",pac_cv_prog_c_unaligned_doubles="no",

pac_cv_prog_c_unaligned_doubles="unknown")])

ifelse($1,,,if test "X$pac_cv_prog_c_unaligned_doubles" = "yes" ; then 

$1

fi)

ifelse($2,,,if test "X$pac_cv_prog_c_unaligned_doubles" = "no" ; then 

$2

fi)

ifelse($3,,,if test "X$pac_cv_prog_c_unaligned_doubles" = "unknown" ; then 

$3

fi)

])

dnl/*D 

dnl PAC_PROG_C_WEAK_SYMBOLS - Test whether C supports weak alias symbols.

dnl

dnl Synopsis

dnl PAC_PROG_C_WEAK_SYMBOLS(action-if-true,action-if-false)

dnl

dnl Output Effect:

dnl Defines one of the following if a weak symbol pragma is found:

dnl.vb

dnl    HAVE_PRAGMA_WEAK - #pragma weak

dnl    HAVE_PRAGMA_HP_SEC_DEF - #pragma _HP_SECONDARY_DEF

dnl    HAVE_PRAGMA_CRI_DUP  - #pragma _CRI duplicate x as y

dnl.ve

dnl May also define

dnl.vb

dnl    HAVE_WEAK_ATTRIBUTE

dnl.ve

dnl if functions can be declared as 'int foo(...) __attribute__ ((weak));'

dnl sets the shell variable pac_cv_attr_weak to yes.

dnl Also checks for __attribute__((weak_import)) which is supported by

dnl Apple in Mac OSX (at least in Darwin).  Note that this provides only

dnl weak symbols, not weak aliases

dnl 

dnl D*/

AC_DEFUN([PAC_PROG_C_WEAK_SYMBOLS],[

pragma_extra_message=""

AC_CACHE_CHECK([for type of weak symbol alias support],

pac_cv_prog_c_weak_symbols,[

# Test for weak symbol support...

# We can't put # in the message because it causes autoconf to generate

# incorrect code

AC_TRY_LINK([

extern int PFoo(int);

#pragma weak PFoo = Foo

int Foo(int a) { return a; }

],[return PFoo(1);],has_pragma_weak=yes)

#

# Some systems (Linux ia64 and ecc, for example), support weak symbols

# only within a single object file!  This tests that case.

# Note that there is an extern int PFoo declaration before the

# pragma.  Some compilers require this in order to make the weak symbol

# externally visible.  

if test "$has_pragma_weak" = yes ; then

    PAC_COMPLINK_IFELSE([

        AC_LANG_SOURCE([

extern int PFoo(int);

#pragma weak PFoo = Foo

int Foo(int);

int Foo(int a) { return a; }

        ])

    ],[

        AC_LANG_SOURCE([

extern int PFoo(int);

int main(int argc, char **argv) {

return PFoo(0);}

        ])

    ],[

        PAC_COMPLINK_IFELSE([

            AC_LANG_SOURCE([

extern int PFoo(int);

#pragma weak PFoo = Foo

int Foo(int);

int Foo(int a) { return a; }

            ])

        ],[

            AC_LANG_SOURCE([

extern int Foo(int);

int PFoo(int a) { return a+1;}

int main(int argc, char **argv) {

return Foo(0);}

            ])

        ],[

            pac_cv_prog_c_weak_symbols="pragma weak"

        ],[

            has_pragma_weak=0

            pragma_extra_message="pragma weak accepted but does not work (probably creates two non-weak entries)"

        ])

    ],[

        has_pragma_weak=0

        pragma_extra_message="pragma weak accepted but does not work (probably creates two non-weak entries)"

    ])

fi

dnl

if test -z "$pac_cv_prog_c_weak_symbols" ; then 

    AC_TRY_LINK([

extern int PFoo(int);

#pragma _HP_SECONDARY_DEF Foo  PFoo

int Foo(int a) { return a; }

],[return PFoo(1);],pac_cv_prog_c_weak_symbols="pragma _HP_SECONDARY_DEF")

fi

dnl

if test -z "$pac_cv_prog_c_weak_symbols" ; then

    AC_TRY_LINK([

extern int PFoo(int);

#pragma _CRI duplicate PFoo as Foo

int Foo(int a) { return a; }

],[return PFoo(1);],pac_cv_prog_c_weak_symbols="pragma _CRI duplicate x as y")

fi

dnl

if test -z "$pac_cv_prog_c_weak_symbols" ; then

    pac_cv_prog_c_weak_symbols="no"

fi

dnl

dnl If there is an extra explanatory message, echo it now so that it

dnl doesn't interfere with the cache result value

if test -n "$pragma_extra_message" ; then

    echo $pragma_extra_message

fi

dnl

])

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

    case "$pac_cv_prog_c_weak_symbols" in

        "pragma weak") AC_DEFINE(HAVE_PRAGMA_WEAK,1,[Supports weak pragma])

        ;;

        "pragma _HP")  AC_DEFINE(HAVE_PRAGMA_HP_SEC_DEF,1,[HP style weak pragma])

        ;;

        "pragma _CRI") AC_DEFINE(HAVE_PRAGMA_CRI_DUP,1,[Cray style weak pragma])

        ;;

    esac

fi

AC_CACHE_CHECK([whether __attribute__ ((weak)) allowed],

pac_cv_attr_weak,[

AC_TRY_COMPILE([int foo(int) __attribute__ ((weak));],[int a;],

pac_cv_attr_weak=yes,pac_cv_attr_weak=no)])

# Note that being able to compile with weak_import doesn't mean that

# it works.

AC_CACHE_CHECK([whether __attribute__ ((weak_import)) allowed],

pac_cv_attr_weak_import,[

AC_TRY_COMPILE([int foo(int) __attribute__ ((weak_import));],[int a;],

pac_cv_attr_weak_import=yes,pac_cv_attr_weak_import=no)])

# Check if the alias option for weak attributes is allowed

AC_CACHE_CHECK([whether __attribute__((weak,alias(...))) allowed],

pac_cv_attr_weak_alias,[

PAC_PUSH_FLAG([CFLAGS])

# force an error exit if the weak attribute isn't understood

CFLAGS=-Werror

AC_TRY_COMPILE([int __foo(int a){return 0;} int foo(int) __attribute__((weak,alias("__foo")));],[int a;],

pac_cv_attr_weak_alias=yes,pac_cv_attr_weak_alias=no)

# Restore original CFLAGS

PAC_POP_FLAG([CFLAGS])])

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

    AC_DEFINE(HAVE_WEAK_ATTRIBUTE,1,[Attribute style weak pragma])

fi

if test "$pac_cv_prog_c_weak_symbols" = "no" -a "$pac_cv_attr_weak_alias" = "no" ; then

    ifelse([$2],,:,[$2])

else

    ifelse([$1],,:,[$1])

fi

])

#

# This is a replacement that checks that FAILURES are signaled as well

# (later configure macros look for the .o file, not just success from the

# compiler, but they should not HAVE to

#

dnl --- insert 2.52 compatibility here ---

dnl 2.52 does not have AC_PROG_CC_WORKS

ifdef([AC_PROG_CC_WORKS],,[AC_DEFUN([AC_PROG_CC_WORKS],)])

dnl

AC_DEFUN([PAC_PROG_CC_WORKS],

[AC_PROG_CC_WORKS

AC_MSG_CHECKING([whether the C compiler sets its return status correctly])

AC_LANG_SAVE

AC_LANG_C

AC_TRY_COMPILE(,[int a = bzzzt;],notbroken=no,notbroken=yes)

AC_MSG_RESULT($notbroken)

if test "$notbroken" = "no" ; then

    AC_MSG_ERROR([installation or configuration problem: C compiler does not

correctly set error code when a fatal error occurs])

fi

])

dnl/*D 

dnl PAC_PROG_C_MULTIPLE_WEAK_SYMBOLS - Test whether C and the

dnl linker allow multiple weak symbols.

dnl

dnl Synopsis

dnl PAC_PROG_C_MULTIPLE_WEAK_SYMBOLS(action-if-true,action-if-false)

dnl

dnl 

dnl D*/

AC_DEFUN([PAC_PROG_C_MULTIPLE_WEAK_SYMBOLS],[

AC_CACHE_CHECK([for multiple weak symbol support],

pac_cv_prog_c_multiple_weak_symbols,[

# Test for multiple weak symbol support...

PAC_COMPLINK_IFELSE([

    AC_LANG_SOURCE([

extern int PFoo(int);

extern int PFoo_(int);

extern int pfoo_(int);

#pragma weak PFoo = Foo

#pragma weak PFoo_ = Foo

#pragma weak pfoo_ = Foo

int Foo(int);

int Foo(a) { return a; }

    ])

],[

    AC_LANG_SOURCE([

extern int PFoo(int), PFoo_(int), pfoo_(int);

int main() {

return PFoo(0) + PFoo_(1) + pfoo_(2);}

    ])

],[

    pac_cv_prog_c_multiple_weak_symbols="yes"

])

dnl

])

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

    ifelse([$1],,:,[$1])

else

    ifelse([$2],,:,[$2])

fi

])

dnl Use the value of enable-strict to update CFLAGS

dnl pac_cc_strict_flags contains the strict flags.

dnl

dnl -std=c89 is used to select the C89 version of the ANSI/ISO C standard.

dnl As of this writing, many C compilers still accepted only this version,

dnl not the later C99 version. When all compilers accept C99, this 

dnl should be changed to the appropriate standard level.  Note that we've

dnl had trouble with gcc 2.95.3 accepting -std=c89 but then trying to 

dnl compile program with a invalid set of options 

dnl (-D __STRICT_ANSI__-trigraphs)

AC_DEFUN([PAC_CC_STRICT],[

export enable_strict_done

if test "$enable_strict_done" != "yes" ; then

    # Some comments on strict warning options.

    # These were added to improve portability

    #   -Wstack-usage=262144 -- 32 bit FreeBSD did not like the mprobe test

    #       allocating a big variable on the stack. (See tt#2160).  The "right"

    #       value requires further investigation; 1 MiB would have at least

    #       caught #2160 at compile-time, and only two other tests show a

    #       warning at 256k.

    #

    # These were added to reduce warnings:

    #   -Wno-missing-field-initializers  -- We want to allow a struct to be 

    #       initialized to zero using "struct x y = {0};" and not require 

    #       each field to be initialized individually.

    #   -Wno-unused-parameter -- For portability, some parameters go unused

    #	    when we have different implementations of functions for 

    #	    different platforms

    #   -Wno-unused-label -- We add fn_exit: and fn_fail: on all functions, 

    #	    but fn_fail may not be used if the function doesn't return an 

    #	    error.

    #   -Wno-sign-compare -- read() and write() return bytes read/written

    #       as a signed value, but we often compare this to size_t (or

    #	    msg_sz_t) variables.

    #   -Wno-format-zero-length -- this warning is irritating and useless, since

    #                              a zero-length format string is very well defined

    # These were removed to reduce warnings:

    #   -Wcast-qual -- Sometimes we need to cast "volatile char*" to 

    #	    "char*", e.g., for memcpy.

    #   -Wpadded -- We catch struct padding with asserts when we need to

    #   -Wredundant-decls -- Having redundant declarations is benign and the 

    #	    code already has some.

    #   -Waggregate-return -- This seems to be a performance-related warning

    #       aggregate return values are legal in ANSI C, but they may be returned

    #	    in memory rather than through a register.  We do use aggregate return

    #	    values, but they are structs of a single basic type (used to enforce

    #	    type checking for relative vs. absolute ptrs), and with optimization

    #	    the aggregate value is converted to a scalar.

    #   -Wdeclaration-after-statement -- This is a C89

    #       requirement. When compiling with C99, this should be

    #       disabled.

    #   -Wfloat-equal -- There are places in hwloc that set a float var to 0, then 

    #       compare it to 0 later to see if it was updated.  Also when using strtod()

    #       one needs to compare the return value with 0 to see whether a conversion

    #       was performed.

    #   -Werror-implicit-function-declaration -- implicit function declarations

    #       should never be tolerated.  This also ensures that we get quick

    #       compilation failures rather than later link failures that usually

    #       come from a function name typo.

    #   -Wcast-align -- Casting alignment warnings.  This is an

    #       important check, but is temporarily disabled, since it is

    #       throwing too many (correct) warnings currently, causing us

    #       to miss other warnings.

    #   -Wshorten-64-to-32 -- Bad type-casting warnings.  This is an

    #       important check, but is temporarily disabled, since it is

    #       throwing too many (correct) warnings currently, causing us

    #       to miss other warnings.

    #

    # This was removed because it masks important failures (see ticket #2094).

    # However, since Intel compiler currently does not include -Wtype-limits

    # in -Wextra, -Wtype-limits was added to handle warnings with the Intel

    # compiler.

    #   -Wno-type-limits -- There are places where we compare an unsigned to 

    #	    a constant that happens to be zero e.g., if x is unsigned and 

    #	    MIN_VAL is zero, we'd like to do "MPIU_Assert(x >= MIN_VAL);".

    #       Note this option is not supported by gcc 4.2.  This needs to be added 

    #	    after most other warning flags, so that we catch a gcc bug on 32-bit 

    #	    that doesn't give a warning that this is unsupported, unless another

    #	    warning is triggered, and then if gives an error.

    # the embedded newlines in this string are safe because we evaluate each

    # argument in the for-loop below and append them to the CFLAGS with a space

    # as the separator instead

    pac_common_strict_flags="

        -Wall

        -Wextra

        -Wno-missing-field-initializers

        -Wstrict-prototypes

        -Wmissing-prototypes

        -DGCC_WALL

        -Wno-unused-parameter

        -Wno-unused-label

        -Wshadow

        -Wmissing-declarations

        -Wno-long-long

        -Wundef

        -Wno-endif-labels

        -Wpointer-arith

        -Wbad-function-cast

        -Wwrite-strings

        -Wno-sign-compare

        -Wold-style-definition

        -Wno-multichar

        -Wno-deprecated-declarations

        -Wpacked

        -Wnested-externs

        -Winvalid-pch

        -Wno-pointer-sign

        -Wvariadic-macros

        -Wno-format-zero-length

        -Wtype-limits

        -Werror-implicit-function-declaration

        -Wstack-usage=262144

    "

    enable_c89=no

    enable_c99=yes

    enable_posix=2001

    enable_opt=yes

    flags="`echo $1 | sed -e 's/:/ /g' -e 's/,/ /g'`"

    for flag in ${flags}; do

        case "$flag" in

	     c89)

		enable_strict_done="yes"

		enable_c89=yes

                enable_c99=no

		;;

	     c99)

		enable_strict_done="yes"

                enable_c89=no

		enable_c99=yes

		;;

	     posix1995)

		enable_strict_done="yes"

		enable_posix=1995

		;;

	     posix|posix2001)

		enable_strict_done="yes"

		enable_posix=2001

		;;

	     posix2008)

		enable_strict_done="yes"

		enable_posix=2008

		;;

	     noposix)

		enable_strict_done="yes"

		enable_posix=no

		;;

	     opt)

		enable_strict_done="yes"

		enable_opt=yes

		;;

	     noopt)

		enable_strict_done="yes"

		enable_opt=no

		;;

	     all|yes)

		enable_strict_done="yes"

		enable_c99=yes

		enable_posix=2001

		enable_opt=yes

	        ;;

	     no)

		# Accept and ignore this value

		:

		;;

	     *)

		if test -n "$flag" ; then

		   AC_MSG_WARN([Unrecognized value for enable-strict:$flag])

		fi

		;;

	esac

    done

    pac_cc_strict_flags=""

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

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

       	  pac_cc_strict_flags="-O2"

       fi

       pac_cc_strict_flags="$pac_cc_strict_flags $pac_common_strict_flags"

       # We only allow one of strict-C99 or strict-C89 to be

       # enabled. If C99 is enabled, we automatically disable C89.

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

       	  PAC_APPEND_FLAG([-std=c99],[pac_cc_strict_flags])

          # Use -D_STDC_C99= for Solaris compilers. See

          # http://lists.gnu.org/archive/html/autoconf/2010-12/msg00059.html

          # for discussion on why not to use -xc99

          PAC_APPEND_FLAG([-D_STDC_C99=],[pac_cc_strict_flags])

       elif test "${enable_c89}" = "yes" ; then

       	  PAC_APPEND_FLAG([-std=c89],[pac_cc_strict_flags])

       	  PAC_APPEND_FLAG([-Wdeclaration-after-statement],[pac_cc_strict_flags])

       fi

       # POSIX 2001 should be used with C99. But the default standard for some

       # compilers are not C99. We must test the support of POSIX 2001 after

       # testing C99.

       case "$enable_posix" in

            no)   : ;;

            1995) PAC_APPEND_FLAG([-D_POSIX_C_SOURCE=199506L],[pac_cc_strict_flags]) ;;

            2001) PAC_APPEND_FLAG([-D_POSIX_C_SOURCE=200112L],[pac_cc_strict_flags]) ;;

            2008) PAC_APPEND_FLAG([-D_POSIX_C_SOURCE=200809L],[pac_cc_strict_flags]) ;;

            *)    AC_MSG_ERROR([internal error, unexpected POSIX version: '$enable_posix']) ;;

       esac

    fi

    # See if the above options work with the compiler

    accepted_flags=""

    for flag in $pac_cc_strict_flags ; do

        PAC_PUSH_FLAG([CFLAGS])

	CFLAGS="$CFLAGS $accepted_flags"

        PAC_C_CHECK_COMPILER_OPTION([$flag],[accepted_flags="$accepted_flags $flag"],)

        PAC_POP_FLAG([CFLAGS])

    done

    pac_cc_strict_flags=$accepted_flags

fi

])

dnl/*D

dnl PAC_ARG_STRICT - Add --enable-strict to configure.  

dnl

dnl Synopsis:

dnl PAC_ARG_STRICT

dnl 

dnl Output effects:

dnl Adds '--enable-strict' to the command line.

dnl

dnl D*/

AC_DEFUN([PAC_ARG_STRICT],[

AC_ARG_ENABLE(strict,

	AC_HELP_STRING([--enable-strict], [Turn on strict compilation testing]))

PAC_CC_STRICT($enable_strict)

CFLAGS="$CFLAGS $pac_cc_strict_flags"

export CFLAGS

])

dnl Return the integer structure alignment in pac_cv_c_max_integer_align

dnl Possible values include

dnl	packed

dnl	two

dnl	four

dnl	eight

dnl

dnl In addition, a "Could not determine alignment" and a "error!"

dnl return is possible.  

AC_DEFUN([PAC_C_MAX_INTEGER_ALIGN],[

AC_CACHE_CHECK([for max C struct integer alignment],

pac_cv_c_max_integer_align,[

AC_TRY_RUN([

#include <stdio.h>

#define DBG(a,b,c)

int main( int argc, char *argv[] )

{

    FILE *cf;

    int is_packed  = 1;

    int is_two     = 1;

    int is_four    = 1;

    int is_eight   = 1;

    struct { char a; int b; } char_int;

    struct { char a; short b; } char_short;

    struct { char a; long b; } char_long;

    struct { char a; int b; char c; } char_int_char;

    struct { char a; short b; char c; } char_short_char;

#ifdef HAVE_LONG_LONG_INT

    struct { long long int a; char b; } lli_c;

    struct { char a; long long int b; } c_lli;

#endif

    int size, extent, extent2;

    /* assume max integer alignment isn't 8 if we don't have

     * an eight-byte value :)

     */

#ifdef HAVE_LONG_LONG_INT

    if (sizeof(int) < 8 && sizeof(long) < 8 && sizeof(long long int) < 8)

	is_eight = 0;

#else

    if (sizeof(int) < 8 && sizeof(long) < 8) is_eight = 0;

#endif

    size = sizeof(char) + sizeof(int);

    extent = sizeof(char_int);

    if (size != extent) is_packed = 0;

    if ( (extent % 2) != 0) is_two = 0;

    if ( (extent % 4) != 0) is_four = 0;

    if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;

    DBG("char_int",size,extent);

    size = sizeof(char) + sizeof(short);

    extent = sizeof(char_short);

    if (size != extent) is_packed = 0;

    if ( (extent % 2) != 0) is_two = 0;

    if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;

    if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;

    DBG("char_short",size,extent);

    size = sizeof(char) + sizeof(long);

    extent = sizeof(char_long);

    if (size != extent) is_packed = 0;

    if ( (extent % 2) != 0) is_two = 0;

    if ( (extent % 4) != 0) is_four = 0;

    if (sizeof(long) == 8 && (extent % 8) != 0) is_eight = 0;

    DBG("char_long",size,extent);

#ifdef HAVE_LONG_LONG_INT

    size = sizeof(char) + sizeof(long long int);

    extent = sizeof(lli_c);

    extent2 = sizeof(c_lli);

    if (size != extent) is_packed = 0;

    if ( (extent % 2) != 0 && (extent2 % 2) != 0) is_two = 0;

    if ( (extent % 4) != 0 && (extent2 % 4) != 0) is_four = 0;

    if (sizeof(long long int) >= 8 && (extent % 8) != 0 && (extent2 % 8) != 0)

	is_eight = 0;

#endif

    size = sizeof(char) + sizeof(int) + sizeof(char);

    extent = sizeof(char_int_char);

    if (size != extent) is_packed = 0;

    if ( (extent % 2) != 0) is_two = 0;

    if ( (extent % 4) != 0) is_four = 0;

    if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;

    DBG("char_int_char",size,extent);

    size = sizeof(char) + sizeof(short) + sizeof(char);

    extent = sizeof(char_short_char);

    if (size != extent) is_packed = 0;

    if ( (extent % 2) != 0) is_two = 0;

    if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;

    if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;

    DBG("char_short_char",size,extent);

    /* If aligned mod 8, it will be aligned mod 4 */

    if (is_eight) { is_four = 0; is_two = 0; }

    if (is_four) is_two = 0;

    /* Tabulate the results */

    cf = fopen( "ctest.out", "w" );

    if (is_packed + is_two + is_four + is_eight == 0) {

	fprintf( cf, "Could not determine alignment\n" );

    }

    else {

	if (is_packed + is_two + is_four + is_eight != 1) {

	    fprintf( cf, "error!\n" );

	}

	else {

	    if (is_packed) fprintf( cf, "packed\n" );

	    if (is_two) fprintf( cf, "two\n" );

	    if (is_four) fprintf( cf, "four\n" );

	    if (is_eight) fprintf( cf, "eight\n" );

	}

    }

    fclose( cf );

    return 0;

}],

pac_cv_c_max_integer_align=`cat ctest.out`,

pac_cv_c_max_integer_align="unknown",

pac_cv_c_max_integer_align="$CROSS_ALIGN_STRUCT_INT")

rm -f ctest.out

])

if test -z "$pac_cv_c_max_integer_align" ; then

    pac_cv_c_max_integer_align="unknown"

fi

])

dnl Return the floating point structure alignment in

dnl pac_cv_c_max_fp_align.

dnl

dnl Possible values include:

dnl	packed

dnl	two

dnl	four

dnl	eight

dnl     sixteen

dnl

dnl In addition, a "Could not determine alignment" and a "error!"

dnl return is possible.  

AC_DEFUN([PAC_C_MAX_FP_ALIGN],[

AC_CACHE_CHECK([for max C struct floating point alignment],

pac_cv_c_max_fp_align,[

AC_TRY_RUN([

#include <stdio.h>

#define DBG(a,b,c)

int main( int argc, char *argv[] )

{

    FILE *cf;

    int is_packed  = 1;

    int is_two     = 1;

    int is_four    = 1;

    int is_eight   = 1;

    int is_sixteen = 1;

    struct { char a; float b; } char_float;

    struct { float b; char a; } float_char;

    struct { char a; double b; } char_double;

    struct { double b; char a; } double_char;

#ifdef HAVE_LONG_DOUBLE

    struct { char a; long double b; } char_long_double;

    struct { long double b; char a; } long_double_char;

    struct { long double a; int b; char c; } long_double_int_char;

#endif

    int size, extent1, extent2;

    size = sizeof(char) + sizeof(float);

    extent1 = sizeof(char_float);

    extent2 = sizeof(float_char);

    if (size != extent1) is_packed = 0;

    if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;

    if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;

    if (sizeof(float) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)

	is_eight = 0;

    DBG("char_float",size,extent1);

    size = sizeof(char) + sizeof(double);

    extent1 = sizeof(char_double);

    extent2 = sizeof(double_char);

    if (size != extent1) is_packed = 0;

    if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;

    if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;

    if (sizeof(double) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)

	is_eight = 0;

    DBG("char_double",size,extent1);

#ifdef HAVE_LONG_DOUBLE

    size = sizeof(char) + sizeof(long double);

    extent1 = sizeof(char_long_double);

    extent2 = sizeof(long_double_char);

    if (size != extent1) is_packed = 0;

    if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;

    if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;

    if (sizeof(long double) >= 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)

	is_eight = 0;

    if (sizeof(long double) > 8 && (extent1 % 16) != 0

	&& (extent2 % 16) != 0) is_sixteen = 0;

    DBG("char_long-double",size,extent1);