| 3599 | | |
| 3600 | | |
| 3601 | | |
| 3602 | | |
| 3603 | | { echo "$as_me:$LINENO: checking for strerror in -lcposix" >&5 |
| 3604 | | echo $ECHO_N "checking for strerror in -lcposix... $ECHO_C" >&6; } |
| 3605 | | if test "${ac_cv_lib_cposix_strerror+set}" = set; then |
| 3606 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 3607 | | else |
| 3608 | | ac_check_lib_save_LIBS=$LIBS |
| 3609 | | LIBS="-lcposix $LIBS" |
| 3610 | | cat >conftest.$ac_ext <<_ACEOF |
| 3611 | | /* confdefs.h. */ |
| 3612 | | _ACEOF |
| 3613 | | cat confdefs.h >>conftest.$ac_ext |
| 3614 | | cat >>conftest.$ac_ext <<_ACEOF |
| 3615 | | /* end confdefs.h. */ |
| 3616 | | |
| 3617 | | /* Override any GCC internal prototype to avoid an error. |
| 3618 | | Use char because int might match the return type of a GCC |
| 3619 | | builtin and then its argument prototype would still apply. */ |
| 3620 | | #ifdef __cplusplus |
| 3621 | | extern "C" |
| 3622 | | #endif |
| 3623 | | char strerror (); |
| 3624 | | int |
| 3625 | | main () |
| 3626 | | { |
| 3627 | | return strerror (); |
| 3628 | | ; |
| 3629 | | return 0; |
| 3630 | | } |
| 3631 | | _ACEOF |
| 3632 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 3633 | | if { (ac_try="$ac_link" |
| 3634 | | case "(($ac_try" in |
| 3635 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 3636 | | *) ac_try_echo=$ac_try;; |
| 3637 | | esac |
| 3638 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 3639 | | (eval "$ac_link") 2>conftest.er1 |
| 3640 | | ac_status=$? |
| 3641 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 3642 | | rm -f conftest.er1 |
| 3643 | | cat conftest.err >&5 |
| 3644 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 3645 | | (exit $ac_status); } && { |
| 3646 | | test -z "$ac_c_werror_flag" || |
| 3647 | | test ! -s conftest.err |
| 3648 | | } && test -s conftest$ac_exeext && |
| 3649 | | $as_test_x conftest$ac_exeext; then |
| 3650 | | ac_cv_lib_cposix_strerror=yes |
| 3651 | | else |
| 3652 | | echo "$as_me: failed program was:" >&5 |
| 3653 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 3654 | | |
| 3655 | | ac_cv_lib_cposix_strerror=no |
| 3656 | | fi |
| 3657 | | |
| 3658 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 3659 | | conftest$ac_exeext conftest.$ac_ext |
| 3660 | | LIBS=$ac_check_lib_save_LIBS |
| 3661 | | fi |
| 3662 | | { echo "$as_me:$LINENO: result: $ac_cv_lib_cposix_strerror" >&5 |
| 3663 | | echo "${ECHO_T}$ac_cv_lib_cposix_strerror" >&6; } |
| 3664 | | if test $ac_cv_lib_cposix_strerror = yes; then |
| 3665 | | LIBS="$LIBS -lcposix" |
| 3666 | | fi |
| 3667 | | |
| 3668 | | |
| 3669 | | |
| 3670 | | CFLAGS=$CFLAGS |
| 3671 | | |
| 3672 | | ac_ext=c |
| 3673 | | ac_cpp='$CPP $CPPFLAGS' |
| 3674 | | ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' |
| 3675 | | ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' |
| 3676 | | ac_compiler_gnu=$ac_cv_c_compiler_gnu |
| 3677 | | if test -n "$ac_tool_prefix"; then |
| 3678 | | # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. |
| 3679 | | set dummy ${ac_tool_prefix}gcc; ac_word=$2 |
| 3680 | | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| 3681 | | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| 3682 | | if test "${ac_cv_prog_CC+set}" = set; then |
| 3683 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 3684 | | else |
| 3685 | | if test -n "$CC"; then |
| 3686 | | ac_cv_prog_CC="$CC" # Let the user override the test. |
| 3687 | | else |
| 3688 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 3689 | | for as_dir in $PATH |
| 3690 | | do |
| 3691 | | IFS=$as_save_IFS |
| 3692 | | test -z "$as_dir" && as_dir=. |
| 3693 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 3694 | | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| 3695 | | ac_cv_prog_CC="${ac_tool_prefix}gcc" |
| 3696 | | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| 3697 | | break 2 |
| 3698 | | fi |
| 3699 | | done |
| 3700 | | done |
| 3701 | | IFS=$as_save_IFS |
| 3702 | | |
| 3703 | | fi |
| 3704 | | fi |
| 3705 | | CC=$ac_cv_prog_CC |
| 3706 | | if test -n "$CC"; then |
| 3707 | | { echo "$as_me:$LINENO: result: $CC" >&5 |
| 3708 | | echo "${ECHO_T}$CC" >&6; } |
| 3709 | | else |
| 3710 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 3711 | | echo "${ECHO_T}no" >&6; } |
| 3712 | | fi |
| 3713 | | |
| 3714 | | |
| 3715 | | fi |
| 3716 | | if test -z "$ac_cv_prog_CC"; then |
| 3717 | | ac_ct_CC=$CC |
| 3718 | | # Extract the first word of "gcc", so it can be a program name with args. |
| 3719 | | set dummy gcc; ac_word=$2 |
| 3720 | | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| 3721 | | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| 3722 | | if test "${ac_cv_prog_ac_ct_CC+set}" = set; then |
| 3723 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 3724 | | else |
| 3725 | | if test -n "$ac_ct_CC"; then |
| 3726 | | ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. |
| 3727 | | else |
| 3728 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 3729 | | for as_dir in $PATH |
| 3730 | | do |
| 3731 | | IFS=$as_save_IFS |
| 3732 | | test -z "$as_dir" && as_dir=. |
| 3733 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 3734 | | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| 3735 | | ac_cv_prog_ac_ct_CC="gcc" |
| 3736 | | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| 3737 | | break 2 |
| 3738 | | fi |
| 3739 | | done |
| 3740 | | done |
| 3741 | | IFS=$as_save_IFS |
| 3742 | | |
| 3743 | | fi |
| 3744 | | fi |
| 3745 | | ac_ct_CC=$ac_cv_prog_ac_ct_CC |
| 3746 | | if test -n "$ac_ct_CC"; then |
| 3747 | | { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5 |
| 3748 | | echo "${ECHO_T}$ac_ct_CC" >&6; } |
| 3749 | | else |
| 3750 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 3751 | | echo "${ECHO_T}no" >&6; } |
| 3752 | | fi |
| 3753 | | |
| 3754 | | if test "x$ac_ct_CC" = x; then |
| 3755 | | CC="" |
| 3756 | | else |
| 3757 | | case $cross_compiling:$ac_tool_warned in |
| 3758 | | yes:) |
| 3759 | | { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools |
| 3760 | | whose name does not start with the host triplet. If you think this |
| 3761 | | configuration is useful to you, please write to autoconf@gnu.org." >&5 |
| 3762 | | echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools |
| 3763 | | whose name does not start with the host triplet. If you think this |
| 3764 | | configuration is useful to you, please write to autoconf@gnu.org." >&2;} |
| 3765 | | ac_tool_warned=yes ;; |
| 3766 | | esac |
| 3767 | | CC=$ac_ct_CC |
| 3768 | | fi |
| 3769 | | else |
| 3770 | | CC="$ac_cv_prog_CC" |
| 3771 | | fi |
| 3772 | | |
| 3773 | | if test -z "$CC"; then |
| 3774 | | if test -n "$ac_tool_prefix"; then |
| 3775 | | # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. |
| 3776 | | set dummy ${ac_tool_prefix}cc; ac_word=$2 |
| 3777 | | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| 3778 | | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| 3779 | | if test "${ac_cv_prog_CC+set}" = set; then |
| 3780 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 3781 | | else |
| 3782 | | if test -n "$CC"; then |
| 3783 | | ac_cv_prog_CC="$CC" # Let the user override the test. |
| 3784 | | else |
| 3785 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 3786 | | for as_dir in $PATH |
| 3787 | | do |
| 3788 | | IFS=$as_save_IFS |
| 3789 | | test -z "$as_dir" && as_dir=. |
| 3790 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 3791 | | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| 3792 | | ac_cv_prog_CC="${ac_tool_prefix}cc" |
| 3793 | | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| 3794 | | break 2 |
| 3795 | | fi |
| 3796 | | done |
| 3797 | | done |
| 3798 | | IFS=$as_save_IFS |
| 3799 | | |
| 3800 | | fi |
| 3801 | | fi |
| 3802 | | CC=$ac_cv_prog_CC |
| 3803 | | if test -n "$CC"; then |
| 3804 | | { echo "$as_me:$LINENO: result: $CC" >&5 |
| 3805 | | echo "${ECHO_T}$CC" >&6; } |
| 3806 | | else |
| 3807 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 3808 | | echo "${ECHO_T}no" >&6; } |
| 3809 | | fi |
| 3810 | | |
| 3811 | | |
| 3812 | | fi |
| 3813 | | fi |
| 3814 | | if test -z "$CC"; then |
| 3815 | | # Extract the first word of "cc", so it can be a program name with args. |
| 3816 | | set dummy cc; ac_word=$2 |
| 3817 | | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| 3818 | | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| 3819 | | if test "${ac_cv_prog_CC+set}" = set; then |
| 3820 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 3821 | | else |
| 3822 | | if test -n "$CC"; then |
| 3823 | | ac_cv_prog_CC="$CC" # Let the user override the test. |
| 3824 | | else |
| 3825 | | ac_prog_rejected=no |
| 3826 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 3827 | | for as_dir in $PATH |
| 3828 | | do |
| 3829 | | IFS=$as_save_IFS |
| 3830 | | test -z "$as_dir" && as_dir=. |
| 3831 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 3832 | | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| 3833 | | if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then |
| 3834 | | ac_prog_rejected=yes |
| 3835 | | continue |
| 3836 | | fi |
| 3837 | | ac_cv_prog_CC="cc" |
| 3838 | | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| 3839 | | break 2 |
| 3840 | | fi |
| 3841 | | done |
| 3842 | | done |
| 3843 | | IFS=$as_save_IFS |
| 3844 | | |
| 3845 | | if test $ac_prog_rejected = yes; then |
| 3846 | | # We found a bogon in the path, so make sure we never use it. |
| 3847 | | set dummy $ac_cv_prog_CC |
| 3848 | | shift |
| 3849 | | if test $# != 0; then |
| 3850 | | # We chose a different compiler from the bogus one. |
| 3851 | | # However, it has the same basename, so the bogon will be chosen |
| 3852 | | # first if we set CC to just the basename; use the full file name. |
| 3853 | | shift |
| 3854 | | ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" |
| 3855 | | fi |
| 3856 | | fi |
| 3857 | | fi |
| 3858 | | fi |
| 3859 | | CC=$ac_cv_prog_CC |
| 3860 | | if test -n "$CC"; then |
| 3861 | | { echo "$as_me:$LINENO: result: $CC" >&5 |
| 3862 | | echo "${ECHO_T}$CC" >&6; } |
| 3863 | | else |
| 3864 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 3865 | | echo "${ECHO_T}no" >&6; } |
| 3866 | | fi |
| 3867 | | |
| 3868 | | |
| 3869 | | fi |
| 3870 | | if test -z "$CC"; then |
| 3871 | | if test -n "$ac_tool_prefix"; then |
| 3872 | | for ac_prog in cl.exe |
| 3873 | | do |
| 3874 | | # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. |
| 3875 | | set dummy $ac_tool_prefix$ac_prog; ac_word=$2 |
| 3876 | | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| 3877 | | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| 3878 | | if test "${ac_cv_prog_CC+set}" = set; then |
| 3879 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 3880 | | else |
| 3881 | | if test -n "$CC"; then |
| 3882 | | ac_cv_prog_CC="$CC" # Let the user override the test. |
| 3883 | | else |
| 3884 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 3885 | | for as_dir in $PATH |
| 3886 | | do |
| 3887 | | IFS=$as_save_IFS |
| 3888 | | test -z "$as_dir" && as_dir=. |
| 3889 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 3890 | | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| 3891 | | ac_cv_prog_CC="$ac_tool_prefix$ac_prog" |
| 3892 | | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| 3893 | | break 2 |
| 3894 | | fi |
| 3895 | | done |
| 3896 | | done |
| 3897 | | IFS=$as_save_IFS |
| 3898 | | |
| 3899 | | fi |
| 3900 | | fi |
| 3901 | | CC=$ac_cv_prog_CC |
| 3902 | | if test -n "$CC"; then |
| 3903 | | { echo "$as_me:$LINENO: result: $CC" >&5 |
| 3904 | | echo "${ECHO_T}$CC" >&6; } |
| 3905 | | else |
| 3906 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 3907 | | echo "${ECHO_T}no" >&6; } |
| 3908 | | fi |
| 3909 | | |
| 3910 | | |
| 3911 | | test -n "$CC" && break |
| 3912 | | done |
| 3913 | | fi |
| 3914 | | if test -z "$CC"; then |
| 3915 | | ac_ct_CC=$CC |
| 3916 | | for ac_prog in cl.exe |
| 3917 | | do |
| 3918 | | # Extract the first word of "$ac_prog", so it can be a program name with args. |
| 3919 | | set dummy $ac_prog; ac_word=$2 |
| 3920 | | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| 3921 | | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| 3922 | | if test "${ac_cv_prog_ac_ct_CC+set}" = set; then |
| 3923 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 3924 | | else |
| 3925 | | if test -n "$ac_ct_CC"; then |
| 3926 | | ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. |
| 3927 | | else |
| 3928 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 3929 | | for as_dir in $PATH |
| 3930 | | do |
| 3931 | | IFS=$as_save_IFS |
| 3932 | | test -z "$as_dir" && as_dir=. |
| 3933 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 3934 | | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| 3935 | | ac_cv_prog_ac_ct_CC="$ac_prog" |
| 3936 | | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| 3937 | | break 2 |
| 3938 | | fi |
| 3939 | | done |
| 3940 | | done |
| 3941 | | IFS=$as_save_IFS |
| 3942 | | |
| 3943 | | fi |
| 3944 | | fi |
| 3945 | | ac_ct_CC=$ac_cv_prog_ac_ct_CC |
| 3946 | | if test -n "$ac_ct_CC"; then |
| 3947 | | { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5 |
| 3948 | | echo "${ECHO_T}$ac_ct_CC" >&6; } |
| 3949 | | else |
| 3950 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 3951 | | echo "${ECHO_T}no" >&6; } |
| 3952 | | fi |
| 3953 | | |
| 3954 | | |
| 3955 | | test -n "$ac_ct_CC" && break |
| 3956 | | done |
| 3957 | | |
| 3958 | | if test "x$ac_ct_CC" = x; then |
| 3959 | | CC="" |
| 3960 | | else |
| 3961 | | case $cross_compiling:$ac_tool_warned in |
| 3962 | | yes:) |
| 3963 | | { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools |
| 3964 | | whose name does not start with the host triplet. If you think this |
| 3965 | | configuration is useful to you, please write to autoconf@gnu.org." >&5 |
| 3966 | | echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools |
| 3967 | | whose name does not start with the host triplet. If you think this |
| 3968 | | configuration is useful to you, please write to autoconf@gnu.org." >&2;} |
| 3969 | | ac_tool_warned=yes ;; |
| 3970 | | esac |
| 3971 | | CC=$ac_ct_CC |
| 3972 | | fi |
| 3973 | | fi |
| 3974 | | |
| 3975 | | fi |
| 3976 | | |
| 3977 | | |
| 3978 | | test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH |
| 3979 | | See \`config.log' for more details." >&5 |
| 3980 | | echo "$as_me: error: no acceptable C compiler found in \$PATH |
| 3981 | | See \`config.log' for more details." >&2;} |
| 3982 | | { (exit 1); exit 1; }; } |
| 3983 | | |
| 3984 | | # Provide some information about the compiler. |
| 3985 | | echo "$as_me:$LINENO: checking for C compiler version" >&5 |
| 3986 | | ac_compiler=`set X $ac_compile; echo $2` |
| 3987 | | { (ac_try="$ac_compiler --version >&5" |
| 3988 | | case "(($ac_try" in |
| 3989 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 3990 | | *) ac_try_echo=$ac_try;; |
| 3991 | | esac |
| 3992 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 3993 | | (eval "$ac_compiler --version >&5") 2>&5 |
| 3994 | | ac_status=$? |
| 3995 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 3996 | | (exit $ac_status); } |
| 3997 | | { (ac_try="$ac_compiler -v >&5" |
| 3998 | | case "(($ac_try" in |
| 3999 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 4000 | | *) ac_try_echo=$ac_try;; |
| 4001 | | esac |
| 4002 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 4003 | | (eval "$ac_compiler -v >&5") 2>&5 |
| 4004 | | ac_status=$? |
| 4005 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 4006 | | (exit $ac_status); } |
| 4007 | | { (ac_try="$ac_compiler -V >&5" |
| 4008 | | case "(($ac_try" in |
| 4009 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 4010 | | *) ac_try_echo=$ac_try;; |
| 4011 | | esac |
| 4012 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 4013 | | (eval "$ac_compiler -V >&5") 2>&5 |
| 4014 | | ac_status=$? |
| 4015 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 4016 | | (exit $ac_status); } |
| 4017 | | |
| 4018 | | { echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5 |
| 4019 | | echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; } |
| 4020 | | if test "${ac_cv_c_compiler_gnu+set}" = set; then |
| 4021 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 4022 | | else |
| 4023 | | cat >conftest.$ac_ext <<_ACEOF |
| 4024 | | /* confdefs.h. */ |
| 4025 | | _ACEOF |
| 4026 | | cat confdefs.h >>conftest.$ac_ext |
| 4027 | | cat >>conftest.$ac_ext <<_ACEOF |
| 4028 | | /* end confdefs.h. */ |
| 4029 | | |
| 4030 | | int |
| 4031 | | main () |
| 4032 | | { |
| 4033 | | #ifndef __GNUC__ |
| 4034 | | choke me |
| 4035 | | #endif |
| 4036 | | |
| 4037 | | ; |
| 4038 | | return 0; |
| 4039 | | } |
| 4040 | | _ACEOF |
| 4041 | | rm -f conftest.$ac_objext |
| 4042 | | if { (ac_try="$ac_compile" |
| 4043 | | case "(($ac_try" in |
| 4044 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 4045 | | *) ac_try_echo=$ac_try;; |
| 4046 | | esac |
| 4047 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 4048 | | (eval "$ac_compile") 2>conftest.er1 |
| 4049 | | ac_status=$? |
| 4050 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 4051 | | rm -f conftest.er1 |
| 4052 | | cat conftest.err >&5 |
| 4053 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 4054 | | (exit $ac_status); } && { |
| 4055 | | test -z "$ac_c_werror_flag" || |
| 4056 | | test ! -s conftest.err |
| 4057 | | } && test -s conftest.$ac_objext; then |
| 4058 | | ac_compiler_gnu=yes |
| 4059 | | else |
| 4060 | | echo "$as_me: failed program was:" >&5 |
| 4061 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 4062 | | |
| 4063 | | ac_compiler_gnu=no |
| 4064 | | fi |
| 4065 | | |
| 4066 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 4067 | | ac_cv_c_compiler_gnu=$ac_compiler_gnu |
| 4068 | | |
| 4069 | | fi |
| 4070 | | { echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5 |
| 4071 | | echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; } |
| 4072 | | GCC=`test $ac_compiler_gnu = yes && echo yes` |
| 4073 | | ac_test_CFLAGS=${CFLAGS+set} |
| 4074 | | ac_save_CFLAGS=$CFLAGS |
| 4075 | | { echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5 |
| 4076 | | echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; } |
| 4077 | | if test "${ac_cv_prog_cc_g+set}" = set; then |
| 4078 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 4079 | | else |
| 4080 | | ac_save_c_werror_flag=$ac_c_werror_flag |
| 4081 | | ac_c_werror_flag=yes |
| 4082 | | ac_cv_prog_cc_g=no |
| 4083 | | CFLAGS="-g" |
| 4084 | | cat >conftest.$ac_ext <<_ACEOF |
| 4085 | | /* confdefs.h. */ |
| 4086 | | _ACEOF |
| 4087 | | cat confdefs.h >>conftest.$ac_ext |
| 4088 | | cat >>conftest.$ac_ext <<_ACEOF |
| 4089 | | /* end confdefs.h. */ |
| 4090 | | |
| 4091 | | int |
| 4092 | | main () |
| 4093 | | { |
| 4094 | | |
| 4095 | | ; |
| 4096 | | return 0; |
| 4097 | | } |
| 4098 | | _ACEOF |
| 4099 | | rm -f conftest.$ac_objext |
| 4100 | | if { (ac_try="$ac_compile" |
| 4101 | | case "(($ac_try" in |
| 4102 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 4103 | | *) ac_try_echo=$ac_try;; |
| 4104 | | esac |
| 4105 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 4106 | | (eval "$ac_compile") 2>conftest.er1 |
| 4107 | | ac_status=$? |
| 4108 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 4109 | | rm -f conftest.er1 |
| 4110 | | cat conftest.err >&5 |
| 4111 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 4112 | | (exit $ac_status); } && { |
| 4113 | | test -z "$ac_c_werror_flag" || |
| 4114 | | test ! -s conftest.err |
| 4115 | | } && test -s conftest.$ac_objext; then |
| 4116 | | ac_cv_prog_cc_g=yes |
| 4117 | | else |
| 4118 | | echo "$as_me: failed program was:" >&5 |
| 4119 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 4120 | | |
| 4121 | | CFLAGS="" |
| 4122 | | cat >conftest.$ac_ext <<_ACEOF |
| 4123 | | /* confdefs.h. */ |
| 4124 | | _ACEOF |
| 4125 | | cat confdefs.h >>conftest.$ac_ext |
| 4126 | | cat >>conftest.$ac_ext <<_ACEOF |
| 4127 | | /* end confdefs.h. */ |
| 4128 | | |
| 4129 | | int |
| 4130 | | main () |
| 4131 | | { |
| 4132 | | |
| 4133 | | ; |
| 4134 | | return 0; |
| 4135 | | } |
| 4136 | | _ACEOF |
| 4137 | | rm -f conftest.$ac_objext |
| 4138 | | if { (ac_try="$ac_compile" |
| 4139 | | case "(($ac_try" in |
| 4140 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 4141 | | *) ac_try_echo=$ac_try;; |
| 4142 | | esac |
| 4143 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 4144 | | (eval "$ac_compile") 2>conftest.er1 |
| 4145 | | ac_status=$? |
| 4146 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 4147 | | rm -f conftest.er1 |
| 4148 | | cat conftest.err >&5 |
| 4149 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 4150 | | (exit $ac_status); } && { |
| 4151 | | test -z "$ac_c_werror_flag" || |
| 4152 | | test ! -s conftest.err |
| 4153 | | } && test -s conftest.$ac_objext; then |
| 4154 | | : |
| 4155 | | else |
| 4156 | | echo "$as_me: failed program was:" >&5 |
| 4157 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 4158 | | |
| 4159 | | ac_c_werror_flag=$ac_save_c_werror_flag |
| 4160 | | CFLAGS="-g" |
| 4161 | | cat >conftest.$ac_ext <<_ACEOF |
| 4162 | | /* confdefs.h. */ |
| 4163 | | _ACEOF |
| 4164 | | cat confdefs.h >>conftest.$ac_ext |
| 4165 | | cat >>conftest.$ac_ext <<_ACEOF |
| 4166 | | /* end confdefs.h. */ |
| 4167 | | |
| 4168 | | int |
| 4169 | | main () |
| 4170 | | { |
| 4171 | | |
| 4172 | | ; |
| 4173 | | return 0; |
| 4174 | | } |
| 4175 | | _ACEOF |
| 4176 | | rm -f conftest.$ac_objext |
| 4177 | | if { (ac_try="$ac_compile" |
| 4178 | | case "(($ac_try" in |
| 4179 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 4180 | | *) ac_try_echo=$ac_try;; |
| 4181 | | esac |
| 4182 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 4183 | | (eval "$ac_compile") 2>conftest.er1 |
| 4184 | | ac_status=$? |
| 4185 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 4186 | | rm -f conftest.er1 |
| 4187 | | cat conftest.err >&5 |
| 4188 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 4189 | | (exit $ac_status); } && { |
| 4190 | | test -z "$ac_c_werror_flag" || |
| 4191 | | test ! -s conftest.err |
| 4192 | | } && test -s conftest.$ac_objext; then |
| 4193 | | ac_cv_prog_cc_g=yes |
| 4194 | | else |
| 4195 | | echo "$as_me: failed program was:" >&5 |
| 4196 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 4197 | | |
| 4198 | | |
| 4199 | | fi |
| 4200 | | |
| 4201 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 4202 | | fi |
| 4203 | | |
| 4204 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 4205 | | fi |
| 4206 | | |
| 4207 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 4208 | | ac_c_werror_flag=$ac_save_c_werror_flag |
| 4209 | | fi |
| 4210 | | { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5 |
| 4211 | | echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; } |
| 4212 | | if test "$ac_test_CFLAGS" = set; then |
| 4213 | | CFLAGS=$ac_save_CFLAGS |
| 4214 | | elif test $ac_cv_prog_cc_g = yes; then |
| 4215 | | if test "$GCC" = yes; then |
| 4216 | | CFLAGS="-g -O2" |
| 4217 | | else |
| 4218 | | CFLAGS="-g" |
| 4219 | | fi |
| 4220 | | else |
| 4221 | | if test "$GCC" = yes; then |
| 4222 | | CFLAGS="-O2" |
| 4223 | | else |
| 4224 | | CFLAGS= |
| 4225 | | fi |
| 4226 | | fi |
| 4227 | | { echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5 |
| 4228 | | echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; } |
| 4229 | | if test "${ac_cv_prog_cc_c89+set}" = set; then |
| 4230 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 4231 | | else |
| 4232 | | ac_cv_prog_cc_c89=no |
| 4233 | | ac_save_CC=$CC |
| 4234 | | cat >conftest.$ac_ext <<_ACEOF |
| 4235 | | /* confdefs.h. */ |
| 4236 | | _ACEOF |
| 4237 | | cat confdefs.h >>conftest.$ac_ext |
| 4238 | | cat >>conftest.$ac_ext <<_ACEOF |
| 4239 | | /* end confdefs.h. */ |
| 4240 | | #include <stdarg.h> |
| 4241 | | #include <stdio.h> |
| 4242 | | #include <sys/types.h> |
| 4243 | | #include <sys/stat.h> |
| 4244 | | /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ |
| 4245 | | struct buf { int x; }; |
| 4246 | | FILE * (*rcsopen) (struct buf *, struct stat *, int); |
| 4247 | | static char *e (p, i) |
| 4248 | | char **p; |
| 4249 | | int i; |
| 4250 | | { |
| 4251 | | return p[i]; |
| 4252 | | } |
| 4253 | | static char *f (char * (*g) (char **, int), char **p, ...) |
| 4254 | | { |
| 4255 | | char *s; |
| 4256 | | va_list v; |
| 4257 | | va_start (v,p); |
| 4258 | | s = g (p, va_arg (v,int)); |
| 4259 | | va_end (v); |
| 4260 | | return s; |
| 4261 | | } |
| 4262 | | |
| 4263 | | /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has |
| 4264 | | function prototypes and stuff, but not '\xHH' hex character constants. |
| 4265 | | These don't provoke an error unfortunately, instead are silently treated |
| 4266 | | as 'x'. The following induces an error, until -std is added to get |
| 4267 | | proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an |
| 4268 | | array size at least. It's necessary to write '\x00'==0 to get something |
| 4269 | | that's true only with -std. */ |
| 4270 | | int osf4_cc_array ['\x00' == 0 ? 1 : -1]; |
| 4271 | | |
| 4272 | | /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters |
| 4273 | | inside strings and character constants. */ |
| 4274 | | #define FOO(x) 'x' |
| 4275 | | int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; |
| 4276 | | |
| 4277 | | int test (int i, double x); |
| 4278 | | struct s1 {int (*f) (int a);}; |
| 4279 | | struct s2 {int (*f) (double a);}; |
| 4280 | | int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); |
| 4281 | | int argc; |
| 4282 | | char **argv; |
| 4283 | | int |
| 4284 | | main () |
| 4285 | | { |
| 4286 | | return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; |
| 4287 | | ; |
| 4288 | | return 0; |
| 4289 | | } |
| 4290 | | _ACEOF |
| 4291 | | for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ |
| 4292 | | -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" |
| 4293 | | do |
| 4294 | | CC="$ac_save_CC $ac_arg" |
| 4295 | | rm -f conftest.$ac_objext |
| 4296 | | if { (ac_try="$ac_compile" |
| 4297 | | case "(($ac_try" in |
| 4298 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 4299 | | *) ac_try_echo=$ac_try;; |
| 4300 | | esac |
| 4301 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 4302 | | (eval "$ac_compile") 2>conftest.er1 |
| 4303 | | ac_status=$? |
| 4304 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 4305 | | rm -f conftest.er1 |
| 4306 | | cat conftest.err >&5 |
| 4307 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 4308 | | (exit $ac_status); } && { |
| 4309 | | test -z "$ac_c_werror_flag" || |
| 4310 | | test ! -s conftest.err |
| 4311 | | } && test -s conftest.$ac_objext; then |
| 4312 | | ac_cv_prog_cc_c89=$ac_arg |
| 4313 | | else |
| 4314 | | echo "$as_me: failed program was:" >&5 |
| 4315 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 4316 | | |
| 4317 | | |
| 4318 | | fi |
| 4319 | | |
| 4320 | | rm -f core conftest.err conftest.$ac_objext |
| 4321 | | test "x$ac_cv_prog_cc_c89" != "xno" && break |
| 4322 | | done |
| 4323 | | rm -f conftest.$ac_ext |
| 4324 | | CC=$ac_save_CC |
| 4325 | | |
| 4326 | | fi |
| 4327 | | # AC_CACHE_VAL |
| 4328 | | case "x$ac_cv_prog_cc_c89" in |
| 4329 | | x) |
| 4330 | | { echo "$as_me:$LINENO: result: none needed" >&5 |
| 4331 | | echo "${ECHO_T}none needed" >&6; } ;; |
| 4332 | | xno) |
| 4333 | | { echo "$as_me:$LINENO: result: unsupported" >&5 |
| 4334 | | echo "${ECHO_T}unsupported" >&6; } ;; |
| 4335 | | *) |
| 4336 | | CC="$CC $ac_cv_prog_cc_c89" |
| 4337 | | { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5 |
| 4338 | | echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;; |
| 4339 | | esac |
| 4340 | | |
| 4341 | | |
| 4342 | | ac_ext=c |
| 4343 | | ac_cpp='$CPP $CPPFLAGS' |
| 4344 | | ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' |
| 4345 | | ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' |
| 4346 | | ac_compiler_gnu=$ac_cv_c_compiler_gnu |
| 4347 | | |
| 4348 | | depcc="$CC" am_compiler_list= |
| 4349 | | |
| 4350 | | { echo "$as_me:$LINENO: checking dependency style of $depcc" >&5 |
| 4351 | | echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6; } |
| 4352 | | if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then |
| 4353 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 4354 | | else |
| 4355 | | if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then |
| 4356 | | # We make a subdir and do the tests there. Otherwise we can end up |
| 4357 | | # making bogus files that we don't know about and never remove. For |
| 4358 | | # instance it was reported that on HP-UX the gcc test will end up |
| 4359 | | # making a dummy file named `D' -- because `-MD' means `put the output |
| 4360 | | # in D'. |
| 4361 | | mkdir conftest.dir |
| 4362 | | # Copy depcomp to subdir because otherwise we won't find it if we're |
| 4363 | | # using a relative directory. |
| 4364 | | cp "$am_depcomp" conftest.dir |
| 4365 | | cd conftest.dir |
| 4366 | | # We will build objects and dependencies in a subdirectory because |
| 4367 | | # it helps to detect inapplicable dependency modes. For instance |
| 4368 | | # both Tru64's cc and ICC support -MD to output dependencies as a |
| 4369 | | # side effect of compilation, but ICC will put the dependencies in |
| 4370 | | # the current directory while Tru64 will put them in the object |
| 4371 | | # directory. |
| 4372 | | mkdir sub |
| 4373 | | |
| 4374 | | am_cv_CC_dependencies_compiler_type=none |
| 4375 | | if test "$am_compiler_list" = ""; then |
| 4376 | | am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` |
| 4377 | | fi |
| 4378 | | for depmode in $am_compiler_list; do |
| 4379 | | # Setup a source with many dependencies, because some compilers |
| 4380 | | # like to wrap large dependency lists on column 80 (with \), and |
| 4381 | | # we should not choose a depcomp mode which is confused by this. |
| 4382 | | # |
| 4383 | | # We need to recreate these files for each test, as the compiler may |
| 4384 | | # overwrite some of them when testing with obscure command lines. |
| 4385 | | # This happens at least with the AIX C compiler. |
| 4386 | | : > sub/conftest.c |
| 4387 | | for i in 1 2 3 4 5 6; do |
| 4388 | | echo '#include "conftst'$i'.h"' >> sub/conftest.c |
| 4389 | | # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with |
| 4390 | | # Solaris 8's {/usr,}/bin/sh. |
| 4391 | | touch sub/conftst$i.h |
| 4392 | | done |
| 4393 | | echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf |
| 4394 | | |
| 4395 | | case $depmode in |
| 4396 | | nosideeffect) |
| 4397 | | # after this tag, mechanisms are not by side-effect, so they'll |
| 4398 | | # only be used when explicitly requested |
| 4399 | | if test "x$enable_dependency_tracking" = xyes; then |
| 4400 | | continue |
| 4401 | | else |
| 4402 | | break |
| 4403 | | fi |
| 4404 | | ;; |
| 4405 | | none) break ;; |
| 4406 | | esac |
| 4407 | | # We check with `-c' and `-o' for the sake of the "dashmstdout" |
| 4408 | | # mode. It turns out that the SunPro C++ compiler does not properly |
| 4409 | | # handle `-M -o', and we need to detect this. |
| 4410 | | if depmode=$depmode \ |
| 4411 | | source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \ |
| 4412 | | depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ |
| 4413 | | $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \ |
| 4414 | | >/dev/null 2>conftest.err && |
| 4415 | | grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && |
| 4416 | | grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && |
| 4417 | | grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 && |
| 4418 | | ${MAKE-make} -s -f confmf > /dev/null 2>&1; then |
| 4419 | | # icc doesn't choke on unknown options, it will just issue warnings |
| 4420 | | # or remarks (even with -Werror). So we grep stderr for any message |
| 4421 | | # that says an option was ignored or not supported. |
| 4422 | | # When given -MP, icc 7.0 and 7.1 complain thusly: |
| 4423 | | # icc: Command line warning: ignoring option '-M'; no argument required |
| 4424 | | # The diagnosis changed in icc 8.0: |
| 4425 | | # icc: Command line remark: option '-MP' not supported |
| 4426 | | if (grep 'ignoring option' conftest.err || |
| 4427 | | grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else |
| 4428 | | am_cv_CC_dependencies_compiler_type=$depmode |
| 4429 | | break |
| 4430 | | fi |
| 4431 | | fi |
| 4432 | | done |
| 4433 | | |
| 4434 | | cd .. |
| 4435 | | rm -rf conftest.dir |
| 4436 | | else |
| 4437 | | am_cv_CC_dependencies_compiler_type=none |
| 4438 | | fi |
| 4439 | | |
| 4440 | | fi |
| 4441 | | { echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5 |
| 4442 | | echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6; } |
| 4443 | | CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type |
| 4444 | | |
| 4445 | | if |
| 4446 | | test "x$enable_dependency_tracking" != xno \ |
| 4447 | | && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then |
| 4448 | | am__fastdepCC_TRUE= |
| 4449 | | am__fastdepCC_FALSE='#' |
| 4450 | | else |
| 4451 | | am__fastdepCC_TRUE='#' |
| 4452 | | am__fastdepCC_FALSE= |
| 4453 | | fi |
| 4454 | | |
| 4455 | | |
| 4456 | | ac_ext=c |
| 4457 | | ac_cpp='$CPP $CPPFLAGS' |
| 4458 | | ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' |
| 4459 | | ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' |
| 4460 | | ac_compiler_gnu=$ac_cv_c_compiler_gnu |
| 4461 | | if test -n "$ac_tool_prefix"; then |
| 4462 | | # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. |
| 4463 | | set dummy ${ac_tool_prefix}gcc; ac_word=$2 |
| 4464 | | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| 4465 | | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| 4466 | | if test "${ac_cv_prog_CC+set}" = set; then |
| 4467 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 4468 | | else |
| 4469 | | if test -n "$CC"; then |
| 4470 | | ac_cv_prog_CC="$CC" # Let the user override the test. |
| 4471 | | else |
| 4472 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 4473 | | for as_dir in $PATH |
| 4474 | | do |
| 4475 | | IFS=$as_save_IFS |
| 4476 | | test -z "$as_dir" && as_dir=. |
| 4477 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 4478 | | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| 4479 | | ac_cv_prog_CC="${ac_tool_prefix}gcc" |
| 4480 | | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| 4481 | | break 2 |
| 4482 | | fi |
| 4483 | | done |
| 4484 | | done |
| 4485 | | IFS=$as_save_IFS |
| 4486 | | |
| 4487 | | fi |
| 4488 | | fi |
| 4489 | | CC=$ac_cv_prog_CC |
| 4490 | | if test -n "$CC"; then |
| 4491 | | { echo "$as_me:$LINENO: result: $CC" >&5 |
| 4492 | | echo "${ECHO_T}$CC" >&6; } |
| 4493 | | else |
| 4494 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 4495 | | echo "${ECHO_T}no" >&6; } |
| 4496 | | fi |
| 4497 | | |
| 4498 | | |
| 4499 | | fi |
| 4500 | | if test -z "$ac_cv_prog_CC"; then |
| 4501 | | ac_ct_CC=$CC |
| 4502 | | # Extract the first word of "gcc", so it can be a program name with args. |
| 4503 | | set dummy gcc; ac_word=$2 |
| 4504 | | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| 4505 | | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| 4506 | | if test "${ac_cv_prog_ac_ct_CC+set}" = set; then |
| 4507 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 4508 | | else |
| 4509 | | if test -n "$ac_ct_CC"; then |
| 4510 | | ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. |
| 4511 | | else |
| 4512 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 4513 | | for as_dir in $PATH |
| 4514 | | do |
| 4515 | | IFS=$as_save_IFS |
| 4516 | | test -z "$as_dir" && as_dir=. |
| 4517 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 4518 | | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| 4519 | | ac_cv_prog_ac_ct_CC="gcc" |
| 4520 | | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| 4521 | | break 2 |
| 4522 | | fi |
| 4523 | | done |
| 4524 | | done |
| 4525 | | IFS=$as_save_IFS |
| 4526 | | |
| 4527 | | fi |
| 4528 | | fi |
| 4529 | | ac_ct_CC=$ac_cv_prog_ac_ct_CC |
| 4530 | | if test -n "$ac_ct_CC"; then |
| 4531 | | { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5 |
| 4532 | | echo "${ECHO_T}$ac_ct_CC" >&6; } |
| 4533 | | else |
| 4534 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 4535 | | echo "${ECHO_T}no" >&6; } |
| 4536 | | fi |
| 4537 | | |
| 4538 | | if test "x$ac_ct_CC" = x; then |
| 4539 | | CC="" |
| 4540 | | else |
| 4541 | | case $cross_compiling:$ac_tool_warned in |
| 4542 | | yes:) |
| 4543 | | { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools |
| 4544 | | whose name does not start with the host triplet. If you think this |
| 4545 | | configuration is useful to you, please write to autoconf@gnu.org." >&5 |
| 4546 | | echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools |
| 4547 | | whose name does not start with the host triplet. If you think this |
| 4548 | | configuration is useful to you, please write to autoconf@gnu.org." >&2;} |
| 4549 | | ac_tool_warned=yes ;; |
| 4550 | | esac |
| 4551 | | CC=$ac_ct_CC |
| 4552 | | fi |
| 4553 | | else |
| 4554 | | CC="$ac_cv_prog_CC" |
| 4555 | | fi |
| 4556 | | |
| 4557 | | if test -z "$CC"; then |
| 4558 | | if test -n "$ac_tool_prefix"; then |
| 4559 | | # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. |
| 4560 | | set dummy ${ac_tool_prefix}cc; ac_word=$2 |
| 4561 | | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| 4562 | | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| 4563 | | if test "${ac_cv_prog_CC+set}" = set; then |
| 4564 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 4565 | | else |
| 4566 | | if test -n "$CC"; then |
| 4567 | | ac_cv_prog_CC="$CC" # Let the user override the test. |
| 4568 | | else |
| 4569 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 4570 | | for as_dir in $PATH |
| 4571 | | do |
| 4572 | | IFS=$as_save_IFS |
| 4573 | | test -z "$as_dir" && as_dir=. |
| 4574 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 4575 | | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| 4576 | | ac_cv_prog_CC="${ac_tool_prefix}cc" |
| 4577 | | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| 4578 | | break 2 |
| 4579 | | fi |
| 4580 | | done |
| 4581 | | done |
| 4582 | | IFS=$as_save_IFS |
| 4583 | | |
| 4584 | | fi |
| 4585 | | fi |
| 4586 | | CC=$ac_cv_prog_CC |
| 4587 | | if test -n "$CC"; then |
| 4588 | | { echo "$as_me:$LINENO: result: $CC" >&5 |
| 4589 | | echo "${ECHO_T}$CC" >&6; } |
| 4590 | | else |
| 4591 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 4592 | | echo "${ECHO_T}no" >&6; } |
| 4593 | | fi |
| 4594 | | |
| 4595 | | |
| 4596 | | fi |
| 4597 | | fi |
| 4598 | | if test -z "$CC"; then |
| 4599 | | # Extract the first word of "cc", so it can be a program name with args. |
| 4600 | | set dummy cc; ac_word=$2 |
| 4601 | | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| 4602 | | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| 4603 | | if test "${ac_cv_prog_CC+set}" = set; then |
| 4604 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 4605 | | else |
| 4606 | | if test -n "$CC"; then |
| 4607 | | ac_cv_prog_CC="$CC" # Let the user override the test. |
| 4608 | | else |
| 4609 | | ac_prog_rejected=no |
| 4610 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 4611 | | for as_dir in $PATH |
| 4612 | | do |
| 4613 | | IFS=$as_save_IFS |
| 4614 | | test -z "$as_dir" && as_dir=. |
| 4615 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 4616 | | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| 4617 | | if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then |
| 4618 | | ac_prog_rejected=yes |
| 4619 | | continue |
| 4620 | | fi |
| 4621 | | ac_cv_prog_CC="cc" |
| 4622 | | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| 4623 | | break 2 |
| 4624 | | fi |
| 4625 | | done |
| 4626 | | done |
| 4627 | | IFS=$as_save_IFS |
| 4628 | | |
| 4629 | | if test $ac_prog_rejected = yes; then |
| 4630 | | # We found a bogon in the path, so make sure we never use it. |
| 4631 | | set dummy $ac_cv_prog_CC |
| 4632 | | shift |
| 4633 | | if test $# != 0; then |
| 4634 | | # We chose a different compiler from the bogus one. |
| 4635 | | # However, it has the same basename, so the bogon will be chosen |
| 4636 | | # first if we set CC to just the basename; use the full file name. |
| 4637 | | shift |
| 4638 | | ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" |
| 4639 | | fi |
| 4640 | | fi |
| 4641 | | fi |
| 4642 | | fi |
| 4643 | | CC=$ac_cv_prog_CC |
| 4644 | | if test -n "$CC"; then |
| 4645 | | { echo "$as_me:$LINENO: result: $CC" >&5 |
| 4646 | | echo "${ECHO_T}$CC" >&6; } |
| 4647 | | else |
| 4648 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 4649 | | echo "${ECHO_T}no" >&6; } |
| 4650 | | fi |
| 4651 | | |
| 4652 | | |
| 4653 | | fi |
| 4654 | | if test -z "$CC"; then |
| 4655 | | if test -n "$ac_tool_prefix"; then |
| 4656 | | for ac_prog in cl.exe |
| 4657 | | do |
| 4658 | | # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. |
| 4659 | | set dummy $ac_tool_prefix$ac_prog; ac_word=$2 |
| 4660 | | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| 4661 | | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| 4662 | | if test "${ac_cv_prog_CC+set}" = set; then |
| 4663 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 4664 | | else |
| 4665 | | if test -n "$CC"; then |
| 4666 | | ac_cv_prog_CC="$CC" # Let the user override the test. |
| 4667 | | else |
| 4668 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 4669 | | for as_dir in $PATH |
| 4670 | | do |
| 4671 | | IFS=$as_save_IFS |
| 4672 | | test -z "$as_dir" && as_dir=. |
| 4673 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 4674 | | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| 4675 | | ac_cv_prog_CC="$ac_tool_prefix$ac_prog" |
| 4676 | | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| 4677 | | break 2 |
| 4678 | | fi |
| 4679 | | done |
| 4680 | | done |
| 4681 | | IFS=$as_save_IFS |
| 4682 | | |
| 4683 | | fi |
| 4684 | | fi |
| 4685 | | CC=$ac_cv_prog_CC |
| 4686 | | if test -n "$CC"; then |
| 4687 | | { echo "$as_me:$LINENO: result: $CC" >&5 |
| 4688 | | echo "${ECHO_T}$CC" >&6; } |
| 4689 | | else |
| 4690 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 4691 | | echo "${ECHO_T}no" >&6; } |
| 4692 | | fi |
| 4693 | | |
| 4694 | | |
| 4695 | | test -n "$CC" && break |
| 4696 | | done |
| 4697 | | fi |
| 4698 | | if test -z "$CC"; then |
| 4699 | | ac_ct_CC=$CC |
| 4700 | | for ac_prog in cl.exe |
| 4701 | | do |
| 4702 | | # Extract the first word of "$ac_prog", so it can be a program name with args. |
| 4703 | | set dummy $ac_prog; ac_word=$2 |
| 4704 | | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| 4705 | | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| 4706 | | if test "${ac_cv_prog_ac_ct_CC+set}" = set; then |
| 4707 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 4708 | | else |
| 4709 | | if test -n "$ac_ct_CC"; then |
| 4710 | | ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. |
| 4711 | | else |
| 4712 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 4713 | | for as_dir in $PATH |
| 4714 | | do |
| 4715 | | IFS=$as_save_IFS |
| 4716 | | test -z "$as_dir" && as_dir=. |
| 4717 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 4718 | | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| 4719 | | ac_cv_prog_ac_ct_CC="$ac_prog" |
| 4720 | | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| 4721 | | break 2 |
| 4722 | | fi |
| 4723 | | done |
| 4724 | | done |
| 4725 | | IFS=$as_save_IFS |
| 4726 | | |
| 4727 | | fi |
| 4728 | | fi |
| 4729 | | ac_ct_CC=$ac_cv_prog_ac_ct_CC |
| 4730 | | if test -n "$ac_ct_CC"; then |
| 4731 | | { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5 |
| 4732 | | echo "${ECHO_T}$ac_ct_CC" >&6; } |
| 4733 | | else |
| 4734 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 4735 | | echo "${ECHO_T}no" >&6; } |
| 4736 | | fi |
| 4737 | | |
| 4738 | | |
| 4739 | | test -n "$ac_ct_CC" && break |
| 4740 | | done |
| 4741 | | |
| 4742 | | if test "x$ac_ct_CC" = x; then |
| 4743 | | CC="" |
| 4744 | | else |
| 4745 | | case $cross_compiling:$ac_tool_warned in |
| 4746 | | yes:) |
| 4747 | | { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools |
| 4748 | | whose name does not start with the host triplet. If you think this |
| 4749 | | configuration is useful to you, please write to autoconf@gnu.org." >&5 |
| 4750 | | echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools |
| 4751 | | whose name does not start with the host triplet. If you think this |
| 4752 | | configuration is useful to you, please write to autoconf@gnu.org." >&2;} |
| 4753 | | ac_tool_warned=yes ;; |
| 4754 | | esac |
| 4755 | | CC=$ac_ct_CC |
| 4756 | | fi |
| 4757 | | fi |
| 4758 | | |
| 4759 | | fi |
| 4760 | | |
| 4761 | | |
| 4762 | | test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH |
| 4763 | | See \`config.log' for more details." >&5 |
| 4764 | | echo "$as_me: error: no acceptable C compiler found in \$PATH |
| 4765 | | See \`config.log' for more details." >&2;} |
| 4766 | | { (exit 1); exit 1; }; } |
| 4767 | | |
| 4768 | | # Provide some information about the compiler. |
| 4769 | | echo "$as_me:$LINENO: checking for C compiler version" >&5 |
| 4770 | | ac_compiler=`set X $ac_compile; echo $2` |
| 4771 | | { (ac_try="$ac_compiler --version >&5" |
| 4772 | | case "(($ac_try" in |
| 4773 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 4774 | | *) ac_try_echo=$ac_try;; |
| 4775 | | esac |
| 4776 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 4777 | | (eval "$ac_compiler --version >&5") 2>&5 |
| 4778 | | ac_status=$? |
| 4779 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 4780 | | (exit $ac_status); } |
| 4781 | | { (ac_try="$ac_compiler -v >&5" |
| 4782 | | case "(($ac_try" in |
| 4783 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 4784 | | *) ac_try_echo=$ac_try;; |
| 4785 | | esac |
| 4786 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 4787 | | (eval "$ac_compiler -v >&5") 2>&5 |
| 4788 | | ac_status=$? |
| 4789 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 4790 | | (exit $ac_status); } |
| 4791 | | { (ac_try="$ac_compiler -V >&5" |
| 4792 | | case "(($ac_try" in |
| 4793 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 4794 | | *) ac_try_echo=$ac_try;; |
| 4795 | | esac |
| 4796 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 4797 | | (eval "$ac_compiler -V >&5") 2>&5 |
| 4798 | | ac_status=$? |
| 4799 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 4800 | | (exit $ac_status); } |
| 4801 | | |
| 4802 | | { echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5 |
| 4803 | | echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; } |
| 4804 | | if test "${ac_cv_c_compiler_gnu+set}" = set; then |
| 4805 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 4806 | | else |
| 4807 | | cat >conftest.$ac_ext <<_ACEOF |
| 4808 | | /* confdefs.h. */ |
| 4809 | | _ACEOF |
| 4810 | | cat confdefs.h >>conftest.$ac_ext |
| 4811 | | cat >>conftest.$ac_ext <<_ACEOF |
| 4812 | | /* end confdefs.h. */ |
| 4813 | | |
| 4814 | | int |
| 4815 | | main () |
| 4816 | | { |
| 4817 | | #ifndef __GNUC__ |
| 4818 | | choke me |
| 4819 | | #endif |
| 4820 | | |
| 4821 | | ; |
| 4822 | | return 0; |
| 4823 | | } |
| 4824 | | _ACEOF |
| 4825 | | rm -f conftest.$ac_objext |
| 4826 | | if { (ac_try="$ac_compile" |
| 4827 | | case "(($ac_try" in |
| 4828 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 4829 | | *) ac_try_echo=$ac_try;; |
| 4830 | | esac |
| 4831 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 4832 | | (eval "$ac_compile") 2>conftest.er1 |
| 4833 | | ac_status=$? |
| 4834 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 4835 | | rm -f conftest.er1 |
| 4836 | | cat conftest.err >&5 |
| 4837 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 4838 | | (exit $ac_status); } && { |
| 4839 | | test -z "$ac_c_werror_flag" || |
| 4840 | | test ! -s conftest.err |
| 4841 | | } && test -s conftest.$ac_objext; then |
| 4842 | | ac_compiler_gnu=yes |
| 4843 | | else |
| 4844 | | echo "$as_me: failed program was:" >&5 |
| 4845 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 4846 | | |
| 4847 | | ac_compiler_gnu=no |
| 4848 | | fi |
| 4849 | | |
| 4850 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 4851 | | ac_cv_c_compiler_gnu=$ac_compiler_gnu |
| 4852 | | |
| 4853 | | fi |
| 4854 | | { echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5 |
| 4855 | | echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; } |
| 4856 | | GCC=`test $ac_compiler_gnu = yes && echo yes` |
| 4857 | | ac_test_CFLAGS=${CFLAGS+set} |
| 4858 | | ac_save_CFLAGS=$CFLAGS |
| 4859 | | { echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5 |
| 4860 | | echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; } |
| 4861 | | if test "${ac_cv_prog_cc_g+set}" = set; then |
| 4862 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 4863 | | else |
| 4864 | | ac_save_c_werror_flag=$ac_c_werror_flag |
| 4865 | | ac_c_werror_flag=yes |
| 4866 | | ac_cv_prog_cc_g=no |
| 4867 | | CFLAGS="-g" |
| 4868 | | cat >conftest.$ac_ext <<_ACEOF |
| 4869 | | /* confdefs.h. */ |
| 4870 | | _ACEOF |
| 4871 | | cat confdefs.h >>conftest.$ac_ext |
| 4872 | | cat >>conftest.$ac_ext <<_ACEOF |
| 4873 | | /* end confdefs.h. */ |
| 4874 | | |
| 4875 | | int |
| 4876 | | main () |
| 4877 | | { |
| 4878 | | |
| 4879 | | ; |
| 4880 | | return 0; |
| 4881 | | } |
| 4882 | | _ACEOF |
| 4883 | | rm -f conftest.$ac_objext |
| 4884 | | if { (ac_try="$ac_compile" |
| 4885 | | case "(($ac_try" in |
| 4886 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 4887 | | *) ac_try_echo=$ac_try;; |
| 4888 | | esac |
| 4889 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 4890 | | (eval "$ac_compile") 2>conftest.er1 |
| 4891 | | ac_status=$? |
| 4892 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 4893 | | rm -f conftest.er1 |
| 4894 | | cat conftest.err >&5 |
| 4895 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 4896 | | (exit $ac_status); } && { |
| 4897 | | test -z "$ac_c_werror_flag" || |
| 4898 | | test ! -s conftest.err |
| 4899 | | } && test -s conftest.$ac_objext; then |
| 4900 | | ac_cv_prog_cc_g=yes |
| 4901 | | else |
| 4902 | | echo "$as_me: failed program was:" >&5 |
| 4903 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 4904 | | |
| 4905 | | CFLAGS="" |
| 4906 | | cat >conftest.$ac_ext <<_ACEOF |
| 4907 | | /* confdefs.h. */ |
| 4908 | | _ACEOF |
| 4909 | | cat confdefs.h >>conftest.$ac_ext |
| 4910 | | cat >>conftest.$ac_ext <<_ACEOF |
| 4911 | | /* end confdefs.h. */ |
| 4912 | | |
| 4913 | | int |
| 4914 | | main () |
| 4915 | | { |
| 4916 | | |
| 4917 | | ; |
| 4918 | | return 0; |
| 4919 | | } |
| 4920 | | _ACEOF |
| 4921 | | rm -f conftest.$ac_objext |
| 4922 | | if { (ac_try="$ac_compile" |
| 4923 | | case "(($ac_try" in |
| 4924 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 4925 | | *) ac_try_echo=$ac_try;; |
| 4926 | | esac |
| 4927 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 4928 | | (eval "$ac_compile") 2>conftest.er1 |
| 4929 | | ac_status=$? |
| 4930 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 4931 | | rm -f conftest.er1 |
| 4932 | | cat conftest.err >&5 |
| 4933 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 4934 | | (exit $ac_status); } && { |
| 4935 | | test -z "$ac_c_werror_flag" || |
| 4936 | | test ! -s conftest.err |
| 4937 | | } && test -s conftest.$ac_objext; then |
| 4938 | | : |
| 4939 | | else |
| 4940 | | echo "$as_me: failed program was:" >&5 |
| 4941 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 4942 | | |
| 4943 | | ac_c_werror_flag=$ac_save_c_werror_flag |
| 4944 | | CFLAGS="-g" |
| 4945 | | cat >conftest.$ac_ext <<_ACEOF |
| 4946 | | /* confdefs.h. */ |
| 4947 | | _ACEOF |
| 4948 | | cat confdefs.h >>conftest.$ac_ext |
| 4949 | | cat >>conftest.$ac_ext <<_ACEOF |
| 4950 | | /* end confdefs.h. */ |
| 4951 | | |
| 4952 | | int |
| 4953 | | main () |
| 4954 | | { |
| 4955 | | |
| 4956 | | ; |
| 4957 | | return 0; |
| 4958 | | } |
| 4959 | | _ACEOF |
| 4960 | | rm -f conftest.$ac_objext |
| 4961 | | if { (ac_try="$ac_compile" |
| 4962 | | case "(($ac_try" in |
| 4963 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 4964 | | *) ac_try_echo=$ac_try;; |
| 4965 | | esac |
| 4966 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 4967 | | (eval "$ac_compile") 2>conftest.er1 |
| 4968 | | ac_status=$? |
| 4969 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 4970 | | rm -f conftest.er1 |
| 4971 | | cat conftest.err >&5 |
| 4972 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 4973 | | (exit $ac_status); } && { |
| 4974 | | test -z "$ac_c_werror_flag" || |
| 4975 | | test ! -s conftest.err |
| 4976 | | } && test -s conftest.$ac_objext; then |
| 4977 | | ac_cv_prog_cc_g=yes |
| 4978 | | else |
| 4979 | | echo "$as_me: failed program was:" >&5 |
| 4980 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 4981 | | |
| 4982 | | |
| 4983 | | fi |
| 4984 | | |
| 4985 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 4986 | | fi |
| 4987 | | |
| 4988 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 4989 | | fi |
| 4990 | | |
| 4991 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 4992 | | ac_c_werror_flag=$ac_save_c_werror_flag |
| 4993 | | fi |
| 4994 | | { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5 |
| 4995 | | echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; } |
| 4996 | | if test "$ac_test_CFLAGS" = set; then |
| 4997 | | CFLAGS=$ac_save_CFLAGS |
| 4998 | | elif test $ac_cv_prog_cc_g = yes; then |
| 4999 | | if test "$GCC" = yes; then |
| 5000 | | CFLAGS="-g -O2" |
| 5001 | | else |
| 5002 | | CFLAGS="-g" |
| 5003 | | fi |
| 5004 | | else |
| 5005 | | if test "$GCC" = yes; then |
| 5006 | | CFLAGS="-O2" |
| 5007 | | else |
| 5008 | | CFLAGS= |
| 5009 | | fi |
| 5010 | | fi |
| 5011 | | { echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5 |
| 5012 | | echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; } |
| 5013 | | if test "${ac_cv_prog_cc_c89+set}" = set; then |
| 5014 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 5015 | | else |
| 5016 | | ac_cv_prog_cc_c89=no |
| 5017 | | ac_save_CC=$CC |
| 5018 | | cat >conftest.$ac_ext <<_ACEOF |
| 5019 | | /* confdefs.h. */ |
| 5020 | | _ACEOF |
| 5021 | | cat confdefs.h >>conftest.$ac_ext |
| 5022 | | cat >>conftest.$ac_ext <<_ACEOF |
| 5023 | | /* end confdefs.h. */ |
| 5024 | | #include <stdarg.h> |
| 5025 | | #include <stdio.h> |
| 5026 | | #include <sys/types.h> |
| 5027 | | #include <sys/stat.h> |
| 5028 | | /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ |
| 5029 | | struct buf { int x; }; |
| 5030 | | FILE * (*rcsopen) (struct buf *, struct stat *, int); |
| 5031 | | static char *e (p, i) |
| 5032 | | char **p; |
| 5033 | | int i; |
| 5034 | | { |
| 5035 | | return p[i]; |
| 5036 | | } |
| 5037 | | static char *f (char * (*g) (char **, int), char **p, ...) |
| 5038 | | { |
| 5039 | | char *s; |
| 5040 | | va_list v; |
| 5041 | | va_start (v,p); |
| 5042 | | s = g (p, va_arg (v,int)); |
| 5043 | | va_end (v); |
| 5044 | | return s; |
| 5045 | | } |
| 5046 | | |
| 5047 | | /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has |
| 5048 | | function prototypes and stuff, but not '\xHH' hex character constants. |
| 5049 | | These don't provoke an error unfortunately, instead are silently treated |
| 5050 | | as 'x'. The following induces an error, until -std is added to get |
| 5051 | | proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an |
| 5052 | | array size at least. It's necessary to write '\x00'==0 to get something |
| 5053 | | that's true only with -std. */ |
| 5054 | | int osf4_cc_array ['\x00' == 0 ? 1 : -1]; |
| 5055 | | |
| 5056 | | /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters |
| 5057 | | inside strings and character constants. */ |
| 5058 | | #define FOO(x) 'x' |
| 5059 | | int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; |
| 5060 | | |
| 5061 | | int test (int i, double x); |
| 5062 | | struct s1 {int (*f) (int a);}; |
| 5063 | | struct s2 {int (*f) (double a);}; |
| 5064 | | int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); |
| 5065 | | int argc; |
| 5066 | | char **argv; |
| 5067 | | int |
| 5068 | | main () |
| 5069 | | { |
| 5070 | | return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; |
| 5071 | | ; |
| 5072 | | return 0; |
| 5073 | | } |
| 5074 | | _ACEOF |
| 5075 | | for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ |
| 5076 | | -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" |
| 5077 | | do |
| 5078 | | CC="$ac_save_CC $ac_arg" |
| 5079 | | rm -f conftest.$ac_objext |
| 5080 | | if { (ac_try="$ac_compile" |
| 5081 | | case "(($ac_try" in |
| 5082 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 5083 | | *) ac_try_echo=$ac_try;; |
| 5084 | | esac |
| 5085 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 5086 | | (eval "$ac_compile") 2>conftest.er1 |
| 5087 | | ac_status=$? |
| 5088 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 5089 | | rm -f conftest.er1 |
| 5090 | | cat conftest.err >&5 |
| 5091 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 5092 | | (exit $ac_status); } && { |
| 5093 | | test -z "$ac_c_werror_flag" || |
| 5094 | | test ! -s conftest.err |
| 5095 | | } && test -s conftest.$ac_objext; then |
| 5096 | | ac_cv_prog_cc_c89=$ac_arg |
| 5097 | | else |
| 5098 | | echo "$as_me: failed program was:" >&5 |
| 5099 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 5100 | | |
| 5101 | | |
| 5102 | | fi |
| 5103 | | |
| 5104 | | rm -f core conftest.err conftest.$ac_objext |
| 5105 | | test "x$ac_cv_prog_cc_c89" != "xno" && break |
| 5106 | | done |
| 5107 | | rm -f conftest.$ac_ext |
| 5108 | | CC=$ac_save_CC |
| 5109 | | |
| 5110 | | fi |
| 5111 | | # AC_CACHE_VAL |
| 5112 | | case "x$ac_cv_prog_cc_c89" in |
| 5113 | | x) |
| 5114 | | { echo "$as_me:$LINENO: result: none needed" >&5 |
| 5115 | | echo "${ECHO_T}none needed" >&6; } ;; |
| 5116 | | xno) |
| 5117 | | { echo "$as_me:$LINENO: result: unsupported" >&5 |
| 5118 | | echo "${ECHO_T}unsupported" >&6; } ;; |
| 5119 | | *) |
| 5120 | | CC="$CC $ac_cv_prog_cc_c89" |
| 5121 | | { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5 |
| 5122 | | echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;; |
| 5123 | | esac |
| 5124 | | |
| 5125 | | |
| 5126 | | ac_ext=c |
| 5127 | | ac_cpp='$CPP $CPPFLAGS' |
| 5128 | | ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' |
| 5129 | | ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' |
| 5130 | | ac_compiler_gnu=$ac_cv_c_compiler_gnu |
| 5131 | | |
| 5132 | | depcc="$CC" am_compiler_list= |
| 5133 | | |
| 5134 | | { echo "$as_me:$LINENO: checking dependency style of $depcc" >&5 |
| 5135 | | echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6; } |
| 5136 | | if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then |
| 5137 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 5138 | | else |
| 5139 | | if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then |
| 5140 | | # We make a subdir and do the tests there. Otherwise we can end up |
| 5141 | | # making bogus files that we don't know about and never remove. For |
| 5142 | | # instance it was reported that on HP-UX the gcc test will end up |
| 5143 | | # making a dummy file named `D' -- because `-MD' means `put the output |
| 5144 | | # in D'. |
| 5145 | | mkdir conftest.dir |
| 5146 | | # Copy depcomp to subdir because otherwise we won't find it if we're |
| 5147 | | # using a relative directory. |
| 5148 | | cp "$am_depcomp" conftest.dir |
| 5149 | | cd conftest.dir |
| 5150 | | # We will build objects and dependencies in a subdirectory because |
| 5151 | | # it helps to detect inapplicable dependency modes. For instance |
| 5152 | | # both Tru64's cc and ICC support -MD to output dependencies as a |
| 5153 | | # side effect of compilation, but ICC will put the dependencies in |
| 5154 | | # the current directory while Tru64 will put them in the object |
| 5155 | | # directory. |
| 5156 | | mkdir sub |
| 5157 | | |
| 5158 | | am_cv_CC_dependencies_compiler_type=none |
| 5159 | | if test "$am_compiler_list" = ""; then |
| 5160 | | am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` |
| 5161 | | fi |
| 5162 | | for depmode in $am_compiler_list; do |
| 5163 | | # Setup a source with many dependencies, because some compilers |
| 5164 | | # like to wrap large dependency lists on column 80 (with \), and |
| 5165 | | # we should not choose a depcomp mode which is confused by this. |
| 5166 | | # |
| 5167 | | # We need to recreate these files for each test, as the compiler may |
| 5168 | | # overwrite some of them when testing with obscure command lines. |
| 5169 | | # This happens at least with the AIX C compiler. |
| 5170 | | : > sub/conftest.c |
| 5171 | | for i in 1 2 3 4 5 6; do |
| 5172 | | echo '#include "conftst'$i'.h"' >> sub/conftest.c |
| 5173 | | # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with |
| 5174 | | # Solaris 8's {/usr,}/bin/sh. |
| 5175 | | touch sub/conftst$i.h |
| 5176 | | done |
| 5177 | | echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf |
| 5178 | | |
| 5179 | | case $depmode in |
| 5180 | | nosideeffect) |
| 5181 | | # after this tag, mechanisms are not by side-effect, so they'll |
| 5182 | | # only be used when explicitly requested |
| 5183 | | if test "x$enable_dependency_tracking" = xyes; then |
| 5184 | | continue |
| 5185 | | else |
| 5186 | | break |
| 5187 | | fi |
| 5188 | | ;; |
| 5189 | | none) break ;; |
| 5190 | | esac |
| 5191 | | # We check with `-c' and `-o' for the sake of the "dashmstdout" |
| 5192 | | # mode. It turns out that the SunPro C++ compiler does not properly |
| 5193 | | # handle `-M -o', and we need to detect this. |
| 5194 | | if depmode=$depmode \ |
| 5195 | | source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \ |
| 5196 | | depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ |
| 5197 | | $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \ |
| 5198 | | >/dev/null 2>conftest.err && |
| 5199 | | grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && |
| 5200 | | grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && |
| 5201 | | grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 && |
| 5202 | | ${MAKE-make} -s -f confmf > /dev/null 2>&1; then |
| 5203 | | # icc doesn't choke on unknown options, it will just issue warnings |
| 5204 | | # or remarks (even with -Werror). So we grep stderr for any message |
| 5205 | | # that says an option was ignored or not supported. |
| 5206 | | # When given -MP, icc 7.0 and 7.1 complain thusly: |
| 5207 | | # icc: Command line warning: ignoring option '-M'; no argument required |
| 5208 | | # The diagnosis changed in icc 8.0: |
| 5209 | | # icc: Command line remark: option '-MP' not supported |
| 5210 | | if (grep 'ignoring option' conftest.err || |
| 5211 | | grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else |
| 5212 | | am_cv_CC_dependencies_compiler_type=$depmode |
| 5213 | | break |
| 5214 | | fi |
| 5215 | | fi |
| 5216 | | done |
| 5217 | | |
| 5218 | | cd .. |
| 5219 | | rm -rf conftest.dir |
| 5220 | | else |
| 5221 | | am_cv_CC_dependencies_compiler_type=none |
| 5222 | | fi |
| 5223 | | |
| 5224 | | fi |
| 5225 | | { echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5 |
| 5226 | | echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6; } |
| 5227 | | CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type |
| 5228 | | |
| 5229 | | if |
| 5230 | | test "x$enable_dependency_tracking" != xno \ |
| 5231 | | && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then |
| 5232 | | am__fastdepCC_TRUE= |
| 5233 | | am__fastdepCC_FALSE='#' |
| 5234 | | else |
| 5235 | | am__fastdepCC_TRUE='#' |
| 5236 | | am__fastdepCC_FALSE= |
| 5237 | | fi |
| 5238 | | |
| 5239 | | |
| 5240 | | |
| 5241 | | am_cv_prog_cc_stdc=$ac_cv_prog_cc_stdc |
| 5242 | | |
| 5243 | | ac_ext=c |
| 5244 | | ac_cpp='$CPP $CPPFLAGS' |
| 5245 | | ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' |
| 5246 | | ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' |
| 5247 | | ac_compiler_gnu=$ac_cv_c_compiler_gnu |
| 5248 | | { echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5 |
| 5249 | | echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6; } |
| 5250 | | # On Suns, sometimes $CPP names a directory. |
| 5251 | | if test -n "$CPP" && test -d "$CPP"; then |
| 5252 | | CPP= |
| 5253 | | fi |
| 5254 | | if test -z "$CPP"; then |
| 5255 | | if test "${ac_cv_prog_CPP+set}" = set; then |
| 5256 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 5257 | | else |
| 5258 | | # Double quotes because CPP needs to be expanded |
| 5259 | | for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" |
| 5260 | | do |
| 5261 | | ac_preproc_ok=false |
| 5262 | | for ac_c_preproc_warn_flag in '' yes |
| 5263 | | do |
| 5264 | | # Use a header file that comes with gcc, so configuring glibc |
| 5265 | | # with a fresh cross-compiler works. |
| 5266 | | # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since |
| 5267 | | # <limits.h> exists even on freestanding compilers. |
| 5268 | | # On the NeXT, cc -E runs the code through the compiler's parser, |
| 5269 | | # not just through cpp. "Syntax error" is here to catch this case. |
| 5270 | | cat >conftest.$ac_ext <<_ACEOF |
| 5271 | | /* confdefs.h. */ |
| 5272 | | _ACEOF |
| 5273 | | cat confdefs.h >>conftest.$ac_ext |
| 5274 | | cat >>conftest.$ac_ext <<_ACEOF |
| 5275 | | /* end confdefs.h. */ |
| 5276 | | #ifdef __STDC__ |
| 5277 | | # include <limits.h> |
| 5278 | | #else |
| 5279 | | # include <assert.h> |
| 5280 | | #endif |
| 5281 | | Syntax error |
| 5282 | | _ACEOF |
| 5283 | | if { (ac_try="$ac_cpp conftest.$ac_ext" |
| 5284 | | case "(($ac_try" in |
| 5285 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 5286 | | *) ac_try_echo=$ac_try;; |
| 5287 | | esac |
| 5288 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 5289 | | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 |
| 5290 | | ac_status=$? |
| 5291 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 5292 | | rm -f conftest.er1 |
| 5293 | | cat conftest.err >&5 |
| 5294 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 5295 | | (exit $ac_status); } >/dev/null && { |
| 5296 | | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| 5297 | | test ! -s conftest.err |
| 5298 | | }; then |
| 5299 | | : |
| 5300 | | else |
| 5301 | | echo "$as_me: failed program was:" >&5 |
| 5302 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 5303 | | |
| 5304 | | # Broken: fails on valid input. |
| 5305 | | continue |
| 5306 | | fi |
| 5307 | | |
| 5308 | | rm -f conftest.err conftest.$ac_ext |
| 5309 | | |
| 5310 | | # OK, works on sane cases. Now check whether nonexistent headers |
| 5311 | | # can be detected and how. |
| 5312 | | cat >conftest.$ac_ext <<_ACEOF |
| 5313 | | /* confdefs.h. */ |
| 5314 | | _ACEOF |
| 5315 | | cat confdefs.h >>conftest.$ac_ext |
| 5316 | | cat >>conftest.$ac_ext <<_ACEOF |
| 5317 | | /* end confdefs.h. */ |
| 5318 | | #include <ac_nonexistent.h> |
| 5319 | | _ACEOF |
| 5320 | | if { (ac_try="$ac_cpp conftest.$ac_ext" |
| 5321 | | case "(($ac_try" in |
| 5322 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 5323 | | *) ac_try_echo=$ac_try;; |
| 5324 | | esac |
| 5325 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 5326 | | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 |
| 5327 | | ac_status=$? |
| 5328 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 5329 | | rm -f conftest.er1 |
| 5330 | | cat conftest.err >&5 |
| 5331 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 5332 | | (exit $ac_status); } >/dev/null && { |
| 5333 | | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| 5334 | | test ! -s conftest.err |
| 5335 | | }; then |
| 5336 | | # Broken: success on invalid input. |
| 5337 | | continue |
| 5338 | | else |
| 5339 | | echo "$as_me: failed program was:" >&5 |
| 5340 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 5341 | | |
| 5342 | | # Passes both tests. |
| 5343 | | ac_preproc_ok=: |
| 5344 | | break |
| 5345 | | fi |
| 5346 | | |
| 5347 | | rm -f conftest.err conftest.$ac_ext |
| 5348 | | |
| 5349 | | done |
| 5350 | | # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. |
| 5351 | | rm -f conftest.err conftest.$ac_ext |
| 5352 | | if $ac_preproc_ok; then |
| 5353 | | break |
| 5354 | | fi |
| 5355 | | |
| 5356 | | done |
| 5357 | | ac_cv_prog_CPP=$CPP |
| 5358 | | |
| 5359 | | fi |
| 5360 | | CPP=$ac_cv_prog_CPP |
| 5361 | | else |
| 5362 | | ac_cv_prog_CPP=$CPP |
| 5363 | | fi |
| 5364 | | { echo "$as_me:$LINENO: result: $CPP" >&5 |
| 5365 | | echo "${ECHO_T}$CPP" >&6; } |
| 5366 | | ac_preproc_ok=false |
| 5367 | | for ac_c_preproc_warn_flag in '' yes |
| 5368 | | do |
| 5369 | | # Use a header file that comes with gcc, so configuring glibc |
| 5370 | | # with a fresh cross-compiler works. |
| 5371 | | # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since |
| 5372 | | # <limits.h> exists even on freestanding compilers. |
| 5373 | | # On the NeXT, cc -E runs the code through the compiler's parser, |
| 5374 | | # not just through cpp. "Syntax error" is here to catch this case. |
| 5375 | | cat >conftest.$ac_ext <<_ACEOF |
| 5376 | | /* confdefs.h. */ |
| 5377 | | _ACEOF |
| 5378 | | cat confdefs.h >>conftest.$ac_ext |
| 5379 | | cat >>conftest.$ac_ext <<_ACEOF |
| 5380 | | /* end confdefs.h. */ |
| 5381 | | #ifdef __STDC__ |
| 5382 | | # include <limits.h> |
| 5383 | | #else |
| 5384 | | # include <assert.h> |
| 5385 | | #endif |
| 5386 | | Syntax error |
| 5387 | | _ACEOF |
| 5388 | | if { (ac_try="$ac_cpp conftest.$ac_ext" |
| 5389 | | case "(($ac_try" in |
| 5390 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 5391 | | *) ac_try_echo=$ac_try;; |
| 5392 | | esac |
| 5393 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 5394 | | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 |
| 5395 | | ac_status=$? |
| 5396 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 5397 | | rm -f conftest.er1 |
| 5398 | | cat conftest.err >&5 |
| 5399 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 5400 | | (exit $ac_status); } >/dev/null && { |
| 5401 | | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| 5402 | | test ! -s conftest.err |
| 5403 | | }; then |
| 5404 | | : |
| 5405 | | else |
| 5406 | | echo "$as_me: failed program was:" >&5 |
| 5407 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 5408 | | |
| 5409 | | # Broken: fails on valid input. |
| 5410 | | continue |
| 5411 | | fi |
| 5412 | | |
| 5413 | | rm -f conftest.err conftest.$ac_ext |
| 5414 | | |
| 5415 | | # OK, works on sane cases. Now check whether nonexistent headers |
| 5416 | | # can be detected and how. |
| 5417 | | cat >conftest.$ac_ext <<_ACEOF |
| 5418 | | /* confdefs.h. */ |
| 5419 | | _ACEOF |
| 5420 | | cat confdefs.h >>conftest.$ac_ext |
| 5421 | | cat >>conftest.$ac_ext <<_ACEOF |
| 5422 | | /* end confdefs.h. */ |
| 5423 | | #include <ac_nonexistent.h> |
| 5424 | | _ACEOF |
| 5425 | | if { (ac_try="$ac_cpp conftest.$ac_ext" |
| 5426 | | case "(($ac_try" in |
| 5427 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 5428 | | *) ac_try_echo=$ac_try;; |
| 5429 | | esac |
| 5430 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 5431 | | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 |
| 5432 | | ac_status=$? |
| 5433 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 5434 | | rm -f conftest.er1 |
| 5435 | | cat conftest.err >&5 |
| 5436 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 5437 | | (exit $ac_status); } >/dev/null && { |
| 5438 | | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| 5439 | | test ! -s conftest.err |
| 5440 | | }; then |
| 5441 | | # Broken: success on invalid input. |
| 5442 | | continue |
| 5443 | | else |
| 5444 | | echo "$as_me: failed program was:" >&5 |
| 5445 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 5446 | | |
| 5447 | | # Passes both tests. |
| 5448 | | ac_preproc_ok=: |
| 5449 | | break |
| 5450 | | fi |
| 5451 | | |
| 5452 | | rm -f conftest.err conftest.$ac_ext |
| 5453 | | |
| 5454 | | done |
| 5455 | | # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. |
| 5456 | | rm -f conftest.err conftest.$ac_ext |
| 5457 | | if $ac_preproc_ok; then |
| 5458 | | : |
| 5459 | | else |
| 5460 | | { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check |
| 5461 | | See \`config.log' for more details." >&5 |
| 5462 | | echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check |
| 5463 | | See \`config.log' for more details." >&2;} |
| 5464 | | { (exit 1); exit 1; }; } |
| 5465 | | fi |
| 5466 | | |
| 5467 | | ac_ext=c |
| 5468 | | ac_cpp='$CPP $CPPFLAGS' |
| 5469 | | ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' |
| 5470 | | ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' |
| 5471 | | ac_compiler_gnu=$ac_cv_c_compiler_gnu |
| 5472 | | |
| 5473 | | |
| 5474 | | { echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5 |
| 5475 | | echo $ECHO_N "checking for grep that handles long lines and -e... $ECHO_C" >&6; } |
| 5476 | | if test "${ac_cv_path_GREP+set}" = set; then |
| 5477 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 5478 | | else |
| 5479 | | # Extract the first word of "grep ggrep" to use in msg output |
| 5480 | | if test -z "$GREP"; then |
| 5481 | | set dummy grep ggrep; ac_prog_name=$2 |
| 5482 | | if test "${ac_cv_path_GREP+set}" = set; then |
| 5483 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 5484 | | else |
| 5485 | | ac_path_GREP_found=false |
| 5486 | | # Loop through the user's path and test for each of PROGNAME-LIST |
| 5487 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 5488 | | for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin |
| 5489 | | do |
| 5490 | | IFS=$as_save_IFS |
| 5491 | | test -z "$as_dir" && as_dir=. |
| 5492 | | for ac_prog in grep ggrep; do |
| 5493 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 5494 | | ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" |
| 5495 | | { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue |
| 5496 | | # Check for GNU ac_path_GREP and select it if it is found. |
| 5497 | | # Check for GNU $ac_path_GREP |
| 5498 | | case `"$ac_path_GREP" --version 2>&1` in |
| 5499 | | *GNU*) |
| 5500 | | ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; |
| 5501 | | *) |
| 5502 | | ac_count=0 |
| 5503 | | echo $ECHO_N "0123456789$ECHO_C" >"conftest.in" |
| 5504 | | while : |
| 5505 | | do |
| 5506 | | cat "conftest.in" "conftest.in" >"conftest.tmp" |
| 5507 | | mv "conftest.tmp" "conftest.in" |
| 5508 | | cp "conftest.in" "conftest.nl" |
| 5509 | | echo 'GREP' >> "conftest.nl" |
| 5510 | | "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break |
| 5511 | | diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break |
| 5512 | | ac_count=`expr $ac_count + 1` |
| 5513 | | if test $ac_count -gt ${ac_path_GREP_max-0}; then |
| 5514 | | # Best one so far, save it but keep looking for a better one |
| 5515 | | ac_cv_path_GREP="$ac_path_GREP" |
| 5516 | | ac_path_GREP_max=$ac_count |
| 5517 | | fi |
| 5518 | | # 10*(2^10) chars as input seems more than enough |
| 5519 | | test $ac_count -gt 10 && break |
| 5520 | | done |
| 5521 | | rm -f conftest.in conftest.tmp conftest.nl conftest.out;; |
| 5522 | | esac |
| 5523 | | |
| 5524 | | |
| 5525 | | $ac_path_GREP_found && break 3 |
| 5526 | | done |
| 5527 | | done |
| 5528 | | |
| 5529 | | done |
| 5530 | | IFS=$as_save_IFS |
| 5531 | | |
| 5532 | | |
| 5533 | | fi |
| 5534 | | |
| 5535 | | GREP="$ac_cv_path_GREP" |
| 5536 | | if test -z "$GREP"; then |
| 5537 | | { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5 |
| 5538 | | echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;} |
| 5539 | | { (exit 1); exit 1; }; } |
| 5540 | | fi |
| 5541 | | |
| 5542 | | else |
| 5543 | | ac_cv_path_GREP=$GREP |
| 5544 | | fi |
| 5545 | | |
| 5546 | | |
| 5547 | | fi |
| 5548 | | { echo "$as_me:$LINENO: result: $ac_cv_path_GREP" >&5 |
| 5549 | | echo "${ECHO_T}$ac_cv_path_GREP" >&6; } |
| 5550 | | GREP="$ac_cv_path_GREP" |
| 5551 | | |
| 5552 | | |
| 5553 | | { echo "$as_me:$LINENO: checking for egrep" >&5 |
| 5554 | | echo $ECHO_N "checking for egrep... $ECHO_C" >&6; } |
| 5555 | | if test "${ac_cv_path_EGREP+set}" = set; then |
| 5556 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 5557 | | else |
| 5558 | | if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 |
| 5559 | | then ac_cv_path_EGREP="$GREP -E" |
| 5560 | | else |
| 5561 | | # Extract the first word of "egrep" to use in msg output |
| 5562 | | if test -z "$EGREP"; then |
| 5563 | | set dummy egrep; ac_prog_name=$2 |
| 5564 | | if test "${ac_cv_path_EGREP+set}" = set; then |
| 5565 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 5566 | | else |
| 5567 | | ac_path_EGREP_found=false |
| 5568 | | # Loop through the user's path and test for each of PROGNAME-LIST |
| 5569 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 5570 | | for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin |
| 5571 | | do |
| 5572 | | IFS=$as_save_IFS |
| 5573 | | test -z "$as_dir" && as_dir=. |
| 5574 | | for ac_prog in egrep; do |
| 5575 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 5576 | | ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" |
| 5577 | | { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue |
| 5578 | | # Check for GNU ac_path_EGREP and select it if it is found. |
| 5579 | | # Check for GNU $ac_path_EGREP |
| 5580 | | case `"$ac_path_EGREP" --version 2>&1` in |
| 5581 | | *GNU*) |
| 5582 | | ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; |
| 5583 | | *) |
| 5584 | | ac_count=0 |
| 5585 | | echo $ECHO_N "0123456789$ECHO_C" >"conftest.in" |
| 5586 | | while : |
| 5587 | | do |
| 5588 | | cat "conftest.in" "conftest.in" >"conftest.tmp" |
| 5589 | | mv "conftest.tmp" "conftest.in" |
| 5590 | | cp "conftest.in" "conftest.nl" |
| 5591 | | echo 'EGREP' >> "conftest.nl" |
| 5592 | | "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break |
| 5593 | | diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break |
| 5594 | | ac_count=`expr $ac_count + 1` |
| 5595 | | if test $ac_count -gt ${ac_path_EGREP_max-0}; then |
| 5596 | | # Best one so far, save it but keep looking for a better one |
| 5597 | | ac_cv_path_EGREP="$ac_path_EGREP" |
| 5598 | | ac_path_EGREP_max=$ac_count |
| 5599 | | fi |
| 5600 | | # 10*(2^10) chars as input seems more than enough |
| 5601 | | test $ac_count -gt 10 && break |
| 5602 | | done |
| 5603 | | rm -f conftest.in conftest.tmp conftest.nl conftest.out;; |
| 5604 | | esac |
| 5605 | | |
| 5606 | | |
| 5607 | | $ac_path_EGREP_found && break 3 |
| 5608 | | done |
| 5609 | | done |
| 5610 | | |
| 5611 | | done |
| 5612 | | IFS=$as_save_IFS |
| 5613 | | |
| 5614 | | |
| 5615 | | fi |
| 5616 | | |
| 5617 | | EGREP="$ac_cv_path_EGREP" |
| 5618 | | if test -z "$EGREP"; then |
| 5619 | | { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5 |
| 5620 | | echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;} |
| 5621 | | { (exit 1); exit 1; }; } |
| 5622 | | fi |
| 5623 | | |
| 5624 | | else |
| 5625 | | ac_cv_path_EGREP=$EGREP |
| 5626 | | fi |
| 5627 | | |
| 5628 | | |
| 5629 | | fi |
| 5630 | | fi |
| 5631 | | { echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5 |
| 5632 | | echo "${ECHO_T}$ac_cv_path_EGREP" >&6; } |
| 5633 | | EGREP="$ac_cv_path_EGREP" |
| 5634 | | |
| 5635 | | |
| 5636 | | { echo "$as_me:$LINENO: checking for ANSI C header files" >&5 |
| 5637 | | echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6; } |
| 5638 | | if test "${ac_cv_header_stdc+set}" = set; then |
| 5639 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 5640 | | else |
| 5641 | | cat >conftest.$ac_ext <<_ACEOF |
| 5642 | | /* confdefs.h. */ |
| 5643 | | _ACEOF |
| 5644 | | cat confdefs.h >>conftest.$ac_ext |
| 5645 | | cat >>conftest.$ac_ext <<_ACEOF |
| 5646 | | /* end confdefs.h. */ |
| 5647 | | #include <stdlib.h> |
| 5648 | | #include <stdarg.h> |
| 5649 | | #include <string.h> |
| 5650 | | #include <float.h> |
| 5651 | | |
| 5652 | | int |
| 5653 | | main () |
| 5654 | | { |
| 5655 | | |
| 5656 | | ; |
| 5657 | | return 0; |
| 5658 | | } |
| 5659 | | _ACEOF |
| 5660 | | rm -f conftest.$ac_objext |
| 5661 | | if { (ac_try="$ac_compile" |
| 5662 | | case "(($ac_try" in |
| 5663 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 5664 | | *) ac_try_echo=$ac_try;; |
| 5665 | | esac |
| 5666 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 5667 | | (eval "$ac_compile") 2>conftest.er1 |
| 5668 | | ac_status=$? |
| 5669 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 5670 | | rm -f conftest.er1 |
| 5671 | | cat conftest.err >&5 |
| 5672 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 5673 | | (exit $ac_status); } && { |
| 5674 | | test -z "$ac_c_werror_flag" || |
| 5675 | | test ! -s conftest.err |
| 5676 | | } && test -s conftest.$ac_objext; then |
| 5677 | | ac_cv_header_stdc=yes |
| 5678 | | else |
| 5679 | | echo "$as_me: failed program was:" >&5 |
| 5680 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 5681 | | |
| 5682 | | ac_cv_header_stdc=no |
| 5683 | | fi |
| 5684 | | |
| 5685 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 5686 | | |
| 5687 | | if test $ac_cv_header_stdc = yes; then |
| 5688 | | # SunOS 4.x string.h does not declare mem*, contrary to ANSI. |
| 5689 | | cat >conftest.$ac_ext <<_ACEOF |
| 5690 | | /* confdefs.h. */ |
| 5691 | | _ACEOF |
| 5692 | | cat confdefs.h >>conftest.$ac_ext |
| 5693 | | cat >>conftest.$ac_ext <<_ACEOF |
| 5694 | | /* end confdefs.h. */ |
| 5695 | | #include <string.h> |
| 5696 | | |
| 5697 | | _ACEOF |
| 5698 | | if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | |
| 5699 | | $EGREP "memchr" >/dev/null 2>&1; then |
| 5700 | | : |
| 5701 | | else |
| 5702 | | ac_cv_header_stdc=no |
| 5703 | | fi |
| 5704 | | rm -f conftest* |
| 5705 | | |
| 5706 | | fi |
| 5707 | | |
| 5708 | | if test $ac_cv_header_stdc = yes; then |
| 5709 | | # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. |
| 5710 | | cat >conftest.$ac_ext <<_ACEOF |
| 5711 | | /* confdefs.h. */ |
| 5712 | | _ACEOF |
| 5713 | | cat confdefs.h >>conftest.$ac_ext |
| 5714 | | cat >>conftest.$ac_ext <<_ACEOF |
| 5715 | | /* end confdefs.h. */ |
| 5716 | | #include <stdlib.h> |
| 5717 | | |
| 5718 | | _ACEOF |
| 5719 | | if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | |
| 5720 | | $EGREP "free" >/dev/null 2>&1; then |
| 5721 | | : |
| 5722 | | else |
| 5723 | | ac_cv_header_stdc=no |
| 5724 | | fi |
| 5725 | | rm -f conftest* |
| 5726 | | |
| 5727 | | fi |
| 5728 | | |
| 5729 | | if test $ac_cv_header_stdc = yes; then |
| 5730 | | # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. |
| 5731 | | if test "$cross_compiling" = yes; then |
| 5732 | | : |
| 5733 | | else |
| 5734 | | cat >conftest.$ac_ext <<_ACEOF |
| 5735 | | /* confdefs.h. */ |
| 5736 | | _ACEOF |
| 5737 | | cat confdefs.h >>conftest.$ac_ext |
| 5738 | | cat >>conftest.$ac_ext <<_ACEOF |
| 5739 | | /* end confdefs.h. */ |
| 5740 | | #include <ctype.h> |
| 5741 | | #include <stdlib.h> |
| 5742 | | #if ((' ' & 0x0FF) == 0x020) |
| 5743 | | # define ISLOWER(c) ('a' <= (c) && (c) <= 'z') |
| 5744 | | # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) |
| 5745 | | #else |
| 5746 | | # define ISLOWER(c) \ |
| 5747 | | (('a' <= (c) && (c) <= 'i') \ |
| 5748 | | || ('j' <= (c) && (c) <= 'r') \ |
| 5749 | | || ('s' <= (c) && (c) <= 'z')) |
| 5750 | | # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) |
| 5751 | | #endif |
| 5752 | | |
| 5753 | | #define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) |
| 5754 | | int |
| 5755 | | main () |
| 5756 | | { |
| 5757 | | int i; |
| 5758 | | for (i = 0; i < 256; i++) |
| 5759 | | if (XOR (islower (i), ISLOWER (i)) |
| 5760 | | || toupper (i) != TOUPPER (i)) |
| 5761 | | return 2; |
| 5762 | | return 0; |
| 5763 | | } |
| 5764 | | _ACEOF |
| 5765 | | rm -f conftest$ac_exeext |
| 5766 | | if { (ac_try="$ac_link" |
| 5767 | | case "(($ac_try" in |
| 5768 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 5769 | | *) ac_try_echo=$ac_try;; |
| 5770 | | esac |
| 5771 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 5772 | | (eval "$ac_link") 2>&5 |
| 5773 | | ac_status=$? |
| 5774 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 5775 | | (exit $ac_status); } && { ac_try='./conftest$ac_exeext' |
| 5776 | | { (case "(($ac_try" in |
| 5777 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 5778 | | *) ac_try_echo=$ac_try;; |
| 5779 | | esac |
| 5780 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 5781 | | (eval "$ac_try") 2>&5 |
| 5782 | | ac_status=$? |
| 5783 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 5784 | | (exit $ac_status); }; }; then |
| 5785 | | : |
| 5786 | | else |
| 5787 | | echo "$as_me: program exited with status $ac_status" >&5 |
| 5788 | | echo "$as_me: failed program was:" >&5 |
| 5789 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 5790 | | |
| 5791 | | ( exit $ac_status ) |
| 5792 | | ac_cv_header_stdc=no |
| 5793 | | fi |
| 5794 | | rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext |
| 5795 | | fi |
| 5796 | | |
| 5797 | | |
| 5798 | | fi |
| 5799 | | fi |
| 5800 | | { echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5 |
| 5801 | | echo "${ECHO_T}$ac_cv_header_stdc" >&6; } |
| 5802 | | if test $ac_cv_header_stdc = yes; then |
| 5803 | | |
| 5804 | | cat >>confdefs.h <<\_ACEOF |
| 5805 | | #define STDC_HEADERS 1 |
| 5806 | | _ACEOF |
| 5807 | | |
| 5808 | | fi |
| 5809 | | |
| 5810 | | # Check whether --enable-shared was given. |
| 5811 | | if test "${enable_shared+set}" = set; then |
| 5812 | | enableval=$enable_shared; p=${PACKAGE-default} |
| 5813 | | case $enableval in |
| 5814 | | yes) enable_shared=yes ;; |
| 5815 | | no) enable_shared=no ;; |
| 5816 | | *) |
| 5817 | | enable_shared=no |
| 5818 | | # Look at the argument we got. We use all the common list separators. |
| 5819 | | lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," |
| 5820 | | for pkg in $enableval; do |
| 5821 | | IFS="$lt_save_ifs" |
| 5822 | | if test "X$pkg" = "X$p"; then |
| 5823 | | enable_shared=yes |
| 5824 | | fi |
| 5825 | | done |
| 5826 | | IFS="$lt_save_ifs" |
| 5827 | | ;; |
| 5828 | | esac |
| 5829 | | else |
| 5830 | | enable_shared=yes |
| 5831 | | fi |
| 5832 | | |
| 5833 | | |
| 5834 | | # Check whether --enable-static was given. |
| 5835 | | if test "${enable_static+set}" = set; then |
| 5836 | | enableval=$enable_static; p=${PACKAGE-default} |
| 5837 | | case $enableval in |
| 5838 | | yes) enable_static=yes ;; |
| 5839 | | no) enable_static=no ;; |
| 5840 | | *) |
| 5841 | | enable_static=no |
| 5842 | | # Look at the argument we got. We use all the common list separators. |
| 5843 | | lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," |
| 5844 | | for pkg in $enableval; do |
| 5845 | | IFS="$lt_save_ifs" |
| 5846 | | if test "X$pkg" = "X$p"; then |
| 5847 | | enable_static=yes |
| 5848 | | fi |
| 5849 | | done |
| 5850 | | IFS="$lt_save_ifs" |
| 5851 | | ;; |
| 5852 | | esac |
| 5853 | | else |
| 5854 | | enable_static=yes |
| 5855 | | fi |
| 5856 | | |
| 5857 | | |
| 5858 | | # Check whether --enable-fast-install was given. |
| 5859 | | if test "${enable_fast_install+set}" = set; then |
| 5860 | | enableval=$enable_fast_install; p=${PACKAGE-default} |
| 5861 | | case $enableval in |
| 5862 | | yes) enable_fast_install=yes ;; |
| 5863 | | no) enable_fast_install=no ;; |
| 5864 | | *) |
| 5865 | | enable_fast_install=no |
| 5866 | | # Look at the argument we got. We use all the common list separators. |
| 5867 | | lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," |
| 5868 | | for pkg in $enableval; do |
| 5869 | | IFS="$lt_save_ifs" |
| 5870 | | if test "X$pkg" = "X$p"; then |
| 5871 | | enable_fast_install=yes |
| 5872 | | fi |
| 5873 | | done |
| 5874 | | IFS="$lt_save_ifs" |
| 5875 | | ;; |
| 5876 | | esac |
| 5877 | | else |
| 5878 | | enable_fast_install=yes |
| 5879 | | fi |
| 5880 | | |
| 5881 | | |
| 5882 | | # Make sure we can run config.sub. |
| 5883 | | $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || |
| 5884 | | { { echo "$as_me:$LINENO: error: cannot run $SHELL $ac_aux_dir/config.sub" >&5 |
| 5885 | | echo "$as_me: error: cannot run $SHELL $ac_aux_dir/config.sub" >&2;} |
| 5886 | | { (exit 1); exit 1; }; } |
| 5887 | | |
| 5888 | | { echo "$as_me:$LINENO: checking build system type" >&5 |
| 5889 | | echo $ECHO_N "checking build system type... $ECHO_C" >&6; } |
| 5890 | | if test "${ac_cv_build+set}" = set; then |
| 5891 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 5892 | | else |
| 5893 | | ac_build_alias=$build_alias |
| 5894 | | test "x$ac_build_alias" = x && |
| 5895 | | ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` |
| 5896 | | test "x$ac_build_alias" = x && |
| 5897 | | { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5 |
| 5898 | | echo "$as_me: error: cannot guess build type; you must specify one" >&2;} |
| 5899 | | { (exit 1); exit 1; }; } |
| 5900 | | ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || |
| 5901 | | { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&5 |
| 5902 | | echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&2;} |
| 5903 | | { (exit 1); exit 1; }; } |
| 5904 | | |
| 5905 | | fi |
| 5906 | | { echo "$as_me:$LINENO: result: $ac_cv_build" >&5 |
| 5907 | | echo "${ECHO_T}$ac_cv_build" >&6; } |
| 5908 | | case $ac_cv_build in |
| 5909 | | *-*-*) ;; |
| 5910 | | *) { { echo "$as_me:$LINENO: error: invalid value of canonical build" >&5 |
| 5911 | | echo "$as_me: error: invalid value of canonical build" >&2;} |
| 5912 | | { (exit 1); exit 1; }; };; |
| 5913 | | esac |
| 5914 | | build=$ac_cv_build |
| 5915 | | ac_save_IFS=$IFS; IFS='-' |
| 5916 | | set x $ac_cv_build |
| 5917 | | shift |
| 5918 | | build_cpu=$1 |
| 5919 | | build_vendor=$2 |
| 5920 | | shift; shift |
| 5921 | | # Remember, the first character of IFS is used to create $*, |
| 5922 | | # except with old shells: |
| 5923 | | build_os=$* |
| 5924 | | IFS=$ac_save_IFS |
| 5925 | | case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac |
| 5926 | | |
| 5927 | | |
| 5928 | | { echo "$as_me:$LINENO: checking host system type" >&5 |
| 5929 | | echo $ECHO_N "checking host system type... $ECHO_C" >&6; } |
| 5930 | | if test "${ac_cv_host+set}" = set; then |
| 5931 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 5932 | | else |
| 5933 | | if test "x$host_alias" = x; then |
| 5934 | | ac_cv_host=$ac_cv_build |
| 5935 | | else |
| 5936 | | ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || |
| 5937 | | { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&5 |
| 5938 | | echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&2;} |
| 5939 | | { (exit 1); exit 1; }; } |
| 5940 | | fi |
| 5941 | | |
| 5942 | | fi |
| 5943 | | { echo "$as_me:$LINENO: result: $ac_cv_host" >&5 |
| 5944 | | echo "${ECHO_T}$ac_cv_host" >&6; } |
| 5945 | | case $ac_cv_host in |
| 5946 | | *-*-*) ;; |
| 5947 | | *) { { echo "$as_me:$LINENO: error: invalid value of canonical host" >&5 |
| 5948 | | echo "$as_me: error: invalid value of canonical host" >&2;} |
| 5949 | | { (exit 1); exit 1; }; };; |
| 5950 | | esac |
| 5951 | | host=$ac_cv_host |
| 5952 | | ac_save_IFS=$IFS; IFS='-' |
| 5953 | | set x $ac_cv_host |
| 5954 | | shift |
| 5955 | | host_cpu=$1 |
| 5956 | | host_vendor=$2 |
| 5957 | | shift; shift |
| 5958 | | # Remember, the first character of IFS is used to create $*, |
| 5959 | | # except with old shells: |
| 5960 | | host_os=$* |
| 5961 | | IFS=$ac_save_IFS |
| 5962 | | case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac |
| 21108 | | |
| 21109 | | |
| 21110 | | if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then |
| 21111 | | if test -n "$ac_tool_prefix"; then |
| 21112 | | # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args. |
| 21113 | | set dummy ${ac_tool_prefix}pkg-config; ac_word=$2 |
| 21114 | | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| 21115 | | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| 21116 | | if test "${ac_cv_path_PKG_CONFIG+set}" = set; then |
| 21117 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 21118 | | else |
| 21119 | | case $PKG_CONFIG in |
| 21120 | | [\\/]* | ?:[\\/]*) |
| 21121 | | ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path. |
| 21122 | | ;; |
| 21123 | | *) |
| 21124 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 21125 | | for as_dir in $PATH |
| 21126 | | do |
| 21127 | | IFS=$as_save_IFS |
| 21128 | | test -z "$as_dir" && as_dir=. |
| 21129 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 21130 | | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| 21131 | | ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" |
| 21132 | | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| 21133 | | break 2 |
| 21134 | | fi |
| 21135 | | done |
| 21136 | | done |
| 21137 | | IFS=$as_save_IFS |
| 21138 | | |
| 21139 | | ;; |
| 21140 | | esac |
| 21141 | | fi |
| 21142 | | PKG_CONFIG=$ac_cv_path_PKG_CONFIG |
| 21143 | | if test -n "$PKG_CONFIG"; then |
| 21144 | | { echo "$as_me:$LINENO: result: $PKG_CONFIG" >&5 |
| 21145 | | echo "${ECHO_T}$PKG_CONFIG" >&6; } |
| 21146 | | else |
| 21147 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 21148 | | echo "${ECHO_T}no" >&6; } |
| 21149 | | fi |
| 21150 | | |
| 21151 | | |
| 21152 | | fi |
| 21153 | | if test -z "$ac_cv_path_PKG_CONFIG"; then |
| 21154 | | ac_pt_PKG_CONFIG=$PKG_CONFIG |
| 21155 | | # Extract the first word of "pkg-config", so it can be a program name with args. |
| 21156 | | set dummy pkg-config; ac_word=$2 |
| 21157 | | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| 21158 | | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| 21159 | | if test "${ac_cv_path_ac_pt_PKG_CONFIG+set}" = set; then |
| 21160 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 21161 | | else |
| 21162 | | case $ac_pt_PKG_CONFIG in |
| 21163 | | [\\/]* | ?:[\\/]*) |
| 21164 | | ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path. |
| 21165 | | ;; |
| 21166 | | *) |
| 21167 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 21168 | | for as_dir in $PATH |
| 21169 | | do |
| 21170 | | IFS=$as_save_IFS |
| 21171 | | test -z "$as_dir" && as_dir=. |
| 21172 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 21173 | | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| 21174 | | ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" |
| 21175 | | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| 21176 | | break 2 |
| 21177 | | fi |
| 21178 | | done |
| 21179 | | done |
| 21180 | | IFS=$as_save_IFS |
| 21181 | | |
| 21182 | | ;; |
| 21183 | | esac |
| 21184 | | fi |
| 21185 | | ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG |
| 21186 | | if test -n "$ac_pt_PKG_CONFIG"; then |
| 21187 | | { echo "$as_me:$LINENO: result: $ac_pt_PKG_CONFIG" >&5 |
| 21188 | | echo "${ECHO_T}$ac_pt_PKG_CONFIG" >&6; } |
| 21189 | | else |
| 21190 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 21191 | | echo "${ECHO_T}no" >&6; } |
| 21192 | | fi |
| 21193 | | |
| 21194 | | if test "x$ac_pt_PKG_CONFIG" = x; then |
| 21195 | | PKG_CONFIG="" |
| 21196 | | else |
| 21197 | | case $cross_compiling:$ac_tool_warned in |
| 21198 | | yes:) |
| 21199 | | { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools |
| 21200 | | whose name does not start with the host triplet. If you think this |
| 21201 | | configuration is useful to you, please write to autoconf@gnu.org." >&5 |
| 21202 | | echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools |
| 21203 | | whose name does not start with the host triplet. If you think this |
| 21204 | | configuration is useful to you, please write to autoconf@gnu.org." >&2;} |
| 21205 | | ac_tool_warned=yes ;; |
| 21206 | | esac |
| 21207 | | PKG_CONFIG=$ac_pt_PKG_CONFIG |
| 21208 | | fi |
| 21209 | | else |
| 21210 | | PKG_CONFIG="$ac_cv_path_PKG_CONFIG" |
| 21211 | | fi |
| 21212 | | |
| 21213 | | fi |
| 21214 | | if test -n "$PKG_CONFIG"; then |
| 21215 | | _pkg_min_version=0.9.0 |
| 21216 | | { echo "$as_me:$LINENO: checking pkg-config is at least version $_pkg_min_version" >&5 |
| 21217 | | echo $ECHO_N "checking pkg-config is at least version $_pkg_min_version... $ECHO_C" >&6; } |
| 21218 | | if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then |
| 21219 | | { echo "$as_me:$LINENO: result: yes" >&5 |
| 21220 | | echo "${ECHO_T}yes" >&6; } |
| 21221 | | else |
| 21222 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 21223 | | echo "${ECHO_T}no" >&6; } |
| 21224 | | PKG_CONFIG="" |
| 21225 | | fi |
| 21226 | | |
| 21227 | | fi |
| 21228 | | |
| 21229 | | pkg_failed=no |
| 21230 | | { echo "$as_me:$LINENO: checking for FM_SERVER" >&5 |
| 21231 | | echo $ECHO_N "checking for FM_SERVER... $ECHO_C" >&6; } |
| 21232 | | |
| 21233 | | if test -n "$PKG_CONFIG"; then |
| 21234 | | if test -n "$FM_SERVER_CFLAGS"; then |
| 21235 | | pkg_cv_FM_SERVER_CFLAGS="$FM_SERVER_CFLAGS" |
| 21236 | | else |
| 21237 | | if test -n "$PKG_CONFIG" && \ |
| 21238 | | { (echo "$as_me:$LINENO: \$PKG_CONFIG --exists --print-errors \"glib-2.0 gthread-2.0 gobject-2.0 rgc_server samplerate gstreamer-0.10 gstreamer-base-0.10 gstreamer-plugins-base-0.10\"") >&5 |
| 21239 | | ($PKG_CONFIG --exists --print-errors "glib-2.0 gthread-2.0 gobject-2.0 rgc_server samplerate gstreamer-0.10 gstreamer-base-0.10 gstreamer-plugins-base-0.10") 2>&5 |
| 21240 | | ac_status=$? |
| 21241 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 21242 | | (exit $ac_status); }; then |
| 21243 | | pkg_cv_FM_SERVER_CFLAGS=`$PKG_CONFIG --cflags "glib-2.0 gthread-2.0 gobject-2.0 rgc_server samplerate gstreamer-0.10 gstreamer-base-0.10 gstreamer-plugins-base-0.10" 2>/dev/null` |
| 21244 | | else |
| 21245 | | pkg_failed=yes |
| 21246 | | fi |
| 21247 | | fi |
| 21248 | | else |
| 21249 | | pkg_failed=untried |
| 21250 | | fi |
| 21251 | | if test -n "$PKG_CONFIG"; then |
| 21252 | | if test -n "$FM_SERVER_LIBS"; then |
| 21253 | | pkg_cv_FM_SERVER_LIBS="$FM_SERVER_LIBS" |
| 21254 | | else |
| 21255 | | if test -n "$PKG_CONFIG" && \ |
| 21256 | | { (echo "$as_me:$LINENO: \$PKG_CONFIG --exists --print-errors \"glib-2.0 gthread-2.0 gobject-2.0 rgc_server samplerate gstreamer-0.10 gstreamer-base-0.10 gstreamer-plugins-base-0.10\"") >&5 |
| 21257 | | ($PKG_CONFIG --exists --print-errors "glib-2.0 gthread-2.0 gobject-2.0 rgc_server samplerate gstreamer-0.10 gstreamer-base-0.10 gstreamer-plugins-base-0.10") 2>&5 |
| 21258 | | ac_status=$? |
| 21259 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 21260 | | (exit $ac_status); }; then |
| 21261 | | pkg_cv_FM_SERVER_LIBS=`$PKG_CONFIG --libs "glib-2.0 gthread-2.0 gobject-2.0 rgc_server samplerate gstreamer-0.10 gstreamer-base-0.10 gstreamer-plugins-base-0.10" 2>/dev/null` |
| 21262 | | else |
| 21263 | | pkg_failed=yes |
| 21264 | | fi |
| 21265 | | fi |
| 21266 | | else |
| 21267 | | pkg_failed=untried |
| 21268 | | fi |
| 21269 | | |
| 21270 | | |
| 21271 | | |
| 21272 | | if test $pkg_failed = yes; then |
| 21273 | | |
| 21274 | | if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then |
| 21275 | | _pkg_short_errors_supported=yes |
| 21276 | | else |
| 21277 | | _pkg_short_errors_supported=no |
| 21278 | | fi |
| 21279 | | if test $_pkg_short_errors_supported = yes; then |
| 21280 | | FM_SERVER_PKG_ERRORS=`$PKG_CONFIG --short-errors --errors-to-stdout --print-errors "glib-2.0 gthread-2.0 gobject-2.0 rgc_server samplerate gstreamer-0.10 gstreamer-base-0.10 gstreamer-plugins-base-0.10"` |
| 21281 | | else |
| 21282 | | FM_SERVER_PKG_ERRORS=`$PKG_CONFIG --errors-to-stdout --print-errors "glib-2.0 gthread-2.0 gobject-2.0 rgc_server samplerate gstreamer-0.10 gstreamer-base-0.10 gstreamer-plugins-base-0.10"` |
| 21283 | | fi |
| 21284 | | # Put the nasty error message in config.log where it belongs |
| 21285 | | echo "$FM_SERVER_PKG_ERRORS" >&5 |
| 21286 | | |
| 21287 | | { { echo "$as_me:$LINENO: error: Package requirements (glib-2.0 gthread-2.0 gobject-2.0 rgc_server samplerate gstreamer-0.10 gstreamer-base-0.10 gstreamer-plugins-base-0.10) were not met: |
| 21288 | | |
| 21289 | | $FM_SERVER_PKG_ERRORS |
| 21290 | | |
| 21291 | | Consider adjusting the PKG_CONFIG_PATH environment variable if you |
| 21292 | | installed software in a non-standard prefix. |
| 21293 | | |
| 21294 | | Alternatively, you may set the environment variables FM_SERVER_CFLAGS |
| 21295 | | and FM_SERVER_LIBS to avoid the need to call pkg-config. |
| 21296 | | See the pkg-config man page for more details. |
| 21297 | | " >&5 |
| 21298 | | echo "$as_me: error: Package requirements (glib-2.0 gthread-2.0 gobject-2.0 rgc_server samplerate gstreamer-0.10 gstreamer-base-0.10 gstreamer-plugins-base-0.10) were not met: |
| 21299 | | |
| 21300 | | $FM_SERVER_PKG_ERRORS |
| 21301 | | |
| 21302 | | Consider adjusting the PKG_CONFIG_PATH environment variable if you |
| 21303 | | installed software in a non-standard prefix. |
| 21304 | | |
| 21305 | | Alternatively, you may set the environment variables FM_SERVER_CFLAGS |
| 21306 | | and FM_SERVER_LIBS to avoid the need to call pkg-config. |
| 21307 | | See the pkg-config man page for more details. |
| 21308 | | " >&2;} |
| 21309 | | { (exit 1); exit 1; }; } |
| 21310 | | elif test $pkg_failed = untried; then |
| 21311 | | { { echo "$as_me:$LINENO: error: The pkg-config script could not be found or is too old. Make sure it |
| 21312 | | is in your PATH or set the PKG_CONFIG environment variable to the full |
| 21313 | | path to pkg-config. |
| 21314 | | |
| 21315 | | Alternatively, you may set the environment variables FM_SERVER_CFLAGS |
| 21316 | | and FM_SERVER_LIBS to avoid the need to call pkg-config. |
| 21317 | | See the pkg-config man page for more details. |
| 21318 | | |
| 21319 | | To get pkg-config, see <http://pkg-config.freedesktop.org/>. |
| 21320 | | See \`config.log' for more details." >&5 |
| 21321 | | echo "$as_me: error: The pkg-config script could not be found or is too old. Make sure it |
| 21322 | | is in your PATH or set the PKG_CONFIG environment variable to the full |
| 21323 | | path to pkg-config. |
| 21324 | | |
| 21325 | | Alternatively, you may set the environment variables FM_SERVER_CFLAGS |
| 21326 | | and FM_SERVER_LIBS to avoid the need to call pkg-config. |
| 21327 | | See the pkg-config man page for more details. |
| 21328 | | |
| 21329 | | To get pkg-config, see <http://pkg-config.freedesktop.org/>. |
| 21330 | | See \`config.log' for more details." >&2;} |
| 21331 | | { (exit 1); exit 1; }; } |
| 21332 | | else |
| 21333 | | FM_SERVER_CFLAGS=$pkg_cv_FM_SERVER_CFLAGS |
| 21334 | | FM_SERVER_LIBS=$pkg_cv_FM_SERVER_LIBS |
| 21335 | | { echo "$as_me:$LINENO: result: yes" >&5 |
| 21336 | | echo "${ECHO_T}yes" >&6; } |
| 21337 | | : |
| 21338 | | fi |
| 21339 | | |
| 21340 | | |
| 21341 | | |
| 21342 | | |
| 21343 | | pkg_failed=no |
| 21344 | | { echo "$as_me:$LINENO: checking for FM_SERVER_TEST" >&5 |
| 21345 | | echo $ECHO_N "checking for FM_SERVER_TEST... $ECHO_C" >&6; } |
| 21346 | | |
| 21347 | | if test -n "$PKG_CONFIG"; then |
| 21348 | | if test -n "$FM_SERVER_TEST_CFLAGS"; then |
| 21349 | | pkg_cv_FM_SERVER_TEST_CFLAGS="$FM_SERVER_TEST_CFLAGS" |
| 21350 | | else |
| 21351 | | if test -n "$PKG_CONFIG" && \ |
| 21352 | | { (echo "$as_me:$LINENO: \$PKG_CONFIG --exists --print-errors \"glib-2.0 gthread-2.0 gobject-2.0 rgc_client\"") >&5 |
| 21353 | | ($PKG_CONFIG --exists --print-errors "glib-2.0 gthread-2.0 gobject-2.0 rgc_client") 2>&5 |
| 21354 | | ac_status=$? |
| 21355 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 21356 | | (exit $ac_status); }; then |
| 21357 | | pkg_cv_FM_SERVER_TEST_CFLAGS=`$PKG_CONFIG --cflags "glib-2.0 gthread-2.0 gobject-2.0 rgc_client" 2>/dev/null` |
| 21358 | | else |
| 21359 | | pkg_failed=yes |
| 21360 | | fi |
| 21361 | | fi |
| 21362 | | else |
| 21363 | | pkg_failed=untried |
| 21364 | | fi |
| 21365 | | if test -n "$PKG_CONFIG"; then |
| 21366 | | if test -n "$FM_SERVER_TEST_LIBS"; then |
| 21367 | | pkg_cv_FM_SERVER_TEST_LIBS="$FM_SERVER_TEST_LIBS" |
| 21368 | | else |
| 21369 | | if test -n "$PKG_CONFIG" && \ |
| 21370 | | { (echo "$as_me:$LINENO: \$PKG_CONFIG --exists --print-errors \"glib-2.0 gthread-2.0 gobject-2.0 rgc_client\"") >&5 |
| 21371 | | ($PKG_CONFIG --exists --print-errors "glib-2.0 gthread-2.0 gobject-2.0 rgc_client") 2>&5 |
| 21372 | | ac_status=$? |
| 21373 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 21374 | | (exit $ac_status); }; then |
| 21375 | | pkg_cv_FM_SERVER_TEST_LIBS=`$PKG_CONFIG --libs "glib-2.0 gthread-2.0 gobject-2.0 rgc_client" 2>/dev/null` |
| 21376 | | else |
| 21377 | | pkg_failed=yes |
| 21378 | | fi |
| 21379 | | fi |
| 21380 | | else |
| 21381 | | pkg_failed=untried |
| 21382 | | fi |
| 21383 | | |
| 21384 | | |
| 21385 | | |
| 21386 | | if test $pkg_failed = yes; then |
| 21387 | | |
| 21388 | | if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then |
| 21389 | | _pkg_short_errors_supported=yes |
| 21390 | | else |
| 21391 | | _pkg_short_errors_supported=no |
| 21392 | | fi |
| 21393 | | if test $_pkg_short_errors_supported = yes; then |
| 21394 | | FM_SERVER_TEST_PKG_ERRORS=`$PKG_CONFIG --short-errors --errors-to-stdout --print-errors "glib-2.0 gthread-2.0 gobject-2.0 rgc_client"` |
| 21395 | | else |
| 21396 | | FM_SERVER_TEST_PKG_ERRORS=`$PKG_CONFIG --errors-to-stdout --print-errors "glib-2.0 gthread-2.0 gobject-2.0 rgc_client"` |
| 21397 | | fi |
| 21398 | | # Put the nasty error message in config.log where it belongs |
| 21399 | | echo "$FM_SERVER_TEST_PKG_ERRORS" >&5 |
| 21400 | | |
| 21401 | | { { echo "$as_me:$LINENO: error: Package requirements (glib-2.0 gthread-2.0 gobject-2.0 rgc_client) were not met: |
| 21402 | | |
| 21403 | | $FM_SERVER_TEST_PKG_ERRORS |
| 21404 | | |
| 21405 | | Consider adjusting the PKG_CONFIG_PATH environment variable if you |
| 21406 | | installed software in a non-standard prefix. |
| 21407 | | |
| 21408 | | Alternatively, you may set the environment variables FM_SERVER_TEST_CFLAGS |
| 21409 | | and FM_SERVER_TEST_LIBS to avoid the need to call pkg-config. |
| 21410 | | See the pkg-config man page for more details. |
| 21411 | | " >&5 |
| 21412 | | echo "$as_me: error: Package requirements (glib-2.0 gthread-2.0 gobject-2.0 rgc_client) were not met: |
| 21413 | | |
| 21414 | | $FM_SERVER_TEST_PKG_ERRORS |
| 21415 | | |
| 21416 | | Consider adjusting the PKG_CONFIG_PATH environment variable if you |
| 21417 | | installed software in a non-standard prefix. |
| 21418 | | |
| 21419 | | Alternatively, you may set the environment variables FM_SERVER_TEST_CFLAGS |
| 21420 | | and FM_SERVER_TEST_LIBS to avoid the need to call pkg-config. |
| 21421 | | See the pkg-config man page for more details. |
| 21422 | | " >&2;} |
| 21423 | | { (exit 1); exit 1; }; } |
| 21424 | | elif test $pkg_failed = untried; then |
| 21425 | | { { echo "$as_me:$LINENO: error: The pkg-config script could not be found or is too old. Make sure it |
| 21426 | | is in your PATH or set the PKG_CONFIG environment variable to the full |
| 21427 | | path to pkg-config. |
| 21428 | | |
| 21429 | | Alternatively, you may set the environment variables FM_SERVER_TEST_CFLAGS |
| 21430 | | and FM_SERVER_TEST_LIBS to avoid the need to call pkg-config. |
| 21431 | | See the pkg-config man page for more details. |
| 21432 | | |
| 21433 | | To get pkg-config, see <http://pkg-config.freedesktop.org/>. |
| 21434 | | See \`config.log' for more details." >&5 |
| 21435 | | echo "$as_me: error: The pkg-config script could not be found or is too old. Make sure it |
| 21436 | | is in your PATH or set the PKG_CONFIG environment variable to the full |
| 21437 | | path to pkg-config. |
| 21438 | | |
| 21439 | | Alternatively, you may set the environment variables FM_SERVER_TEST_CFLAGS |
| 21440 | | and FM_SERVER_TEST_LIBS to avoid the need to call pkg-config. |
| 21441 | | See the pkg-config man page for more details. |
| 21442 | | |
| 21443 | | To get pkg-config, see <http://pkg-config.freedesktop.org/>. |
| 21444 | | See \`config.log' for more details." >&2;} |
| 21445 | | { (exit 1); exit 1; }; } |
| 21446 | | else |
| 21447 | | FM_SERVER_TEST_CFLAGS=$pkg_cv_FM_SERVER_TEST_CFLAGS |
| 21448 | | FM_SERVER_TEST_LIBS=$pkg_cv_FM_SERVER_TEST_LIBS |
| 21449 | | { echo "$as_me:$LINENO: result: yes" >&5 |
| 21450 | | echo "${ECHO_T}yes" >&6; } |
| 21451 | | : |
| 21452 | | fi |
| 21453 | | |
| 21454 | | |
| 21455 | | |
| 21456 | | |
| 21457 | | |
| 21458 | | pkg_failed=no |
| 21459 | | { echo "$as_me:$LINENO: checking for JACK" >&5 |
| 21460 | | echo $ECHO_N "checking for JACK... $ECHO_C" >&6; } |
| 21461 | | |
| 21462 | | if test -n "$PKG_CONFIG"; then |
| 21463 | | if test -n "$JACK_CFLAGS"; then |
| 21464 | | pkg_cv_JACK_CFLAGS="$JACK_CFLAGS" |
| 21465 | | else |
| 21466 | | if test -n "$PKG_CONFIG" && \ |
| 21467 | | { (echo "$as_me:$LINENO: \$PKG_CONFIG --exists --print-errors \"jack\"") >&5 |
| 21468 | | ($PKG_CONFIG --exists --print-errors "jack") 2>&5 |
| 21469 | | ac_status=$? |
| 21470 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 21471 | | (exit $ac_status); }; then |
| 21472 | | pkg_cv_JACK_CFLAGS=`$PKG_CONFIG --cflags "jack" 2>/dev/null` |
| 21473 | | else |
| 21474 | | pkg_failed=yes |
| 21475 | | fi |
| 21476 | | fi |
| 21477 | | else |
| 21478 | | pkg_failed=untried |
| 21479 | | fi |
| 21480 | | if test -n "$PKG_CONFIG"; then |
| 21481 | | if test -n "$JACK_LIBS"; then |
| 21482 | | pkg_cv_JACK_LIBS="$JACK_LIBS" |
| 21483 | | else |
| 21484 | | if test -n "$PKG_CONFIG" && \ |
| 21485 | | { (echo "$as_me:$LINENO: \$PKG_CONFIG --exists --print-errors \"jack\"") >&5 |
| 21486 | | ($PKG_CONFIG --exists --print-errors "jack") 2>&5 |
| 21487 | | ac_status=$? |
| 21488 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 21489 | | (exit $ac_status); }; then |
| 21490 | | pkg_cv_JACK_LIBS=`$PKG_CONFIG --libs "jack" 2>/dev/null` |
| 21491 | | else |
| 21492 | | pkg_failed=yes |
| 21493 | | fi |
| 21494 | | fi |
| 21495 | | else |
| 21496 | | pkg_failed=untried |
| 21497 | | fi |
| 21498 | | |
| 21499 | | |
| 21500 | | |
| 21501 | | if test $pkg_failed = yes; then |
| 21502 | | |
| 21503 | | if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then |
| 21504 | | _pkg_short_errors_supported=yes |
| 21505 | | else |
| 21506 | | _pkg_short_errors_supported=no |
| 21507 | | fi |
| 21508 | | if test $_pkg_short_errors_supported = yes; then |
| 21509 | | JACK_PKG_ERRORS=`$PKG_CONFIG --short-errors --errors-to-stdout --print-errors "jack"` |
| 21510 | | else |
| 21511 | | JACK_PKG_ERRORS=`$PKG_CONFIG --errors-to-stdout --print-errors "jack"` |
| 21512 | | fi |
| 21513 | | # Put the nasty error message in config.log where it belongs |
| 21514 | | echo "$JACK_PKG_ERRORS" >&5 |
| 21515 | | |
| 21516 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 21517 | | echo "${ECHO_T}no" >&6; } |
| 21518 | | got_jack=no |
| 21519 | | elif test $pkg_failed = untried; then |
| 21520 | | got_jack=no |
| 21521 | | else |
| 21522 | | JACK_CFLAGS=$pkg_cv_JACK_CFLAGS |
| 21523 | | JACK_LIBS=$pkg_cv_JACK_LIBS |
| 21524 | | { echo "$as_me:$LINENO: result: yes" >&5 |
| 21525 | | echo "${ECHO_T}yes" >&6; } |
| 21526 | | got_jack=yes |
| 21527 | | fi |
| 21528 | | |
| 21529 | | |
| 21530 | | if test $got_jack = yes; then |
| 21531 | | HAVE_JACK_TRUE= |
| 21532 | | HAVE_JACK_FALSE='#' |
| 21533 | | else |
| 21534 | | HAVE_JACK_TRUE='#' |
| 21535 | | HAVE_JACK_FALSE= |
| 21536 | | fi |
| 21537 | | |
| 21538 | | if test "$got_jack" = "yes"; then |
| 21539 | | |
| 21540 | | cat >>confdefs.h <<_ACEOF |
| 21541 | | #define HAVE_JACK 1 |
| 21542 | | _ACEOF |
| 21543 | | |
| 21544 | | fi |
| 21545 | | |
| 21546 | | |
| 21547 | | |
| 21548 | | pkg_failed=no |
| 21549 | | { echo "$as_me:$LINENO: checking for ALSA" >&5 |
| 21550 | | echo $ECHO_N "checking for ALSA... $ECHO_C" >&6; } |
| 21551 | | |
| 21552 | | if test -n "$PKG_CONFIG"; then |
| 21553 | | if test -n "$ALSA_CFLAGS"; then |
| 21554 | | pkg_cv_ALSA_CFLAGS="$ALSA_CFLAGS" |
| 21555 | | else |
| 21556 | | if test -n "$PKG_CONFIG" && \ |
| 21557 | | { (echo "$as_me:$LINENO: \$PKG_CONFIG --exists --print-errors \"alsa\"") >&5 |
| 21558 | | ($PKG_CONFIG --exists --print-errors "alsa") 2>&5 |
| 21559 | | ac_status=$? |
| 21560 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 21561 | | (exit $ac_status); }; then |
| 21562 | | pkg_cv_ALSA_CFLAGS=`$PKG_CONFIG --cflags "alsa" 2>/dev/null` |
| 21563 | | else |
| 21564 | | pkg_failed=yes |
| 21565 | | fi |
| 21566 | | fi |
| 21567 | | else |
| 21568 | | pkg_failed=untried |
| 21569 | | fi |
| 21570 | | if test -n "$PKG_CONFIG"; then |
| 21571 | | if test -n "$ALSA_LIBS"; then |
| 21572 | | pkg_cv_ALSA_LIBS="$ALSA_LIBS" |
| 21573 | | else |
| 21574 | | if test -n "$PKG_CONFIG" && \ |
| 21575 | | { (echo "$as_me:$LINENO: \$PKG_CONFIG --exists --print-errors \"alsa\"") >&5 |
| 21576 | | ($PKG_CONFIG --exists --print-errors "alsa") 2>&5 |
| 21577 | | ac_status=$? |
| 21578 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 21579 | | (exit $ac_status); }; then |
| 21580 | | pkg_cv_ALSA_LIBS=`$PKG_CONFIG --libs "alsa" 2>/dev/null` |
| 21581 | | else |
| 21582 | | pkg_failed=yes |
| 21583 | | fi |
| 21584 | | fi |
| 21585 | | else |
| 21586 | | pkg_failed=untried |
| 21587 | | fi |
| 21588 | | |
| 21589 | | |
| 21590 | | |
| 21591 | | if test $pkg_failed = yes; then |
| 21592 | | |
| 21593 | | if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then |
| 21594 | | _pkg_short_errors_supported=yes |
| 21595 | | else |
| 21596 | | _pkg_short_errors_supported=no |
| 21597 | | fi |
| 21598 | | if test $_pkg_short_errors_supported = yes; then |
| 21599 | | ALSA_PKG_ERRORS=`$PKG_CONFIG --short-errors --errors-to-stdout --print-errors "alsa"` |
| 21600 | | else |
| 21601 | | ALSA_PKG_ERRORS=`$PKG_CONFIG --errors-to-stdout --print-errors "alsa"` |
| 21602 | | fi |
| 21603 | | # Put the nasty error message in config.log where it belongs |
| 21604 | | echo "$ALSA_PKG_ERRORS" >&5 |
| 21605 | | |
| 21606 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 21607 | | echo "${ECHO_T}no" >&6; } |
| 21608 | | got_alsa=no |
| 21609 | | elif test $pkg_failed = untried; then |
| 21610 | | got_alsa=no |
| 21611 | | else |
| 21612 | | ALSA_CFLAGS=$pkg_cv_ALSA_CFLAGS |
| 21613 | | ALSA_LIBS=$pkg_cv_ALSA_LIBS |
| 21614 | | { echo "$as_me:$LINENO: result: yes" >&5 |
| 21615 | | echo "${ECHO_T}yes" >&6; } |
| 21616 | | got_alsa=yes |
| 21617 | | fi |
| 21618 | | |
| 21619 | | |
| 21620 | | if test $got_alsa = yes; then |
| 21621 | | HAVE_ALSA_TRUE= |
| 21622 | | HAVE_ALSA_FALSE='#' |
| 21623 | | else |
| 21624 | | HAVE_ALSA_TRUE='#' |
| 21625 | | HAVE_ALSA_FALSE= |
| 21626 | | fi |
| 21627 | | |
| 21628 | | if test "$got_alsa" = "yes"; then |
| 21629 | | |
| 21630 | | cat >>confdefs.h <<_ACEOF |
| 21631 | | #define HAVE_ALSA 1 |
| 21632 | | _ACEOF |
| 21633 | | |
| 21634 | | fi |
| 21635 | | |
| 21636 | | |
| 21637 | | #AC_CHECK_LIB(asound, snd_pcm_writei,alsalib=yes,alsalib=no) |
| 21638 | | #AC_CHECK_HEADERS(alsa/asoundlib.h,alsaheader=yes,alsaheader=no) |
| 21639 | | #dnl FM_SERVER_LIBS="$FM_SERVER_LIBS -lasound" |
| 21640 | | #AM_CONDITIONAL(HAVE_ALSA, test $alsalib = yes && test $alsaheader = yes) |
| 21641 | | |
| 21642 | | |
| 21643 | | #AC_CHECK_LIB(jack,jack_activate,jacklib=yes,jacklib=no) |
| 21644 | | #AC_CHECK_HEADERS(jack/jack.h,jackheader=yes,jackheader=no) |
| 21645 | | #if test "$jacklib" = "yes"; then |
| 21646 | | # if test "$jackheader" = "yes"; then |
| 21647 | | # AC_DEFINE_UNQUOTED([USE_JACK], 1, [ Define to enable JACK audio backend.]) |
| 21648 | | # FM_SERVER_LIBS="$FM_SERVER_LIBS -ljack" |
| 21649 | | # AM_CONDITIONAL(USE_JACK, true) |
| 21650 | | # else |
| 21651 | | # AC_MSG_WARN([** Coulnd't find JACK header file jack/jack.h **]) |
| 21652 | | # fi |
| 21653 | | #else |
| 21654 | | # AC_MSG_WARN([** Coulnd'f find JACK library libjack. **]) |
| 21655 | | #fi |
| 21656 | | #AM_CONDITIONAL(HAVE_JACK, test $jacklib = yes && test $jackheader = yes) |
| 21657 | | |
| 21658 | | |
| 21659 | | |
| 21660 | | |
| 21661 | | for ac_func in sched_setscheduler |
| 21662 | | do |
| 21663 | | as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` |
| 21664 | | { echo "$as_me:$LINENO: checking for $ac_func" >&5 |
| 21665 | | echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; } |
| 21666 | | if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then |
| 21667 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 21668 | | else |
| 21669 | | cat >conftest.$ac_ext <<_ACEOF |
| 21670 | | /* confdefs.h. */ |
| 21671 | | _ACEOF |
| 21672 | | cat confdefs.h >>conftest.$ac_ext |
| 21673 | | cat >>conftest.$ac_ext <<_ACEOF |
| 21674 | | /* end confdefs.h. */ |
| 21675 | | /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. |
| 21676 | | For example, HP-UX 11i <limits.h> declares gettimeofday. */ |
| 21677 | | #define $ac_func innocuous_$ac_func |
| 21678 | | |
| 21679 | | /* System header to define __stub macros and hopefully few prototypes, |
| 21680 | | which can conflict with char $ac_func (); below. |
| 21681 | | Prefer <limits.h> to <assert.h> if __STDC__ is defined, since |
| 21682 | | <limits.h> exists even on freestanding compilers. */ |
| 21683 | | |
| 21684 | | #ifdef __STDC__ |
| 21685 | | # include <limits.h> |
| 21686 | | #else |
| 21687 | | # include <assert.h> |
| 21688 | | #endif |
| 21689 | | |
| 21690 | | #undef $ac_func |
| 21691 | | |
| 21692 | | /* Override any GCC internal prototype to avoid an error. |
| 21693 | | Use char because int might match the return type of a GCC |
| 21694 | | builtin and then its argument prototype would still apply. */ |
| 21695 | | #ifdef __cplusplus |
| 21696 | | extern "C" |
| 21697 | | #endif |
| 21698 | | char $ac_func (); |
| 21699 | | /* The GNU C library defines this for functions which it implements |
| 21700 | | to always fail with ENOSYS. Some functions are actually named |
| 21701 | | something starting with __ and the normal name is an alias. */ |
| 21702 | | #if defined __stub_$ac_func || defined __stub___$ac_func |
| 21703 | | choke me |
| 21704 | | #endif |
| 21705 | | |
| 21706 | | int |
| 21707 | | main () |
| 21708 | | { |
| 21709 | | return $ac_func (); |
| 21710 | | ; |
| 21711 | | return 0; |
| 21712 | | } |
| 21713 | | _ACEOF |
| 21714 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 21715 | | if { (ac_try="$ac_link" |
| 21716 | | case "(($ac_try" in |
| 21717 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 21718 | | *) ac_try_echo=$ac_try;; |
| 21719 | | esac |
| 21720 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 21721 | | (eval "$ac_link") 2>conftest.er1 |
| 21722 | | ac_status=$? |
| 21723 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 21724 | | rm -f conftest.er1 |
| 21725 | | cat conftest.err >&5 |
| 21726 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 21727 | | (exit $ac_status); } && { |
| 21728 | | test -z "$ac_c_werror_flag" || |
| 21729 | | test ! -s conftest.err |
| 21730 | | } && test -s conftest$ac_exeext && |
| 21731 | | $as_test_x conftest$ac_exeext; then |
| 21732 | | eval "$as_ac_var=yes" |
| 21733 | | else |
| 21734 | | echo "$as_me: failed program was:" >&5 |
| 21735 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 21736 | | |
| 21737 | | eval "$as_ac_var=no" |
| 21738 | | fi |
| 21739 | | |
| 21740 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 21741 | | conftest$ac_exeext conftest.$ac_ext |
| 21742 | | fi |
| 21743 | | ac_res=`eval echo '${'$as_ac_var'}'` |
| 21744 | | { echo "$as_me:$LINENO: result: $ac_res" >&5 |
| 21745 | | echo "${ECHO_T}$ac_res" >&6; } |
| 21746 | | if test `eval echo '${'$as_ac_var'}'` = yes; then |
| 21747 | | cat >>confdefs.h <<_ACEOF |
| 21748 | | #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1 |
| 21749 | | _ACEOF |
| 21750 | | |
| 21751 | | fi |
| 21752 | | done |
| 21753 | | |
| 21754 | | |
| 21755 | | |
| 21756 | | |
| 21757 | | |
| 21758 | | |
| 21759 | | |
| 21760 | | |
| 21761 | | for ac_func in malloc calloc free memcpy memmove |
| 21762 | | do |
| 21763 | | as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` |
| 21764 | | { echo "$as_me:$LINENO: checking for $ac_func" >&5 |
| 21765 | | echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; } |
| 21766 | | if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then |
| 21767 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 21768 | | else |
| 21769 | | cat >conftest.$ac_ext <<_ACEOF |
| 21770 | | /* confdefs.h. */ |
| 21771 | | _ACEOF |
| 21772 | | cat confdefs.h >>conftest.$ac_ext |
| 21773 | | cat >>conftest.$ac_ext <<_ACEOF |
| 21774 | | /* end confdefs.h. */ |
| 21775 | | /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. |
| 21776 | | For example, HP-UX 11i <limits.h> declares gettimeofday. */ |
| 21777 | | #define $ac_func innocuous_$ac_func |
| 21778 | | |
| 21779 | | /* System header to define __stub macros and hopefully few prototypes, |
| 21780 | | which can conflict with char $ac_func (); below. |
| 21781 | | Prefer <limits.h> to <assert.h> if __STDC__ is defined, since |
| 21782 | | <limits.h> exists even on freestanding compilers. */ |
| 21783 | | |
| 21784 | | #ifdef __STDC__ |
| 21785 | | # include <limits.h> |
| 21786 | | #else |
| 21787 | | # include <assert.h> |
| 21788 | | #endif |
| 21789 | | |
| 21790 | | #undef $ac_func |
| 21791 | | |
| 21792 | | /* Override any GCC internal prototype to avoid an error. |
| 21793 | | Use char because int might match the return type of a GCC |
| 21794 | | builtin and then its argument prototype would still apply. */ |
| 21795 | | #ifdef __cplusplus |
| 21796 | | extern "C" |
| 21797 | | #endif |
| 21798 | | char $ac_func (); |
| 21799 | | /* The GNU C library defines this for functions which it implements |
| 21800 | | to always fail with ENOSYS. Some functions are actually named |
| 21801 | | something starting with __ and the normal name is an alias. */ |
| 21802 | | #if defined __stub_$ac_func || defined __stub___$ac_func |
| 21803 | | choke me |
| 21804 | | #endif |
| 21805 | | |
| 21806 | | int |
| 21807 | | main () |
| 21808 | | { |
| 21809 | | return $ac_func (); |
| 21810 | | ; |
| 21811 | | return 0; |
| 21812 | | } |
| 21813 | | _ACEOF |
| 21814 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 21815 | | if { (ac_try="$ac_link" |
| 21816 | | case "(($ac_try" in |
| 21817 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 21818 | | *) ac_try_echo=$ac_try;; |
| 21819 | | esac |
| 21820 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 21821 | | (eval "$ac_link") 2>conftest.er1 |
| 21822 | | ac_status=$? |
| 21823 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 21824 | | rm -f conftest.er1 |
| 21825 | | cat conftest.err >&5 |
| 21826 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 21827 | | (exit $ac_status); } && { |
| 21828 | | test -z "$ac_c_werror_flag" || |
| 21829 | | test ! -s conftest.err |
| 21830 | | } && test -s conftest$ac_exeext && |
| 21831 | | $as_test_x conftest$ac_exeext; then |
| 21832 | | eval "$as_ac_var=yes" |
| 21833 | | else |
| 21834 | | echo "$as_me: failed program was:" >&5 |
| 21835 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 21836 | | |
| 21837 | | eval "$as_ac_var=no" |
| 21838 | | fi |
| 21839 | | |
| 21840 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 21841 | | conftest$ac_exeext conftest.$ac_ext |
| 21842 | | fi |
| 21843 | | ac_res=`eval echo '${'$as_ac_var'}'` |
| 21844 | | { echo "$as_me:$LINENO: result: $ac_res" >&5 |
| 21845 | | echo "${ECHO_T}$ac_res" >&6; } |
| 21846 | | if test `eval echo '${'$as_ac_var'}'` = yes; then |
| 21847 | | cat >>confdefs.h <<_ACEOF |
| 21848 | | #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1 |
| 21849 | | _ACEOF |
| 21850 | | |
| 21851 | | fi |
| 21852 | | done |
| 21853 | | |
| 21854 | | |
| 21855 | | |
| 21856 | | { echo "$as_me:$LINENO: checking for floor in -lm" >&5 |
| 21857 | | echo $ECHO_N "checking for floor in -lm... $ECHO_C" >&6; } |
| 21858 | | if test "${ac_cv_lib_m_floor+set}" = set; then |
| 21859 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 21860 | | else |
| 21861 | | ac_check_lib_save_LIBS=$LIBS |
| 21862 | | LIBS="-lm $LIBS" |
| 21863 | | cat >conftest.$ac_ext <<_ACEOF |
| 21864 | | /* confdefs.h. */ |
| 21865 | | _ACEOF |
| 21866 | | cat confdefs.h >>conftest.$ac_ext |
| 21867 | | cat >>conftest.$ac_ext <<_ACEOF |
| 21868 | | /* end confdefs.h. */ |
| 21869 | | |
| 21870 | | /* Override any GCC internal prototype to avoid an error. |
| 21871 | | Use char because int might match the return type of a GCC |
| 21872 | | builtin and then its argument prototype would still apply. */ |
| 21873 | | #ifdef __cplusplus |
| 21874 | | extern "C" |
| 21875 | | #endif |
| 21876 | | char floor (); |
| 21877 | | int |
| 21878 | | main () |
| 21879 | | { |
| 21880 | | return floor (); |
| 21881 | | ; |
| 21882 | | return 0; |
| 21883 | | } |
| 21884 | | _ACEOF |
| 21885 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 21886 | | if { (ac_try="$ac_link" |
| 21887 | | case "(($ac_try" in |
| 21888 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 21889 | | *) ac_try_echo=$ac_try;; |
| 21890 | | esac |
| 21891 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 21892 | | (eval "$ac_link") 2>conftest.er1 |
| 21893 | | ac_status=$? |
| 21894 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 21895 | | rm -f conftest.er1 |
| 21896 | | cat conftest.err >&5 |
| 21897 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 21898 | | (exit $ac_status); } && { |
| 21899 | | test -z "$ac_c_werror_flag" || |
| 21900 | | test ! -s conftest.err |
| 21901 | | } && test -s conftest$ac_exeext && |
| 21902 | | $as_test_x conftest$ac_exeext; then |
| 21903 | | ac_cv_lib_m_floor=yes |
| 21904 | | else |
| 21905 | | echo "$as_me: failed program was:" >&5 |
| 21906 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 21907 | | |
| 21908 | | ac_cv_lib_m_floor=no |
| 21909 | | fi |
| 21910 | | |
| 21911 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 21912 | | conftest$ac_exeext conftest.$ac_ext |
| 21913 | | LIBS=$ac_check_lib_save_LIBS |
| 21914 | | fi |
| 21915 | | { echo "$as_me:$LINENO: result: $ac_cv_lib_m_floor" >&5 |
| 21916 | | echo "${ECHO_T}$ac_cv_lib_m_floor" >&6; } |
| 21917 | | if test $ac_cv_lib_m_floor = yes; then |
| 21918 | | cat >>confdefs.h <<_ACEOF |
| 21919 | | #define HAVE_LIBM 1 |
| 21920 | | _ACEOF |
| 21921 | | |
| 21922 | | LIBS="-lm $LIBS" |
| 21923 | | |
| 21924 | | fi |
| 21925 | | |
| 21926 | | |
| 21927 | | |
| 21928 | | |
| 21929 | | for ac_func in floor ceil fmod |
| 21930 | | do |
| 21931 | | as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` |
| 21932 | | { echo "$as_me:$LINENO: checking for $ac_func" >&5 |
| 21933 | | echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; } |
| 21934 | | if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then |
| 21935 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 21936 | | else |
| 21937 | | cat >conftest.$ac_ext <<_ACEOF |
| 21938 | | /* confdefs.h. */ |
| 21939 | | _ACEOF |
| 21940 | | cat confdefs.h >>conftest.$ac_ext |
| 21941 | | cat >>conftest.$ac_ext <<_ACEOF |
| 21942 | | /* end confdefs.h. */ |
| 21943 | | /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. |
| 21944 | | For example, HP-UX 11i <limits.h> declares gettimeofday. */ |
| 21945 | | #define $ac_func innocuous_$ac_func |
| 21946 | | |
| 21947 | | /* System header to define __stub macros and hopefully few prototypes, |
| 21948 | | which can conflict with char $ac_func (); below. |
| 21949 | | Prefer <limits.h> to <assert.h> if __STDC__ is defined, since |
| 21950 | | <limits.h> exists even on freestanding compilers. */ |
| 21951 | | |
| 21952 | | #ifdef __STDC__ |
| 21953 | | # include <limits.h> |
| 21954 | | #else |
| 21955 | | # include <assert.h> |
| 21956 | | #endif |
| 21957 | | |
| 21958 | | #undef $ac_func |
| 21959 | | |
| 21960 | | /* Override any GCC internal prototype to avoid an error. |
| 21961 | | Use char because int might match the return type of a GCC |
| 21962 | | builtin and then its argument prototype would still apply. */ |
| 21963 | | #ifdef __cplusplus |
| 21964 | | extern "C" |
| 21965 | | #endif |
| 21966 | | char $ac_func (); |
| 21967 | | /* The GNU C library defines this for functions which it implements |
| 21968 | | to always fail with ENOSYS. Some functions are actually named |
| 21969 | | something starting with __ and the normal name is an alias. */ |
| 21970 | | #if defined __stub_$ac_func || defined __stub___$ac_func |
| 21971 | | choke me |
| 21972 | | #endif |
| 21973 | | |
| 21974 | | int |
| 21975 | | main () |
| 21976 | | { |
| 21977 | | return $ac_func (); |
| 21978 | | ; |
| 21979 | | return 0; |
| 21980 | | } |
| 21981 | | _ACEOF |
| 21982 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 21983 | | if { (ac_try="$ac_link" |
| 21984 | | case "(($ac_try" in |
| 21985 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 21986 | | *) ac_try_echo=$ac_try;; |
| 21987 | | esac |
| 21988 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 21989 | | (eval "$ac_link") 2>conftest.er1 |
| 21990 | | ac_status=$? |
| 21991 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 21992 | | rm -f conftest.er1 |
| 21993 | | cat conftest.err >&5 |
| 21994 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 21995 | | (exit $ac_status); } && { |
| 21996 | | test -z "$ac_c_werror_flag" || |
| 21997 | | test ! -s conftest.err |
| 21998 | | } && test -s conftest$ac_exeext && |
| 21999 | | $as_test_x conftest$ac_exeext; then |
| 22000 | | eval "$as_ac_var=yes" |
| 22001 | | else |
| 22002 | | echo "$as_me: failed program was:" >&5 |
| 22003 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 22004 | | |
| 22005 | | eval "$as_ac_var=no" |
| 22006 | | fi |
| 22007 | | |
| 22008 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 22009 | | conftest$ac_exeext conftest.$ac_ext |
| 22010 | | fi |
| 22011 | | ac_res=`eval echo '${'$as_ac_var'}'` |
| 22012 | | { echo "$as_me:$LINENO: result: $ac_res" >&5 |
| 22013 | | echo "${ECHO_T}$ac_res" >&6; } |
| 22014 | | if test `eval echo '${'$as_ac_var'}'` = yes; then |
| 22015 | | cat >>confdefs.h <<_ACEOF |
| 22016 | | #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1 |
| 22017 | | _ACEOF |
| 22018 | | |
| 22019 | | fi |
| 22020 | | done |
| 22021 | | |
| 22022 | | |
| 22023 | | { echo "$as_me:$LINENO: checking for lrint" >&5 |
| 22024 | | echo $ECHO_N "checking for lrint... $ECHO_C" >&6; } |
| 22025 | | if test "${ac_cv_c99_lrint+set}" = set; then |
| 22026 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 22027 | | else |
| 22028 | | |
| 22029 | | lrint_save_CFLAGS=$CFLAGS |
| 22030 | | CFLAGS="-O2 -lm" |
| 22031 | | cat >conftest.$ac_ext <<_ACEOF |
| 22032 | | /* confdefs.h. */ |
| 22033 | | _ACEOF |
| 22034 | | cat confdefs.h >>conftest.$ac_ext |
| 22035 | | cat >>conftest.$ac_ext <<_ACEOF |
| 22036 | | /* end confdefs.h. */ |
| 22037 | | |
| 22038 | | #define _ISOC9X_SOURCE 1 |
| 22039 | | #define _ISOC99_SOURCE 1 |
| 22040 | | #define __USE_ISOC99 1 |
| 22041 | | #define __USE_ISOC9X 1 |
| 22042 | | |
| 22043 | | #include <math.h> |
| 22044 | | |
| 22045 | | int |
| 22046 | | main () |
| 22047 | | { |
| 22048 | | if (!lrint(3.14159)) lrint(2.7183); |
| 22049 | | ; |
| 22050 | | return 0; |
| 22051 | | } |
| 22052 | | _ACEOF |
| 22053 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 22054 | | if { (ac_try="$ac_link" |
| 22055 | | case "(($ac_try" in |
| 22056 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 22057 | | *) ac_try_echo=$ac_try;; |
| 22058 | | esac |
| 22059 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 22060 | | (eval "$ac_link") 2>conftest.er1 |
| 22061 | | ac_status=$? |
| 22062 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 22063 | | rm -f conftest.er1 |
| 22064 | | cat conftest.err >&5 |
| 22065 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 22066 | | (exit $ac_status); } && { |
| 22067 | | test -z "$ac_c_werror_flag" || |
| 22068 | | test ! -s conftest.err |
| 22069 | | } && test -s conftest$ac_exeext && |
| 22070 | | $as_test_x conftest$ac_exeext; then |
| 22071 | | ac_cv_c99_lrint=yes |
| 22072 | | else |
| 22073 | | echo "$as_me: failed program was:" >&5 |
| 22074 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 22075 | | |
| 22076 | | ac_cv_c99_lrint=no |
| 22077 | | fi |
| 22078 | | |
| 22079 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 22080 | | conftest$ac_exeext conftest.$ac_ext |
| 22081 | | |
| 22082 | | CFLAGS=$lrint_save_CFLAGS |
| 22083 | | |
| 22084 | | |
| 22085 | | fi |
| 22086 | | { echo "$as_me:$LINENO: result: $ac_cv_c99_lrint" >&5 |
| 22087 | | echo "${ECHO_T}$ac_cv_c99_lrint" >&6; } |
| 22088 | | |
| 22089 | | if test "$ac_cv_c99_lrint" = yes; then |
| 22090 | | |
| 22091 | | cat >>confdefs.h <<\_ACEOF |
| 22092 | | #define HAVE_LRINT 1 |
| 22093 | | _ACEOF |
| 22094 | | |
| 22095 | | fi |
| 22096 | | |
| 22097 | | { echo "$as_me:$LINENO: checking for lrintf" >&5 |
| 22098 | | echo $ECHO_N "checking for lrintf... $ECHO_C" >&6; } |
| 22099 | | if test "${ac_cv_c99_lrintf+set}" = set; then |
| 22100 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 22101 | | else |
| 22102 | | |
| 22103 | | lrintf_save_CFLAGS=$CFLAGS |
| 22104 | | CFLAGS="-O2 -lm" |
| 22105 | | cat >conftest.$ac_ext <<_ACEOF |
| 22106 | | /* confdefs.h. */ |
| 22107 | | _ACEOF |
| 22108 | | cat confdefs.h >>conftest.$ac_ext |
| 22109 | | cat >>conftest.$ac_ext <<_ACEOF |
| 22110 | | /* end confdefs.h. */ |
| 22111 | | |
| 22112 | | #define _ISOC9X_SOURCE 1 |
| 22113 | | #define _ISOC99_SOURCE 1 |
| 22114 | | #define __USE_ISOC99 1 |
| 22115 | | #define __USE_ISOC9X 1 |
| 22116 | | |
| 22117 | | #include <math.h> |
| 22118 | | |
| 22119 | | int |
| 22120 | | main () |
| 22121 | | { |
| 22122 | | if (!lrintf(3.14159)) lrintf(2.7183); |
| 22123 | | ; |
| 22124 | | return 0; |
| 22125 | | } |
| 22126 | | _ACEOF |
| 22127 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 22128 | | if { (ac_try="$ac_link" |
| 22129 | | case "(($ac_try" in |
| 22130 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 22131 | | *) ac_try_echo=$ac_try;; |
| 22132 | | esac |
| 22133 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 22134 | | (eval "$ac_link") 2>conftest.er1 |
| 22135 | | ac_status=$? |
| 22136 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 22137 | | rm -f conftest.er1 |
| 22138 | | cat conftest.err >&5 |
| 22139 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 22140 | | (exit $ac_status); } && { |
| 22141 | | test -z "$ac_c_werror_flag" || |
| 22142 | | test ! -s conftest.err |
| 22143 | | } && test -s conftest$ac_exeext && |
| 22144 | | $as_test_x conftest$ac_exeext; then |
| 22145 | | ac_cv_c99_lrintf=yes |
| 22146 | | else |
| 22147 | | echo "$as_me: failed program was:" >&5 |
| 22148 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 22149 | | |
| 22150 | | ac_cv_c99_lrintf=no |
| 22151 | | fi |
| 22152 | | |
| 22153 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 22154 | | conftest$ac_exeext conftest.$ac_ext |
| 22155 | | |
| 22156 | | CFLAGS=$lrintf_save_CFLAGS |
| 22157 | | |
| 22158 | | |
| 22159 | | fi |
| 22160 | | { echo "$as_me:$LINENO: result: $ac_cv_c99_lrintf" >&5 |
| 22161 | | echo "${ECHO_T}$ac_cv_c99_lrintf" >&6; } |
| 22162 | | |
| 22163 | | if test "$ac_cv_c99_lrintf" = yes; then |
| 22164 | | |
| 22165 | | cat >>confdefs.h <<\_ACEOF |
| 22166 | | #define HAVE_LRINTF 1 |
| 22167 | | _ACEOF |
| 22168 | | |
| 22169 | | fi |
| 22170 | | |
| 22171 | | # AC_C99_FUNC_LLRINT Don't need this (yet?). |
| 22172 | | |
| 22173 | | case "x$ac_cv_c99_lrint$ac_cv_c99_lrintf" in |
| 22174 | | xyesyes) |
| 22175 | | ;; |
| 22176 | | *) |
| 22177 | | { echo "$as_me:$LINENO: WARNING: *** Missing C99 standard functions lrint() and lrintf()." >&5 |
| 22178 | | echo "$as_me: WARNING: *** Missing C99 standard functions lrint() and lrintf()." >&2;} |
| 22179 | | { echo "$as_me:$LINENO: WARNING: *** This may cause benign compiler warnings on some systems (ie Solaris)." >&5 |
| 22180 | | echo "$as_me: WARNING: *** This may cause benign compiler warnings on some systems (ie Solaris)." >&2;} |
| 22181 | | ;; |
| 22182 | | esac |
| 22183 | | |
| 22184 | | |
| 22185 | | # Determine if the processor can do clipping on float to int conversions. |
| 22186 | | |
| 22187 | | if test x$ac_arg_cpu_clip = "xY" ; then |
| 22188 | | { echo "$as_me:$LINENO: checking processor clipping capabilities" >&5 |
| 22189 | | echo $ECHO_N "checking processor clipping capabilities... $ECHO_C" >&6; } |
| 22190 | | if test "${ac_cv_c_clip_type+set}" = set; then |
| 22191 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 22192 | | else |
| 22193 | | # Initialize to unknown |
| 22194 | | ac_cv_c_clip_positive=unknown |
| 22195 | | ac_cv_c_clip_negative=unknown |
| 22196 | | |
| 22197 | | if test $ac_cv_c_clip_positive = unknown ; then |
| 22198 | | if test "$cross_compiling" = yes; then |
| 22199 | | ac_cv_c_clip_positive=unknown |
| 22200 | | |
| 22201 | | else |
| 22202 | | cat >conftest.$ac_ext <<_ACEOF |
| 22203 | | /* confdefs.h. */ |
| 22204 | | _ACEOF |
| 22205 | | cat confdefs.h >>conftest.$ac_ext |
| 22206 | | cat >>conftest.$ac_ext <<_ACEOF |
| 22207 | | /* end confdefs.h. */ |
| 22208 | | |
| 22209 | | #define _ISOC9X_SOURCE 1 |
| 22210 | | #define _ISOC99_SOURCE 1 |
| 22211 | | #define __USE_ISOC99 1 |
| 22212 | | #define __USE_ISOC9X 1 |
| 22213 | | #include <math.h> |
| 22214 | | int main (void) |
| 22215 | | { double fval ; |
| 22216 | | int k, ival ; |
| 22217 | | |
| 22218 | | fval = 1.0 * 0x7FFFFFFF ; |
| 22219 | | for (k = 0 ; k < 100 ; k++) |
| 22220 | | { ival = (lrint (fval)) >> 24 ; |
| 22221 | | if (ival != 127) |
| 22222 | | return 1 ; |
| 22223 | | |
| 22224 | | fval *= 1.2499999 ; |
| 22225 | | } ; |
| 22226 | | |
| 22227 | | return 0 ; |
| 22228 | | } |
| 22229 | | |
| 22230 | | _ACEOF |
| 22231 | | rm -f conftest$ac_exeext |
| 22232 | | if { (ac_try="$ac_link" |
| 22233 | | case "(($ac_try" in |
| 22234 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 22235 | | *) ac_try_echo=$ac_try;; |
| 22236 | | esac |
| 22237 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 22238 | | (eval "$ac_link") 2>&5 |
| 22239 | | ac_status=$? |
| 22240 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 22241 | | (exit $ac_status); } && { ac_try='./conftest$ac_exeext' |
| 22242 | | { (case "(($ac_try" in |
| 22243 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 22244 | | *) ac_try_echo=$ac_try;; |
| 22245 | | esac |
| 22246 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 22247 | | (eval "$ac_try") 2>&5 |
| 22248 | | ac_status=$? |
| 22249 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 22250 | | (exit $ac_status); }; }; then |
| 22251 | | ac_cv_c_clip_positive=yes |
| 22252 | | else |
| 22253 | | echo "$as_me: program exited with status $ac_status" >&5 |
| 22254 | | echo "$as_me: failed program was:" >&5 |
| 22255 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 22256 | | |
| 22257 | | ( exit $ac_status ) |
| 22258 | | ac_cv_c_clip_positive=no |
| 22259 | | fi |
| 22260 | | rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext |
| 22261 | | fi |
| 22262 | | |
| 22263 | | |
| 22264 | | |
| 22265 | | if test "$cross_compiling" = yes; then |
| 22266 | | ac_cv_c_clip_negative=unknown |
| 22267 | | |
| 22268 | | else |
| 22269 | | cat >conftest.$ac_ext <<_ACEOF |
| 22270 | | /* confdefs.h. */ |
| 22271 | | _ACEOF |
| 22272 | | cat confdefs.h >>conftest.$ac_ext |
| 22273 | | cat >>conftest.$ac_ext <<_ACEOF |
| 22274 | | /* end confdefs.h. */ |
| 22275 | | |
| 22276 | | #define _ISOC9X_SOURCE 1 |
| 22277 | | #define _ISOC99_SOURCE 1 |
| 22278 | | #define __USE_ISOC99 1 |
| 22279 | | #define __USE_ISOC9X 1 |
| 22280 | | #include <math.h> |
| 22281 | | int main (void) |
| 22282 | | { double fval ; |
| 22283 | | int k, ival ; |
| 22284 | | |
| 22285 | | fval = -8.0 * 0x10000000 ; |
| 22286 | | for (k = 0 ; k < 100 ; k++) |
| 22287 | | { ival = (lrint (fval)) >> 24 ; |
| 22288 | | if (ival != -128) |
| 22289 | | return 1 ; |
| 22290 | | |
| 22291 | | fval *= 1.2499999 ; |
| 22292 | | } ; |
| 22293 | | |
| 22294 | | return 0 ; |
| 22295 | | } |
| 22296 | | |
| 22297 | | _ACEOF |
| 22298 | | rm -f conftest$ac_exeext |
| 22299 | | if { (ac_try="$ac_link" |
| 22300 | | case "(($ac_try" in |
| 22301 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 22302 | | *) ac_try_echo=$ac_try;; |
| 22303 | | esac |
| 22304 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 22305 | | (eval "$ac_link") 2>&5 |
| 22306 | | ac_status=$? |
| 22307 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 22308 | | (exit $ac_status); } && { ac_try='./conftest$ac_exeext' |
| 22309 | | { (case "(($ac_try" in |
| 22310 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 22311 | | *) ac_try_echo=$ac_try;; |
| 22312 | | esac |
| 22313 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 22314 | | (eval "$ac_try") 2>&5 |
| 22315 | | ac_status=$? |
| 22316 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 22317 | | (exit $ac_status); }; }; then |
| 22318 | | ac_cv_c_clip_negative=yes |
| 22319 | | else |
| 22320 | | echo "$as_me: program exited with status $ac_status" >&5 |
| 22321 | | echo "$as_me: failed program was:" >&5 |
| 22322 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 22323 | | |
| 22324 | | ( exit $ac_status ) |
| 22325 | | ac_cv_c_clip_negative=no |
| 22326 | | fi |
| 22327 | | rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext |
| 22328 | | fi |
| 22329 | | |
| 22330 | | |
| 22331 | | |
| 22332 | | fi |
| 22333 | | |
| 22334 | | if test $ac_cv_c_clip_positive = yes ; then |
| 22335 | | ac_cv_c_clip_positive=1 |
| 22336 | | else |
| 22337 | | ac_cv_c_clip_positive=0 |
| 22338 | | fi |
| 22339 | | |
| 22340 | | if test $ac_cv_c_clip_negative = yes ; then |
| 22341 | | ac_cv_c_clip_negative=1 |
| 22342 | | else |
| 22343 | | ac_cv_c_clip_negative=0 |
| 22344 | | fi |
| 22345 | | |
| 22346 | | |
| 22347 | | case "$ac_cv_c_clip_positive$ac_cv_c_clip_negative" in |
| 22348 | | "00") |
| 22349 | | ac_cv_c_clip_type="none" |
| 22350 | | ;; |
| 22351 | | "10") |
| 22352 | | ac_cv_c_clip_type="positive" |
| 22353 | | ;; |
| 22354 | | "01") |
| 22355 | | ac_cv_c_clip_type="negative" |
| 22356 | | ;; |
| 22357 | | "11") |
| 22358 | | ac_cv_c_clip_type="both" |
| 22359 | | ;; |
| 22360 | | esac |
| 22361 | | |
| 22362 | | |
| 22363 | | |
| 22364 | | fi |
| 22365 | | { echo "$as_me:$LINENO: result: $ac_cv_c_clip_type" >&5 |
| 22366 | | echo "${ECHO_T}$ac_cv_c_clip_type" >&6; } |
| 22367 | | |
| 22368 | | |
| 22369 | | |
| 22370 | | else |
| 22371 | | echo "checking processor clipping capabilities... disabled" |
| 22372 | | ac_cv_c_clip_positive=0 |
| 22373 | | ac_cv_c_clip_negative=0 |
| 22374 | | fi |
| 22375 | | |
| 22376 | | |
| 22377 | | cat >>confdefs.h <<_ACEOF |
| 22378 | | #define CPU_CLIPS_POSITIVE ${ac_cv_c_clip_positive} |
| 22379 | | _ACEOF |
| 22380 | | |
| 22381 | | |
| 22382 | | cat >>confdefs.h <<_ACEOF |
| 22383 | | #define CPU_CLIPS_NEGATIVE ${ac_cv_c_clip_negative} |
| 22384 | | _ACEOF |
| 22385 | | |
| 22386 | | |
| 22387 | | |
| 22388 | | |
| 22389 | | |
| 22390 | | |
| 22391 | | GETTEXT_PACKAGE=fm_server |
| 22392 | | |
| 22393 | | |
| 22394 | | cat >>confdefs.h <<_ACEOF |
| 22395 | | #define GETTEXT_PACKAGE "$GETTEXT_PACKAGE" |
| 22396 | | _ACEOF |
| 22397 | | |
| 22398 | | |
| 22399 | | |
| 22400 | | ALL_LINGUAS="" |
| 22401 | | |
| 22696 | | { echo "$as_me:$LINENO: checking whether we are using the GNU C Library 2 or newer" >&5 |
| 22697 | | echo $ECHO_N "checking whether we are using the GNU C Library 2 or newer... $ECHO_C" >&6; } |
| 22698 | | if test "${ac_cv_gnu_library_2+set}" = set; then |
| 22699 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 22700 | | else |
| 22701 | | cat >conftest.$ac_ext <<_ACEOF |
| 22702 | | /* confdefs.h. */ |
| 22703 | | _ACEOF |
| 22704 | | cat confdefs.h >>conftest.$ac_ext |
| 22705 | | cat >>conftest.$ac_ext <<_ACEOF |
| 22706 | | /* end confdefs.h. */ |
| 22707 | | |
| 22708 | | #include <features.h> |
| 22709 | | #ifdef __GNU_LIBRARY__ |
| 22710 | | #if (__GLIBC__ >= 2) |
| 22711 | | Lucky GNU user |
| 22712 | | #endif |
| 22713 | | #endif |
| 22714 | | |
| 22715 | | _ACEOF |
| 22716 | | if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | |
| 22717 | | $EGREP "Lucky GNU user" >/dev/null 2>&1; then |
| 22718 | | ac_cv_gnu_library_2=yes |
| 22719 | | else |
| 22720 | | ac_cv_gnu_library_2=no |
| 22721 | | fi |
| 22722 | | rm -f conftest* |
| 22723 | | |
| 22724 | | |
| 22725 | | |
| 22726 | | fi |
| 22727 | | { echo "$as_me:$LINENO: result: $ac_cv_gnu_library_2" >&5 |
| 22728 | | echo "${ECHO_T}$ac_cv_gnu_library_2" >&6; } |
| 22729 | | |
| 22730 | | GLIBC2="$ac_cv_gnu_library_2" |
| 22731 | | |
| 22732 | | |
| 22733 | | if test -n "$ac_tool_prefix"; then |
| 22734 | | # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. |
| 22735 | | set dummy ${ac_tool_prefix}ranlib; ac_word=$2 |
| 22736 | | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| 22737 | | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| 22738 | | if test "${ac_cv_prog_RANLIB+set}" = set; then |
| 22739 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 22740 | | else |
| 22741 | | if test -n "$RANLIB"; then |
| 22742 | | ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. |
| 22743 | | else |
| 22744 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 22745 | | for as_dir in $PATH |
| 22746 | | do |
| 22747 | | IFS=$as_save_IFS |
| 22748 | | test -z "$as_dir" && as_dir=. |
| 22749 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 22750 | | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| 22751 | | ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib" |
| 22752 | | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| 22753 | | break 2 |
| 22754 | | fi |
| 22755 | | done |
| 22756 | | done |
| 22757 | | IFS=$as_save_IFS |
| 22758 | | |
| 22759 | | fi |
| 22760 | | fi |
| 22761 | | RANLIB=$ac_cv_prog_RANLIB |
| 22762 | | if test -n "$RANLIB"; then |
| 22763 | | { echo "$as_me:$LINENO: result: $RANLIB" >&5 |
| 22764 | | echo "${ECHO_T}$RANLIB" >&6; } |
| 22765 | | else |
| 22766 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 22767 | | echo "${ECHO_T}no" >&6; } |
| 22768 | | fi |
| 22769 | | |
| 22770 | | |
| 22771 | | fi |
| 22772 | | if test -z "$ac_cv_prog_RANLIB"; then |
| 22773 | | ac_ct_RANLIB=$RANLIB |
| 22774 | | # Extract the first word of "ranlib", so it can be a program name with args. |
| 22775 | | set dummy ranlib; ac_word=$2 |
| 22776 | | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| 22777 | | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| 22778 | | if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then |
| 22779 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 22780 | | else |
| 22781 | | if test -n "$ac_ct_RANLIB"; then |
| 22782 | | ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test. |
| 22783 | | else |
| 22784 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 22785 | | for as_dir in $PATH |
| 22786 | | do |
| 22787 | | IFS=$as_save_IFS |
| 22788 | | test -z "$as_dir" && as_dir=. |
| 22789 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 22790 | | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| 22791 | | ac_cv_prog_ac_ct_RANLIB="ranlib" |
| 22792 | | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| 22793 | | break 2 |
| 22794 | | fi |
| 22795 | | done |
| 22796 | | done |
| 22797 | | IFS=$as_save_IFS |
| 22798 | | |
| 22799 | | fi |
| 22800 | | fi |
| 22801 | | ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB |
| 22802 | | if test -n "$ac_ct_RANLIB"; then |
| 22803 | | { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5 |
| 22804 | | echo "${ECHO_T}$ac_ct_RANLIB" >&6; } |
| 22805 | | else |
| 22806 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 22807 | | echo "${ECHO_T}no" >&6; } |
| 22808 | | fi |
| 22809 | | |
| 22810 | | if test "x$ac_ct_RANLIB" = x; then |
| 22811 | | RANLIB=":" |
| 22812 | | else |
| 22813 | | case $cross_compiling:$ac_tool_warned in |
| 22814 | | yes:) |
| 22815 | | { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools |
| 22816 | | whose name does not start with the host triplet. If you think this |
| 22817 | | configuration is useful to you, please write to autoconf@gnu.org." >&5 |
| 22818 | | echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools |
| 22819 | | whose name does not start with the host triplet. If you think this |
| 22820 | | configuration is useful to you, please write to autoconf@gnu.org." >&2;} |
| 22821 | | ac_tool_warned=yes ;; |
| 22822 | | esac |
| 22823 | | RANLIB=$ac_ct_RANLIB |
| 22824 | | fi |
| 22825 | | else |
| 22826 | | RANLIB="$ac_cv_prog_RANLIB" |
| 22827 | | fi |
| 22828 | | |
| 22829 | | |
| 22830 | | |
| 22831 | | CFLAG_VISIBILITY= |
| 22832 | | HAVE_VISIBILITY=0 |
| 22833 | | if test -n "$GCC"; then |
| 22834 | | { echo "$as_me:$LINENO: checking for simple visibility declarations" >&5 |
| 22835 | | echo $ECHO_N "checking for simple visibility declarations... $ECHO_C" >&6; } |
| 22836 | | if test "${gl_cv_cc_visibility+set}" = set; then |
| 22837 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 22838 | | else |
| 22839 | | |
| 22840 | | gl_save_CFLAGS="$CFLAGS" |
| 22841 | | CFLAGS="$CFLAGS -fvisibility=hidden" |
| 22842 | | cat >conftest.$ac_ext <<_ACEOF |
| 22843 | | /* confdefs.h. */ |
| 22844 | | _ACEOF |
| 22845 | | cat confdefs.h >>conftest.$ac_ext |
| 22846 | | cat >>conftest.$ac_ext <<_ACEOF |
| 22847 | | /* end confdefs.h. */ |
| 22848 | | extern __attribute__((__visibility__("hidden"))) int hiddenvar; |
| 22849 | | extern __attribute__((__visibility__("default"))) int exportedvar; |
| 22850 | | extern __attribute__((__visibility__("hidden"))) int hiddenfunc (void); |
| 22851 | | extern __attribute__((__visibility__("default"))) int exportedfunc (void); |
| 22852 | | int |
| 22853 | | main () |
| 22854 | | { |
| 22855 | | |
| 22856 | | ; |
| 22857 | | return 0; |
| 22858 | | } |
| 22859 | | _ACEOF |
| 22860 | | rm -f conftest.$ac_objext |
| 22861 | | if { (ac_try="$ac_compile" |
| 22862 | | case "(($ac_try" in |
| 22863 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 22864 | | *) ac_try_echo=$ac_try;; |
| 22865 | | esac |
| 22866 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 22867 | | (eval "$ac_compile") 2>conftest.er1 |
| 22868 | | ac_status=$? |
| 22869 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 22870 | | rm -f conftest.er1 |
| 22871 | | cat conftest.err >&5 |
| 22872 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 22873 | | (exit $ac_status); } && { |
| 22874 | | test -z "$ac_c_werror_flag" || |
| 22875 | | test ! -s conftest.err |
| 22876 | | } && test -s conftest.$ac_objext; then |
| 22877 | | gl_cv_cc_visibility=yes |
| 22878 | | else |
| 22879 | | echo "$as_me: failed program was:" >&5 |
| 22880 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 22881 | | |
| 22882 | | gl_cv_cc_visibility=no |
| 22883 | | fi |
| 22884 | | |
| 22885 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 22886 | | CFLAGS="$gl_save_CFLAGS" |
| 22887 | | fi |
| 22888 | | |
| 22889 | | { echo "$as_me:$LINENO: result: $gl_cv_cc_visibility" >&5 |
| 22890 | | echo "${ECHO_T}$gl_cv_cc_visibility" >&6; } |
| 22891 | | if test $gl_cv_cc_visibility = yes; then |
| 22892 | | CFLAG_VISIBILITY="-fvisibility=hidden" |
| 22893 | | HAVE_VISIBILITY=1 |
| 22894 | | fi |
| 22895 | | fi |
| 22896 | | |
| 22897 | | |
| 22898 | | |
| 22899 | | cat >>confdefs.h <<_ACEOF |
| 22900 | | #define HAVE_VISIBILITY $HAVE_VISIBILITY |
| 22901 | | _ACEOF |
| 22902 | | |
| 22903 | | |
| 22904 | | { echo "$as_me:$LINENO: checking for inline" >&5 |
| 22905 | | echo $ECHO_N "checking for inline... $ECHO_C" >&6; } |
| 22906 | | if test "${ac_cv_c_inline+set}" = set; then |
| 22907 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 22908 | | else |
| 22909 | | ac_cv_c_inline=no |
| 22910 | | for ac_kw in inline __inline__ __inline; do |
| 22911 | | cat >conftest.$ac_ext <<_ACEOF |
| 22912 | | /* confdefs.h. */ |
| 22913 | | _ACEOF |
| 22914 | | cat confdefs.h >>conftest.$ac_ext |
| 22915 | | cat >>conftest.$ac_ext <<_ACEOF |
| 22916 | | /* end confdefs.h. */ |
| 22917 | | #ifndef __cplusplus |
| 22918 | | typedef int foo_t; |
| 22919 | | static $ac_kw foo_t static_foo () {return 0; } |
| 22920 | | $ac_kw foo_t foo () {return 0; } |
| 22921 | | #endif |
| 22922 | | |
| 22923 | | _ACEOF |
| 22924 | | rm -f conftest.$ac_objext |
| 22925 | | if { (ac_try="$ac_compile" |
| 22926 | | case "(($ac_try" in |
| 22927 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 22928 | | *) ac_try_echo=$ac_try;; |
| 22929 | | esac |
| 22930 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 22931 | | (eval "$ac_compile") 2>conftest.er1 |
| 22932 | | ac_status=$? |
| 22933 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 22934 | | rm -f conftest.er1 |
| 22935 | | cat conftest.err >&5 |
| 22936 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 22937 | | (exit $ac_status); } && { |
| 22938 | | test -z "$ac_c_werror_flag" || |
| 22939 | | test ! -s conftest.err |
| 22940 | | } && test -s conftest.$ac_objext; then |
| 22941 | | ac_cv_c_inline=$ac_kw |
| 22942 | | else |
| 22943 | | echo "$as_me: failed program was:" >&5 |
| 22944 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 22945 | | |
| 22946 | | |
| 22947 | | fi |
| 22948 | | |
| 22949 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 22950 | | test "$ac_cv_c_inline" != no && break |
| 22951 | | done |
| 22952 | | |
| 22953 | | fi |
| 22954 | | { echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5 |
| 22955 | | echo "${ECHO_T}$ac_cv_c_inline" >&6; } |
| 22956 | | |
| 22957 | | |
| 22958 | | case $ac_cv_c_inline in |
| 22959 | | inline | yes) ;; |
| 22960 | | *) |
| 22961 | | case $ac_cv_c_inline in |
| 22962 | | no) ac_val=;; |
| 22963 | | *) ac_val=$ac_cv_c_inline;; |
| 22964 | | esac |
| 22965 | | cat >>confdefs.h <<_ACEOF |
| 22966 | | #ifndef __cplusplus |
| 22967 | | #define inline $ac_val |
| 22968 | | #endif |
| 22969 | | _ACEOF |
| 22970 | | ;; |
| 22971 | | esac |
| 22972 | | |
| 22973 | | { echo "$as_me:$LINENO: checking for size_t" >&5 |
| 22974 | | echo $ECHO_N "checking for size_t... $ECHO_C" >&6; } |
| 22975 | | if test "${ac_cv_type_size_t+set}" = set; then |
| 22976 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 22977 | | else |
| 22978 | | cat >conftest.$ac_ext <<_ACEOF |
| 22979 | | /* confdefs.h. */ |
| 22980 | | _ACEOF |
| 22981 | | cat confdefs.h >>conftest.$ac_ext |
| 22982 | | cat >>conftest.$ac_ext <<_ACEOF |
| 22983 | | /* end confdefs.h. */ |
| 22984 | | $ac_includes_default |
| 22985 | | typedef size_t ac__type_new_; |
| 22986 | | int |
| 22987 | | main () |
| 22988 | | { |
| 22989 | | if ((ac__type_new_ *) 0) |
| 22990 | | return 0; |
| 22991 | | if (sizeof (ac__type_new_)) |
| 22992 | | return 0; |
| 22993 | | ; |
| 22994 | | return 0; |
| 22995 | | } |
| 22996 | | _ACEOF |
| 22997 | | rm -f conftest.$ac_objext |
| 22998 | | if { (ac_try="$ac_compile" |
| 22999 | | case "(($ac_try" in |
| 23000 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 23001 | | *) ac_try_echo=$ac_try;; |
| 23002 | | esac |
| 23003 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 23004 | | (eval "$ac_compile") 2>conftest.er1 |
| 23005 | | ac_status=$? |
| 23006 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 23007 | | rm -f conftest.er1 |
| 23008 | | cat conftest.err >&5 |
| 23009 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 23010 | | (exit $ac_status); } && { |
| 23011 | | test -z "$ac_c_werror_flag" || |
| 23012 | | test ! -s conftest.err |
| 23013 | | } && test -s conftest.$ac_objext; then |
| 23014 | | ac_cv_type_size_t=yes |
| 23015 | | else |
| 23016 | | echo "$as_me: failed program was:" >&5 |
| 23017 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 23018 | | |
| 23019 | | ac_cv_type_size_t=no |
| 23020 | | fi |
| 23021 | | |
| 23022 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 23023 | | fi |
| 23024 | | { echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5 |
| 23025 | | echo "${ECHO_T}$ac_cv_type_size_t" >&6; } |
| 23026 | | if test $ac_cv_type_size_t = yes; then |
| 23027 | | : |
| 23028 | | else |
| 23029 | | |
| 23030 | | cat >>confdefs.h <<_ACEOF |
| 23031 | | #define size_t unsigned int |
| 23032 | | _ACEOF |
| 23033 | | |
| 23034 | | fi |
| 23035 | | |
| 23036 | | |
| 23037 | | { echo "$as_me:$LINENO: checking for stdint.h" >&5 |
| 23038 | | echo $ECHO_N "checking for stdint.h... $ECHO_C" >&6; } |
| 23039 | | if test "${gl_cv_header_stdint_h+set}" = set; then |
| 23040 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 23041 | | else |
| 23042 | | cat >conftest.$ac_ext <<_ACEOF |
| 23043 | | /* confdefs.h. */ |
| 23044 | | _ACEOF |
| 23045 | | cat confdefs.h >>conftest.$ac_ext |
| 23046 | | cat >>conftest.$ac_ext <<_ACEOF |
| 23047 | | /* end confdefs.h. */ |
| 23048 | | #include <sys/types.h> |
| 23049 | | #include <stdint.h> |
| 23050 | | int |
| 23051 | | main () |
| 23052 | | { |
| 23053 | | uintmax_t i = (uintmax_t) -1; |
| 23054 | | ; |
| 23055 | | return 0; |
| 23056 | | } |
| 23057 | | _ACEOF |
| 23058 | | rm -f conftest.$ac_objext |
| 23059 | | if { (ac_try="$ac_compile" |
| 23060 | | case "(($ac_try" in |
| 23061 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 23062 | | *) ac_try_echo=$ac_try;; |
| 23063 | | esac |
| 23064 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 23065 | | (eval "$ac_compile") 2>conftest.er1 |
| 23066 | | ac_status=$? |
| 23067 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 23068 | | rm -f conftest.er1 |
| 23069 | | cat conftest.err >&5 |
| 23070 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 23071 | | (exit $ac_status); } && { |
| 23072 | | test -z "$ac_c_werror_flag" || |
| 23073 | | test ! -s conftest.err |
| 23074 | | } && test -s conftest.$ac_objext; then |
| 23075 | | gl_cv_header_stdint_h=yes |
| 23076 | | else |
| 23077 | | echo "$as_me: failed program was:" >&5 |
| 23078 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 23079 | | |
| 23080 | | gl_cv_header_stdint_h=no |
| 23081 | | fi |
| 23082 | | |
| 23083 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 23084 | | fi |
| 23085 | | { echo "$as_me:$LINENO: result: $gl_cv_header_stdint_h" >&5 |
| 23086 | | echo "${ECHO_T}$gl_cv_header_stdint_h" >&6; } |
| 23087 | | if test $gl_cv_header_stdint_h = yes; then |
| 23088 | | |
| 23089 | | cat >>confdefs.h <<_ACEOF |
| 23090 | | #define HAVE_STDINT_H_WITH_UINTMAX 1 |
| 23091 | | _ACEOF |
| 23092 | | |
| 23093 | | fi |
| 23094 | | |
| 23095 | | # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works |
| 23096 | | # for constant arguments. Useless! |
| 23097 | | { echo "$as_me:$LINENO: checking for working alloca.h" >&5 |
| 23098 | | echo $ECHO_N "checking for working alloca.h... $ECHO_C" >&6; } |
| 23099 | | if test "${ac_cv_working_alloca_h+set}" = set; then |
| 23100 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 23101 | | else |
| 23102 | | cat >conftest.$ac_ext <<_ACEOF |
| 23103 | | /* confdefs.h. */ |
| 23104 | | _ACEOF |
| 23105 | | cat confdefs.h >>conftest.$ac_ext |
| 23106 | | cat >>conftest.$ac_ext <<_ACEOF |
| 23107 | | /* end confdefs.h. */ |
| 23108 | | #include <alloca.h> |
| 23109 | | int |
| 23110 | | main () |
| 23111 | | { |
| 23112 | | char *p = (char *) alloca (2 * sizeof (int)); |
| 23113 | | if (p) return 0; |
| 23114 | | ; |
| 23115 | | return 0; |
| 23116 | | } |
| 23117 | | _ACEOF |
| 23118 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 23119 | | if { (ac_try="$ac_link" |
| 23120 | | case "(($ac_try" in |
| 23121 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 23122 | | *) ac_try_echo=$ac_try;; |
| 23123 | | esac |
| 23124 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 23125 | | (eval "$ac_link") 2>conftest.er1 |
| 23126 | | ac_status=$? |
| 23127 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 23128 | | rm -f conftest.er1 |
| 23129 | | cat conftest.err >&5 |
| 23130 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 23131 | | (exit $ac_status); } && { |
| 23132 | | test -z "$ac_c_werror_flag" || |
| 23133 | | test ! -s conftest.err |
| 23134 | | } && test -s conftest$ac_exeext && |
| 23135 | | $as_test_x conftest$ac_exeext; then |
| 23136 | | ac_cv_working_alloca_h=yes |
| 23137 | | else |
| 23138 | | echo "$as_me: failed program was:" >&5 |
| 23139 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 23140 | | |
| 23141 | | ac_cv_working_alloca_h=no |
| 23142 | | fi |
| 23143 | | |
| 23144 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 23145 | | conftest$ac_exeext conftest.$ac_ext |
| 23146 | | fi |
| 23147 | | { echo "$as_me:$LINENO: result: $ac_cv_working_alloca_h" >&5 |
| 23148 | | echo "${ECHO_T}$ac_cv_working_alloca_h" >&6; } |
| 23149 | | if test $ac_cv_working_alloca_h = yes; then |
| 23150 | | |
| 23151 | | cat >>confdefs.h <<\_ACEOF |
| 23152 | | #define HAVE_ALLOCA_H 1 |
| 23153 | | _ACEOF |
| 23154 | | |
| 23155 | | fi |
| 23156 | | |
| 23157 | | { echo "$as_me:$LINENO: checking for alloca" >&5 |
| 23158 | | echo $ECHO_N "checking for alloca... $ECHO_C" >&6; } |
| 23159 | | if test "${ac_cv_func_alloca_works+set}" = set; then |
| 23160 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 23161 | | else |
| 23162 | | cat >conftest.$ac_ext <<_ACEOF |
| 23163 | | /* confdefs.h. */ |
| 23164 | | _ACEOF |
| 23165 | | cat confdefs.h >>conftest.$ac_ext |
| 23166 | | cat >>conftest.$ac_ext <<_ACEOF |
| 23167 | | /* end confdefs.h. */ |
| 23168 | | #ifdef __GNUC__ |
| 23169 | | # define alloca __builtin_alloca |
| 23170 | | #else |
| 23171 | | # ifdef _MSC_VER |
| 23172 | | # include <malloc.h> |
| 23173 | | # define alloca _alloca |
| 23174 | | # else |
| 23175 | | # ifdef HAVE_ALLOCA_H |
| 23176 | | # include <alloca.h> |
| 23177 | | # else |
| 23178 | | # ifdef _AIX |
| 23179 | | #pragma alloca |
| 23180 | | # else |
| 23181 | | # ifndef alloca /* predefined by HP cc +Olibcalls */ |
| 23182 | | char *alloca (); |
| 23183 | | # endif |
| 23184 | | # endif |
| 23185 | | # endif |
| 23186 | | # endif |
| 23187 | | #endif |
| 23188 | | |
| 23189 | | int |
| 23190 | | main () |
| 23191 | | { |
| 23192 | | char *p = (char *) alloca (1); |
| 23193 | | if (p) return 0; |
| 23194 | | ; |
| 23195 | | return 0; |
| 23196 | | } |
| 23197 | | _ACEOF |
| 23198 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 23199 | | if { (ac_try="$ac_link" |
| 23200 | | case "(($ac_try" in |
| 23201 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 23202 | | *) ac_try_echo=$ac_try;; |
| 23203 | | esac |
| 23204 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 23205 | | (eval "$ac_link") 2>conftest.er1 |
| 23206 | | ac_status=$? |
| 23207 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 23208 | | rm -f conftest.er1 |
| 23209 | | cat conftest.err >&5 |
| 23210 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 23211 | | (exit $ac_status); } && { |
| 23212 | | test -z "$ac_c_werror_flag" || |
| 23213 | | test ! -s conftest.err |
| 23214 | | } && test -s conftest$ac_exeext && |
| 23215 | | $as_test_x conftest$ac_exeext; then |
| 23216 | | ac_cv_func_alloca_works=yes |
| 23217 | | else |
| 23218 | | echo "$as_me: failed program was:" >&5 |
| 23219 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 23220 | | |
| 23221 | | ac_cv_func_alloca_works=no |
| 23222 | | fi |
| 23223 | | |
| 23224 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 23225 | | conftest$ac_exeext conftest.$ac_ext |
| 23226 | | fi |
| 23227 | | { echo "$as_me:$LINENO: result: $ac_cv_func_alloca_works" >&5 |
| 23228 | | echo "${ECHO_T}$ac_cv_func_alloca_works" >&6; } |
| 23229 | | |
| 23230 | | if test $ac_cv_func_alloca_works = yes; then |
| 23231 | | |
| 23232 | | cat >>confdefs.h <<\_ACEOF |
| 23233 | | #define HAVE_ALLOCA 1 |
| 23234 | | _ACEOF |
| 23235 | | |
| 23236 | | else |
| 23237 | | # The SVR3 libPW and SVR4 libucb both contain incompatible functions |
| 23238 | | # that cause trouble. Some versions do not even contain alloca or |
| 23239 | | # contain a buggy version. If you still want to use their alloca, |
| 23240 | | # use ar to extract alloca.o from them instead of compiling alloca.c. |
| 23241 | | |
| 23242 | | ALLOCA=\${LIBOBJDIR}alloca.$ac_objext |
| 23243 | | |
| 23244 | | cat >>confdefs.h <<\_ACEOF |
| 23245 | | #define C_ALLOCA 1 |
| 23246 | | _ACEOF |
| 23247 | | |
| 23248 | | |
| 23249 | | { echo "$as_me:$LINENO: checking whether \`alloca.c' needs Cray hooks" >&5 |
| 23250 | | echo $ECHO_N "checking whether \`alloca.c' needs Cray hooks... $ECHO_C" >&6; } |
| 23251 | | if test "${ac_cv_os_cray+set}" = set; then |
| 23252 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 23253 | | else |
| 23254 | | cat >conftest.$ac_ext <<_ACEOF |
| 23255 | | /* confdefs.h. */ |
| 23256 | | _ACEOF |
| 23257 | | cat confdefs.h >>conftest.$ac_ext |
| 23258 | | cat >>conftest.$ac_ext <<_ACEOF |
| 23259 | | /* end confdefs.h. */ |
| 23260 | | #if defined CRAY && ! defined CRAY2 |
| 23261 | | webecray |
| 23262 | | #else |
| 23263 | | wenotbecray |
| 23264 | | #endif |
| 23265 | | |
| 23266 | | _ACEOF |
| 23267 | | if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | |
| 23268 | | $EGREP "webecray" >/dev/null 2>&1; then |
| 23269 | | ac_cv_os_cray=yes |
| 23270 | | else |
| 23271 | | ac_cv_os_cray=no |
| 23272 | | fi |
| 23273 | | rm -f conftest* |
| 23274 | | |
| 23275 | | fi |
| 23276 | | { echo "$as_me:$LINENO: result: $ac_cv_os_cray" >&5 |
| 23277 | | echo "${ECHO_T}$ac_cv_os_cray" >&6; } |
| 23278 | | if test $ac_cv_os_cray = yes; then |
| 23279 | | for ac_func in _getb67 GETB67 getb67; do |
| 23280 | | as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` |
| 23281 | | { echo "$as_me:$LINENO: checking for $ac_func" >&5 |
| 23282 | | echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; } |
| 23283 | | if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then |
| 23284 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 23285 | | else |
| 23286 | | cat >conftest.$ac_ext <<_ACEOF |
| 23287 | | /* confdefs.h. */ |
| 23288 | | _ACEOF |
| 23289 | | cat confdefs.h >>conftest.$ac_ext |
| 23290 | | cat >>conftest.$ac_ext <<_ACEOF |
| 23291 | | /* end confdefs.h. */ |
| 23292 | | /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. |
| 23293 | | For example, HP-UX 11i <limits.h> declares gettimeofday. */ |
| 23294 | | #define $ac_func innocuous_$ac_func |
| 23295 | | |
| 23296 | | /* System header to define __stub macros and hopefully few prototypes, |
| 23297 | | which can conflict with char $ac_func (); below. |
| 23298 | | Prefer <limits.h> to <assert.h> if __STDC__ is defined, since |
| 23299 | | <limits.h> exists even on freestanding compilers. */ |
| 23300 | | |
| 23301 | | #ifdef __STDC__ |
| 23302 | | # include <limits.h> |
| 23303 | | #else |
| 23304 | | # include <assert.h> |
| 23305 | | #endif |
| 23306 | | |
| 23307 | | #undef $ac_func |
| 23308 | | |
| 23309 | | /* Override any GCC internal prototype to avoid an error. |
| 23310 | | Use char because int might match the return type of a GCC |
| 23311 | | builtin and then its argument prototype would still apply. */ |
| 23312 | | #ifdef __cplusplus |
| 23313 | | extern "C" |
| 23314 | | #endif |
| 23315 | | char $ac_func (); |
| 23316 | | /* The GNU C library defines this for functions which it implements |
| 23317 | | to always fail with ENOSYS. Some functions are actually named |
| 23318 | | something starting with __ and the normal name is an alias. */ |
| 23319 | | #if defined __stub_$ac_func || defined __stub___$ac_func |
| 23320 | | choke me |
| 23321 | | #endif |
| 23322 | | |
| 23323 | | int |
| 23324 | | main () |
| 23325 | | { |
| 23326 | | return $ac_func (); |
| 23327 | | ; |
| 23328 | | return 0; |
| 23329 | | } |
| 23330 | | _ACEOF |
| 23331 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 23332 | | if { (ac_try="$ac_link" |
| 23333 | | case "(($ac_try" in |
| 23334 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 23335 | | *) ac_try_echo=$ac_try;; |
| 23336 | | esac |
| 23337 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 23338 | | (eval "$ac_link") 2>conftest.er1 |
| 23339 | | ac_status=$? |
| 23340 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 23341 | | rm -f conftest.er1 |
| 23342 | | cat conftest.err >&5 |
| 23343 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 23344 | | (exit $ac_status); } && { |
| 23345 | | test -z "$ac_c_werror_flag" || |
| 23346 | | test ! -s conftest.err |
| 23347 | | } && test -s conftest$ac_exeext && |
| 23348 | | $as_test_x conftest$ac_exeext; then |
| 23349 | | eval "$as_ac_var=yes" |
| 23350 | | else |
| 23351 | | echo "$as_me: failed program was:" >&5 |
| 23352 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 23353 | | |
| 23354 | | eval "$as_ac_var=no" |
| 23355 | | fi |
| 23356 | | |
| 23357 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 23358 | | conftest$ac_exeext conftest.$ac_ext |
| 23359 | | fi |
| 23360 | | ac_res=`eval echo '${'$as_ac_var'}'` |
| 23361 | | { echo "$as_me:$LINENO: result: $ac_res" >&5 |
| 23362 | | echo "${ECHO_T}$ac_res" >&6; } |
| 23363 | | if test `eval echo '${'$as_ac_var'}'` = yes; then |
| 23364 | | |
| 23365 | | cat >>confdefs.h <<_ACEOF |
| 23366 | | #define CRAY_STACKSEG_END $ac_func |
| 23367 | | _ACEOF |
| 23368 | | |
| 23369 | | break |
| 23370 | | fi |
| 23371 | | |
| 23372 | | done |
| 23373 | | fi |
| 23374 | | |
| 23375 | | { echo "$as_me:$LINENO: checking stack direction for C alloca" >&5 |
| 23376 | | echo $ECHO_N "checking stack direction for C alloca... $ECHO_C" >&6; } |
| 23377 | | if test "${ac_cv_c_stack_direction+set}" = set; then |
| 23378 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 23379 | | else |
| 23380 | | if test "$cross_compiling" = yes; then |
| 23381 | | ac_cv_c_stack_direction=0 |
| 23382 | | else |
| 23383 | | cat >conftest.$ac_ext <<_ACEOF |
| 23384 | | /* confdefs.h. */ |
| 23385 | | _ACEOF |
| 23386 | | cat confdefs.h >>conftest.$ac_ext |
| 23387 | | cat >>conftest.$ac_ext <<_ACEOF |
| 23388 | | /* end confdefs.h. */ |
| 23389 | | $ac_includes_default |
| 23390 | | int |
| 23391 | | find_stack_direction () |
| 23392 | | { |
| 23393 | | static char *addr = 0; |
| 23394 | | auto char dummy; |
| 23395 | | if (addr == 0) |
| 23396 | | { |
| 23397 | | addr = &dummy; |
| 23398 | | return find_stack_direction (); |
| 23399 | | } |
| 23400 | | else |
| 23401 | | return (&dummy > addr) ? 1 : -1; |
| 23402 | | } |
| 23403 | | |
| 23404 | | int |
| 23405 | | main () |
| 23406 | | { |
| 23407 | | return find_stack_direction () < 0; |
| 23408 | | } |
| 23409 | | _ACEOF |
| 23410 | | rm -f conftest$ac_exeext |
| 23411 | | if { (ac_try="$ac_link" |
| 23412 | | case "(($ac_try" in |
| 23413 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 23414 | | *) ac_try_echo=$ac_try;; |
| 23415 | | esac |
| 23416 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 23417 | | (eval "$ac_link") 2>&5 |
| 23418 | | ac_status=$? |
| 23419 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 23420 | | (exit $ac_status); } && { ac_try='./conftest$ac_exeext' |
| 23421 | | { (case "(($ac_try" in |
| 23422 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 23423 | | *) ac_try_echo=$ac_try;; |
| 23424 | | esac |
| 23425 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 23426 | | (eval "$ac_try") 2>&5 |
| 23427 | | ac_status=$? |
| 23428 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 23429 | | (exit $ac_status); }; }; then |
| 23430 | | ac_cv_c_stack_direction=1 |
| 23431 | | else |
| 23432 | | echo "$as_me: program exited with status $ac_status" >&5 |
| 23433 | | echo "$as_me: failed program was:" >&5 |
| 23434 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 23435 | | |
| 23436 | | ( exit $ac_status ) |
| 23437 | | ac_cv_c_stack_direction=-1 |
| 23438 | | fi |
| 23439 | | rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext |
| 23440 | | fi |
| 23441 | | |
| 23442 | | |
| 23443 | | fi |
| 23444 | | { echo "$as_me:$LINENO: result: $ac_cv_c_stack_direction" >&5 |
| 23445 | | echo "${ECHO_T}$ac_cv_c_stack_direction" >&6; } |
| 23446 | | |
| 23447 | | cat >>confdefs.h <<_ACEOF |
| 23448 | | #define STACK_DIRECTION $ac_cv_c_stack_direction |
| 23449 | | _ACEOF |
| 23450 | | |
| 23451 | | |
| 23452 | | fi |
| 23453 | | |
| 23454 | | |
| 23455 | | |
| 23456 | | for ac_header in stdlib.h unistd.h |
| 23457 | | do |
| 23458 | | as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` |
| 23459 | | if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then |
| 23460 | | { echo "$as_me:$LINENO: checking for $ac_header" >&5 |
| 23461 | | echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } |
| 23462 | | if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then |
| 23463 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 23464 | | fi |
| 23465 | | ac_res=`eval echo '${'$as_ac_Header'}'` |
| 23466 | | { echo "$as_me:$LINENO: result: $ac_res" >&5 |
| 23467 | | echo "${ECHO_T}$ac_res" >&6; } |
| 23468 | | else |
| 23469 | | # Is the header compilable? |
| 23470 | | { echo "$as_me:$LINENO: checking $ac_header usability" >&5 |
| 23471 | | echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; } |
| 23472 | | cat >conftest.$ac_ext <<_ACEOF |
| 23473 | | /* confdefs.h. */ |
| 23474 | | _ACEOF |
| 23475 | | cat confdefs.h >>conftest.$ac_ext |
| 23476 | | cat >>conftest.$ac_ext <<_ACEOF |
| 23477 | | /* end confdefs.h. */ |
| 23478 | | $ac_includes_default |
| 23479 | | #include <$ac_header> |
| 23480 | | _ACEOF |
| 23481 | | rm -f conftest.$ac_objext |
| 23482 | | if { (ac_try="$ac_compile" |
| 23483 | | case "(($ac_try" in |
| 23484 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 23485 | | *) ac_try_echo=$ac_try;; |
| 23486 | | esac |
| 23487 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 23488 | | (eval "$ac_compile") 2>conftest.er1 |
| 23489 | | ac_status=$? |
| 23490 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 23491 | | rm -f conftest.er1 |
| 23492 | | cat conftest.err >&5 |
| 23493 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 23494 | | (exit $ac_status); } && { |
| 23495 | | test -z "$ac_c_werror_flag" || |
| 23496 | | test ! -s conftest.err |
| 23497 | | } && test -s conftest.$ac_objext; then |
| 23498 | | ac_header_compiler=yes |
| 23499 | | else |
| 23500 | | echo "$as_me: failed program was:" >&5 |
| 23501 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 23502 | | |
| 23503 | | ac_header_compiler=no |
| 23504 | | fi |
| 23505 | | |
| 23506 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 23507 | | { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 |
| 23508 | | echo "${ECHO_T}$ac_header_compiler" >&6; } |
| 23509 | | |
| 23510 | | # Is the header present? |
| 23511 | | { echo "$as_me:$LINENO: checking $ac_header presence" >&5 |
| 23512 | | echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; } |
| 23513 | | cat >conftest.$ac_ext <<_ACEOF |
| 23514 | | /* confdefs.h. */ |
| 23515 | | _ACEOF |
| 23516 | | cat confdefs.h >>conftest.$ac_ext |
| 23517 | | cat >>conftest.$ac_ext <<_ACEOF |
| 23518 | | /* end confdefs.h. */ |
| 23519 | | #include <$ac_header> |
| 23520 | | _ACEOF |
| 23521 | | if { (ac_try="$ac_cpp conftest.$ac_ext" |
| 23522 | | case "(($ac_try" in |
| 23523 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 23524 | | *) ac_try_echo=$ac_try;; |
| 23525 | | esac |
| 23526 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 23527 | | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 |
| 23528 | | ac_status=$? |
| 23529 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 23530 | | rm -f conftest.er1 |
| 23531 | | cat conftest.err >&5 |
| 23532 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 23533 | | (exit $ac_status); } >/dev/null && { |
| 23534 | | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| 23535 | | test ! -s conftest.err |
| 23536 | | }; then |
| 23537 | | ac_header_preproc=yes |
| 23538 | | else |
| 23539 | | echo "$as_me: failed program was:" >&5 |
| 23540 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 23541 | | |
| 23542 | | ac_header_preproc=no |
| 23543 | | fi |
| 23544 | | |
| 23545 | | rm -f conftest.err conftest.$ac_ext |
| 23546 | | { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 |
| 23547 | | echo "${ECHO_T}$ac_header_preproc" >&6; } |
| 23548 | | |
| 23549 | | # So? What about this header? |
| 23550 | | case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in |
| 23551 | | yes:no: ) |
| 23552 | | { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 |
| 23553 | | echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} |
| 23554 | | { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5 |
| 23555 | | echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;} |
| 23556 | | ac_header_preproc=yes |
| 23557 | | ;; |
| 23558 | | no:yes:* ) |
| 23559 | | { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 |
| 23560 | | echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} |
| 23561 | | { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 |
| 23562 | | echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} |
| 23563 | | { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5 |
| 23564 | | echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;} |
| 23565 | | { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5 |
| 23566 | | echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;} |
| 23567 | | { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 |
| 23568 | | echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} |
| 23569 | | { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5 |
| 23570 | | echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;} |
| 23571 | | |
| 23572 | | ;; |
| 23573 | | esac |
| 23574 | | { echo "$as_me:$LINENO: checking for $ac_header" >&5 |
| 23575 | | echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } |
| 23576 | | if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then |
| 23577 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 23578 | | else |
| 23579 | | eval "$as_ac_Header=\$ac_header_preproc" |
| 23580 | | fi |
| 23581 | | ac_res=`eval echo '${'$as_ac_Header'}'` |
| 23582 | | { echo "$as_me:$LINENO: result: $ac_res" >&5 |
| 23583 | | echo "${ECHO_T}$ac_res" >&6; } |
| 23584 | | |
| 23585 | | fi |
| 23586 | | if test `eval echo '${'$as_ac_Header'}'` = yes; then |
| 23587 | | cat >>confdefs.h <<_ACEOF |
| 23588 | | #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 |
| 23589 | | _ACEOF |
| 23590 | | |
| 23591 | | fi |
| 23592 | | |
| 23593 | | done |
| 23594 | | |
| 23595 | | |
| 23596 | | for ac_func in getpagesize |
| 23597 | | do |
| 23598 | | as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` |
| 23599 | | { echo "$as_me:$LINENO: checking for $ac_func" >&5 |
| 23600 | | echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; } |
| 23601 | | if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then |
| 23602 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 23603 | | else |
| 23604 | | cat >conftest.$ac_ext <<_ACEOF |
| 23605 | | /* confdefs.h. */ |
| 23606 | | _ACEOF |
| 23607 | | cat confdefs.h >>conftest.$ac_ext |
| 23608 | | cat >>conftest.$ac_ext <<_ACEOF |
| 23609 | | /* end confdefs.h. */ |
| 23610 | | /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. |
| 23611 | | For example, HP-UX 11i <limits.h> declares gettimeofday. */ |
| 23612 | | #define $ac_func innocuous_$ac_func |
| 23613 | | |
| 23614 | | /* System header to define __stub macros and hopefully few prototypes, |
| 23615 | | which can conflict with char $ac_func (); below. |
| 23616 | | Prefer <limits.h> to <assert.h> if __STDC__ is defined, since |
| 23617 | | <limits.h> exists even on freestanding compilers. */ |
| 23618 | | |
| 23619 | | #ifdef __STDC__ |
| 23620 | | # include <limits.h> |
| 23621 | | #else |
| 23622 | | # include <assert.h> |
| 23623 | | #endif |
| 23624 | | |
| 23625 | | #undef $ac_func |
| 23626 | | |
| 23627 | | /* Override any GCC internal prototype to avoid an error. |
| 23628 | | Use char because int might match the return type of a GCC |
| 23629 | | builtin and then its argument prototype would still apply. */ |
| 23630 | | #ifdef __cplusplus |
| 23631 | | extern "C" |
| 23632 | | #endif |
| 23633 | | char $ac_func (); |
| 23634 | | /* The GNU C library defines this for functions which it implements |
| 23635 | | to always fail with ENOSYS. Some functions are actually named |
| 23636 | | something starting with __ and the normal name is an alias. */ |
| 23637 | | #if defined __stub_$ac_func || defined __stub___$ac_func |
| 23638 | | choke me |
| 23639 | | #endif |
| 23640 | | |
| 23641 | | int |
| 23642 | | main () |
| 23643 | | { |
| 23644 | | return $ac_func (); |
| 23645 | | ; |
| 23646 | | return 0; |
| 23647 | | } |
| 23648 | | _ACEOF |
| 23649 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 23650 | | if { (ac_try="$ac_link" |
| 23651 | | case "(($ac_try" in |
| 23652 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 23653 | | *) ac_try_echo=$ac_try;; |
| 23654 | | esac |
| 23655 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 23656 | | (eval "$ac_link") 2>conftest.er1 |
| 23657 | | ac_status=$? |
| 23658 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 23659 | | rm -f conftest.er1 |
| 23660 | | cat conftest.err >&5 |
| 23661 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 23662 | | (exit $ac_status); } && { |
| 23663 | | test -z "$ac_c_werror_flag" || |
| 23664 | | test ! -s conftest.err |
| 23665 | | } && test -s conftest$ac_exeext && |
| 23666 | | $as_test_x conftest$ac_exeext; then |
| 23667 | | eval "$as_ac_var=yes" |
| 23668 | | else |
| 23669 | | echo "$as_me: failed program was:" >&5 |
| 23670 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 23671 | | |
| 23672 | | eval "$as_ac_var=no" |
| 23673 | | fi |
| 23674 | | |
| 23675 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 23676 | | conftest$ac_exeext conftest.$ac_ext |
| 23677 | | fi |
| 23678 | | ac_res=`eval echo '${'$as_ac_var'}'` |
| 23679 | | { echo "$as_me:$LINENO: result: $ac_res" >&5 |
| 23680 | | echo "${ECHO_T}$ac_res" >&6; } |
| 23681 | | if test `eval echo '${'$as_ac_var'}'` = yes; then |
| 23682 | | cat >>confdefs.h <<_ACEOF |
| 23683 | | #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1 |
| 23684 | | _ACEOF |
| 23685 | | |
| 23686 | | fi |
| 23687 | | done |
| 23688 | | |
| 23689 | | { echo "$as_me:$LINENO: checking for working mmap" >&5 |
| 23690 | | echo $ECHO_N "checking for working mmap... $ECHO_C" >&6; } |
| 23691 | | if test "${ac_cv_func_mmap_fixed_mapped+set}" = set; then |
| 23692 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 23693 | | else |
| 23694 | | if test "$cross_compiling" = yes; then |
| 23695 | | ac_cv_func_mmap_fixed_mapped=no |
| 23696 | | else |
| 23697 | | cat >conftest.$ac_ext <<_ACEOF |
| 23698 | | /* confdefs.h. */ |
| 23699 | | _ACEOF |
| 23700 | | cat confdefs.h >>conftest.$ac_ext |
| 23701 | | cat >>conftest.$ac_ext <<_ACEOF |
| 23702 | | /* end confdefs.h. */ |
| 23703 | | $ac_includes_default |
| 23704 | | /* malloc might have been renamed as rpl_malloc. */ |
| 23705 | | #undef malloc |
| 23706 | | |
| 23707 | | /* Thanks to Mike Haertel and Jim Avera for this test. |
| 23708 | | Here is a matrix of mmap possibilities: |
| 23709 | | mmap private not fixed |
| 23710 | | mmap private fixed at somewhere currently unmapped |
| 23711 | | mmap private fixed at somewhere already mapped |
| 23712 | | mmap shared not fixed |
| 23713 | | mmap shared fixed at somewhere currently unmapped |
| 23714 | | mmap shared fixed at somewhere already mapped |
| 23715 | | For private mappings, we should verify that changes cannot be read() |
| 23716 | | back from the file, nor mmap's back from the file at a different |
| 23717 | | address. (There have been systems where private was not correctly |
| 23718 | | implemented like the infamous i386 svr4.0, and systems where the |
| 23719 | | VM page cache was not coherent with the file system buffer cache |
| 23720 | | like early versions of FreeBSD and possibly contemporary NetBSD.) |
| 23721 | | For shared mappings, we should conversely verify that changes get |
| 23722 | | propagated back to all the places they're supposed to be. |
| 23723 | | |
| 23724 | | Grep wants private fixed already mapped. |
| 23725 | | The main things grep needs to know about mmap are: |
| 23726 | | * does it exist and is it safe to write into the mmap'd area |
| 23727 | | * how to use it (BSD variants) */ |
| 23728 | | |
| 23729 | | #include <fcntl.h> |
| 23730 | | #include <sys/mman.h> |
| 23731 | | |
| 23732 | | #if !defined STDC_HEADERS && !defined HAVE_STDLIB_H |
| 23733 | | char *malloc (); |
| 23734 | | #endif |
| 23735 | | |
| 23736 | | /* This mess was copied from the GNU getpagesize.h. */ |
| 23737 | | #ifndef HAVE_GETPAGESIZE |
| 23738 | | /* Assume that all systems that can run configure have sys/param.h. */ |
| 23739 | | # ifndef HAVE_SYS_PARAM_H |
| 23740 | | # define HAVE_SYS_PARAM_H 1 |
| 23741 | | # endif |
| 23742 | | |
| 23743 | | # ifdef _SC_PAGESIZE |
| 23744 | | # define getpagesize() sysconf(_SC_PAGESIZE) |
| 23745 | | # else /* no _SC_PAGESIZE */ |
| 23746 | | # ifdef HAVE_SYS_PARAM_H |
| 23747 | | # include <sys/param.h> |
| 23748 | | # ifdef EXEC_PAGESIZE |
| 23749 | | # define getpagesize() EXEC_PAGESIZE |
| 23750 | | # else /* no EXEC_PAGESIZE */ |
| 23751 | | # ifdef NBPG |
| 23752 | | # define getpagesize() NBPG * CLSIZE |
| 23753 | | # ifndef CLSIZE |
| 23754 | | # define CLSIZE 1 |
| 23755 | | # endif /* no CLSIZE */ |
| 23756 | | # else /* no NBPG */ |
| 23757 | | # ifdef NBPC |
| 23758 | | # define getpagesize() NBPC |
| 23759 | | # else /* no NBPC */ |
| 23760 | | # ifdef PAGESIZE |
| 23761 | | # define getpagesize() PAGESIZE |
| 23762 | | # endif /* PAGESIZE */ |
| 23763 | | # endif /* no NBPC */ |
| 23764 | | # endif /* no NBPG */ |
| 23765 | | # endif /* no EXEC_PAGESIZE */ |
| 23766 | | # else /* no HAVE_SYS_PARAM_H */ |
| 23767 | | # define getpagesize() 8192 /* punt totally */ |
| 23768 | | # endif /* no HAVE_SYS_PARAM_H */ |
| 23769 | | # endif /* no _SC_PAGESIZE */ |
| 23770 | | |
| 23771 | | #endif /* no HAVE_GETPAGESIZE */ |
| 23772 | | |
| 23773 | | int |
| 23774 | | main () |
| 23775 | | { |
| 23776 | | char *data, *data2, *data3; |
| 23777 | | int i, pagesize; |
| 23778 | | int fd; |
| 23779 | | |
| 23780 | | pagesize = getpagesize (); |
| 23781 | | |
| 23782 | | /* First, make a file with some known garbage in it. */ |
| 23783 | | data = (char *) malloc (pagesize); |
| 23784 | | if (!data) |
| 23785 | | return 1; |
| 23786 | | for (i = 0; i < pagesize; ++i) |
| 23787 | | *(data + i) = rand (); |
| 23788 | | umask (0); |
| 23789 | | fd = creat ("conftest.mmap", 0600); |
| 23790 | | if (fd < 0) |
| 23791 | | return 1; |
| 23792 | | if (write (fd, data, pagesize) != pagesize) |
| 23793 | | return 1; |
| 23794 | | close (fd); |
| 23795 | | |
| 23796 | | /* Next, try to mmap the file at a fixed address which already has |
| 23797 | | something else allocated at it. If we can, also make sure that |
| 23798 | | we see the same garbage. */ |
| 23799 | | fd = open ("conftest.mmap", O_RDWR); |
| 23800 | | if (fd < 0) |
| 23801 | | return 1; |
| 23802 | | data2 = (char *) malloc (2 * pagesize); |
| 23803 | | if (!data2) |
| 23804 | | return 1; |
| 23805 | | data2 += (pagesize - ((long int) data2 & (pagesize - 1))) & (pagesize - 1); |
| 23806 | | if (data2 != mmap (data2, pagesize, PROT_READ | PROT_WRITE, |
| 23807 | | MAP_PRIVATE | MAP_FIXED, fd, 0L)) |
| 23808 | | return 1; |
| 23809 | | for (i = 0; i < pagesize; ++i) |
| 23810 | | if (*(data + i) != *(data2 + i)) |
| 23811 | | return 1; |
| 23812 | | |
| 23813 | | /* Finally, make sure that changes to the mapped area do not |
| 23814 | | percolate back to the file as seen by read(). (This is a bug on |
| 23815 | | some variants of i386 svr4.0.) */ |
| 23816 | | for (i = 0; i < pagesize; ++i) |
| 23817 | | *(data2 + i) = *(data2 + i) + 1; |
| 23818 | | data3 = (char *) malloc (pagesize); |
| 23819 | | if (!data3) |
| 23820 | | return 1; |
| 23821 | | if (read (fd, data3, pagesize) != pagesize) |
| 23822 | | return 1; |
| 23823 | | for (i = 0; i < pagesize; ++i) |
| 23824 | | if (*(data + i) != *(data3 + i)) |
| 23825 | | return 1; |
| 23826 | | close (fd); |
| 23827 | | return 0; |
| 23828 | | } |
| 23829 | | _ACEOF |
| 23830 | | rm -f conftest$ac_exeext |
| 23831 | | if { (ac_try="$ac_link" |
| 23832 | | case "(($ac_try" in |
| 23833 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 23834 | | *) ac_try_echo=$ac_try;; |
| 23835 | | esac |
| 23836 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 23837 | | (eval "$ac_link") 2>&5 |
| 23838 | | ac_status=$? |
| 23839 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 23840 | | (exit $ac_status); } && { ac_try='./conftest$ac_exeext' |
| 23841 | | { (case "(($ac_try" in |
| 23842 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 23843 | | *) ac_try_echo=$ac_try;; |
| 23844 | | esac |
| 23845 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 23846 | | (eval "$ac_try") 2>&5 |
| 23847 | | ac_status=$? |
| 23848 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 23849 | | (exit $ac_status); }; }; then |
| 23850 | | ac_cv_func_mmap_fixed_mapped=yes |
| 23851 | | else |
| 23852 | | echo "$as_me: program exited with status $ac_status" >&5 |
| 23853 | | echo "$as_me: failed program was:" >&5 |
| 23854 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 23855 | | |
| 23856 | | ( exit $ac_status ) |
| 23857 | | ac_cv_func_mmap_fixed_mapped=no |
| 23858 | | fi |
| 23859 | | rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext |
| 23860 | | fi |
| 23861 | | |
| 23862 | | |
| 23863 | | fi |
| 23864 | | { echo "$as_me:$LINENO: result: $ac_cv_func_mmap_fixed_mapped" >&5 |
| 23865 | | echo "${ECHO_T}$ac_cv_func_mmap_fixed_mapped" >&6; } |
| 23866 | | if test $ac_cv_func_mmap_fixed_mapped = yes; then |
| 23867 | | |
| 23868 | | cat >>confdefs.h <<\_ACEOF |
| 23869 | | #define HAVE_MMAP 1 |
| 23870 | | _ACEOF |
| 23871 | | |
| 23872 | | fi |
| 23873 | | rm -f conftest.mmap |
| 23874 | | |
| 23875 | | |
| 23876 | | |
| 23877 | | { echo "$as_me:$LINENO: checking whether integer division by zero raises SIGFPE" >&5 |
| 23878 | | echo $ECHO_N "checking whether integer division by zero raises SIGFPE... $ECHO_C" >&6; } |
| 23879 | | if test "${gt_cv_int_divbyzero_sigfpe+set}" = set; then |
| 23880 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 23881 | | else |
| 23882 | | |
| 23883 | | if test "$cross_compiling" = yes; then |
| 23884 | | |
| 23885 | | # Guess based on the CPU. |
| 23886 | | case "$host_cpu" in |
| 23887 | | alpha* | i3456786 | m68k | s390*) |
| 23888 | | gt_cv_int_divbyzero_sigfpe="guessing yes";; |
| 23889 | | *) |
| 23890 | | gt_cv_int_divbyzero_sigfpe="guessing no";; |
| 23891 | | esac |
| 23892 | | |
| 23893 | | else |
| 23894 | | cat >conftest.$ac_ext <<_ACEOF |
| 23895 | | /* confdefs.h. */ |
| 23896 | | _ACEOF |
| 23897 | | cat confdefs.h >>conftest.$ac_ext |
| 23898 | | cat >>conftest.$ac_ext <<_ACEOF |
| 23899 | | /* end confdefs.h. */ |
| 23900 | | |
| 23901 | | #include <stdlib.h> |
| 23902 | | #include <signal.h> |
| 23903 | | |
| 23904 | | static void |
| 23905 | | #ifdef __cplusplus |
| 23906 | | sigfpe_handler (int sig) |
| 23907 | | #else |
| 23908 | | sigfpe_handler (sig) int sig; |
| 23909 | | #endif |
| 23910 | | { |
| 23911 | | /* Exit with code 0 if SIGFPE, with code 1 if any other signal. */ |
| 23912 | | exit (sig != SIGFPE); |
| 23913 | | } |
| 23914 | | |
| 23915 | | int x = 1; |
| 23916 | | int y = 0; |
| 23917 | | int z; |
| 23918 | | int nan; |
| 23919 | | |
| 23920 | | int main () |
| 23921 | | { |
| 23922 | | signal (SIGFPE, sigfpe_handler); |
| 23923 | | /* IRIX and AIX (when "xlc -qcheck" is used) yield signal SIGTRAP. */ |
| 23924 | | #if (defined (__sgi) || defined (_AIX)) && defined (SIGTRAP) |
| 23925 | | signal (SIGTRAP, sigfpe_handler); |
| 23926 | | #endif |
| 23927 | | /* Linux/SPARC yields signal SIGILL. */ |
| 23928 | | #if defined (__sparc__) && defined (__linux__) |
| 23929 | | signal (SIGILL, sigfpe_handler); |
| 23930 | | #endif |
| 23931 | | |
| 23932 | | z = x / y; |
| 23933 | | nan = y / y; |
| 23934 | | exit (1); |
| 23935 | | } |
| 23936 | | |
| 23937 | | _ACEOF |
| 23938 | | rm -f conftest$ac_exeext |
| 23939 | | if { (ac_try="$ac_link" |
| 23940 | | case "(($ac_try" in |
| 23941 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 23942 | | *) ac_try_echo=$ac_try;; |
| 23943 | | esac |
| 23944 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 23945 | | (eval "$ac_link") 2>&5 |
| 23946 | | ac_status=$? |
| 23947 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 23948 | | (exit $ac_status); } && { ac_try='./conftest$ac_exeext' |
| 23949 | | { (case "(($ac_try" in |
| 23950 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 23951 | | *) ac_try_echo=$ac_try;; |
| 23952 | | esac |
| 23953 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 23954 | | (eval "$ac_try") 2>&5 |
| 23955 | | ac_status=$? |
| 23956 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 23957 | | (exit $ac_status); }; }; then |
| 23958 | | gt_cv_int_divbyzero_sigfpe=yes |
| 23959 | | else |
| 23960 | | echo "$as_me: program exited with status $ac_status" >&5 |
| 23961 | | echo "$as_me: failed program was:" >&5 |
| 23962 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 23963 | | |
| 23964 | | ( exit $ac_status ) |
| 23965 | | gt_cv_int_divbyzero_sigfpe=no |
| 23966 | | fi |
| 23967 | | rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext |
| 23968 | | fi |
| 23969 | | |
| 23970 | | |
| 23971 | | |
| 23972 | | fi |
| 23973 | | { echo "$as_me:$LINENO: result: $gt_cv_int_divbyzero_sigfpe" >&5 |
| 23974 | | echo "${ECHO_T}$gt_cv_int_divbyzero_sigfpe" >&6; } |
| 23975 | | case "$gt_cv_int_divbyzero_sigfpe" in |
| 23976 | | *yes) value=1;; |
| 23977 | | *) value=0;; |
| 23978 | | esac |
| 23979 | | |
| 23980 | | cat >>confdefs.h <<_ACEOF |
| 23981 | | #define INTDIV0_RAISES_SIGFPE $value |
| 23982 | | _ACEOF |
| 23983 | | |
| 23984 | | |
| 23985 | | |
| 23986 | | { echo "$as_me:$LINENO: checking for inttypes.h" >&5 |
| 23987 | | echo $ECHO_N "checking for inttypes.h... $ECHO_C" >&6; } |
| 23988 | | if test "${gl_cv_header_inttypes_h+set}" = set; then |
| 23989 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 23990 | | else |
| 23991 | | cat >conftest.$ac_ext <<_ACEOF |
| 23992 | | /* confdefs.h. */ |
| 23993 | | _ACEOF |
| 23994 | | cat confdefs.h >>conftest.$ac_ext |
| 23995 | | cat >>conftest.$ac_ext <<_ACEOF |
| 23996 | | /* end confdefs.h. */ |
| 23997 | | #include <sys/types.h> |
| 23998 | | #include <inttypes.h> |
| 23999 | | int |
| 24000 | | main () |
| 24001 | | { |
| 24002 | | uintmax_t i = (uintmax_t) -1; |
| 24003 | | ; |
| 24004 | | return 0; |
| 24005 | | } |
| 24006 | | _ACEOF |
| 24007 | | rm -f conftest.$ac_objext |
| 24008 | | if { (ac_try="$ac_compile" |
| 24009 | | case "(($ac_try" in |
| 24010 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 24011 | | *) ac_try_echo=$ac_try;; |
| 24012 | | esac |
| 24013 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 24014 | | (eval "$ac_compile") 2>conftest.er1 |
| 24015 | | ac_status=$? |
| 24016 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 24017 | | rm -f conftest.er1 |
| 24018 | | cat conftest.err >&5 |
| 24019 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 24020 | | (exit $ac_status); } && { |
| 24021 | | test -z "$ac_c_werror_flag" || |
| 24022 | | test ! -s conftest.err |
| 24023 | | } && test -s conftest.$ac_objext; then |
| 24024 | | gl_cv_header_inttypes_h=yes |
| 24025 | | else |
| 24026 | | echo "$as_me: failed program was:" >&5 |
| 24027 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 24028 | | |
| 24029 | | gl_cv_header_inttypes_h=no |
| 24030 | | fi |
| 24031 | | |
| 24032 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 24033 | | fi |
| 24034 | | { echo "$as_me:$LINENO: result: $gl_cv_header_inttypes_h" >&5 |
| 24035 | | echo "${ECHO_T}$gl_cv_header_inttypes_h" >&6; } |
| 24036 | | if test $gl_cv_header_inttypes_h = yes; then |
| 24037 | | |
| 24038 | | cat >>confdefs.h <<_ACEOF |
| 24039 | | #define HAVE_INTTYPES_H_WITH_UINTMAX 1 |
| 24040 | | _ACEOF |
| 24041 | | |
| 24042 | | fi |
| 24043 | | |
| 24044 | | |
| 24045 | | { echo "$as_me:$LINENO: checking for unsigned long long" >&5 |
| 24046 | | echo $ECHO_N "checking for unsigned long long... $ECHO_C" >&6; } |
| 24047 | | if test "${ac_cv_type_unsigned_long_long+set}" = set; then |
| 24048 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 24049 | | else |
| 24050 | | cat >conftest.$ac_ext <<_ACEOF |
| 24051 | | /* confdefs.h. */ |
| 24052 | | _ACEOF |
| 24053 | | cat confdefs.h >>conftest.$ac_ext |
| 24054 | | cat >>conftest.$ac_ext <<_ACEOF |
| 24055 | | /* end confdefs.h. */ |
| 24056 | | unsigned long long ull = 1ULL; int i = 63; |
| 24057 | | int |
| 24058 | | main () |
| 24059 | | { |
| 24060 | | unsigned long long ullmax = (unsigned long long) -1; |
| 24061 | | return ull << i | ull >> i | ullmax / ull | ullmax % ull; |
| 24062 | | ; |
| 24063 | | return 0; |
| 24064 | | } |
| 24065 | | _ACEOF |
| 24066 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 24067 | | if { (ac_try="$ac_link" |
| 24068 | | case "(($ac_try" in |
| 24069 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 24070 | | *) ac_try_echo=$ac_try;; |
| 24071 | | esac |
| 24072 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 24073 | | (eval "$ac_link") 2>conftest.er1 |
| 24074 | | ac_status=$? |
| 24075 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 24076 | | rm -f conftest.er1 |
| 24077 | | cat conftest.err >&5 |
| 24078 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 24079 | | (exit $ac_status); } && { |
| 24080 | | test -z "$ac_c_werror_flag" || |
| 24081 | | test ! -s conftest.err |
| 24082 | | } && test -s conftest$ac_exeext && |
| 24083 | | $as_test_x conftest$ac_exeext; then |
| 24084 | | ac_cv_type_unsigned_long_long=yes |
| 24085 | | else |
| 24086 | | echo "$as_me: failed program was:" >&5 |
| 24087 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 24088 | | |
| 24089 | | ac_cv_type_unsigned_long_long=no |
| 24090 | | fi |
| 24091 | | |
| 24092 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 24093 | | conftest$ac_exeext conftest.$ac_ext |
| 24094 | | fi |
| 24095 | | { echo "$as_me:$LINENO: result: $ac_cv_type_unsigned_long_long" >&5 |
| 24096 | | echo "${ECHO_T}$ac_cv_type_unsigned_long_long" >&6; } |
| 24097 | | if test $ac_cv_type_unsigned_long_long = yes; then |
| 24098 | | |
| 24099 | | cat >>confdefs.h <<\_ACEOF |
| 24100 | | #define HAVE_UNSIGNED_LONG_LONG 1 |
| 24101 | | _ACEOF |
| 24102 | | |
| 24103 | | fi |
| 24104 | | |
| 24105 | | |
| 24106 | | |
| 24107 | | |
| 24108 | | if test $gl_cv_header_inttypes_h = no && test $gl_cv_header_stdint_h = no; then |
| 24109 | | |
| 24110 | | test $ac_cv_type_unsigned_long_long = yes \ |
| 24111 | | && ac_type='unsigned long long' \ |
| 24112 | | || ac_type='unsigned long' |
| 24113 | | |
| 24114 | | cat >>confdefs.h <<_ACEOF |
| 24115 | | #define uintmax_t $ac_type |
| 24116 | | _ACEOF |
| 24117 | | |
| 24118 | | else |
| 24119 | | |
| 24120 | | cat >>confdefs.h <<\_ACEOF |
| 24121 | | #define HAVE_UINTMAX_T 1 |
| 24122 | | _ACEOF |
| 24123 | | |
| 24124 | | fi |
| 24125 | | |
| 24126 | | |
| 24127 | | { echo "$as_me:$LINENO: checking for inttypes.h" >&5 |
| 24128 | | echo $ECHO_N "checking for inttypes.h... $ECHO_C" >&6; } |
| 24129 | | if test "${gl_cv_header_inttypes_h+set}" = set; then |
| 24130 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 24131 | | else |
| 24132 | | |
| 24133 | | cat >conftest.$ac_ext <<_ACEOF |
| 24134 | | /* confdefs.h. */ |
| 24135 | | _ACEOF |
| 24136 | | cat confdefs.h >>conftest.$ac_ext |
| 24137 | | cat >>conftest.$ac_ext <<_ACEOF |
| 24138 | | /* end confdefs.h. */ |
| 24139 | | #include <sys/types.h> |
| 24140 | | #include <inttypes.h> |
| 24141 | | int |
| 24142 | | main () |
| 24143 | | { |
| 24144 | | |
| 24145 | | ; |
| 24146 | | return 0; |
| 24147 | | } |
| 24148 | | _ACEOF |
| 24149 | | rm -f conftest.$ac_objext |
| 24150 | | if { (ac_try="$ac_compile" |
| 24151 | | case "(($ac_try" in |
| 24152 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 24153 | | *) ac_try_echo=$ac_try;; |
| 24154 | | esac |
| 24155 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 24156 | | (eval "$ac_compile") 2>conftest.er1 |
| 24157 | | ac_status=$? |
| 24158 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 24159 | | rm -f conftest.er1 |
| 24160 | | cat conftest.err >&5 |
| 24161 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 24162 | | (exit $ac_status); } && { |
| 24163 | | test -z "$ac_c_werror_flag" || |
| 24164 | | test ! -s conftest.err |
| 24165 | | } && test -s conftest.$ac_objext; then |
| 24166 | | gl_cv_header_inttypes_h=yes |
| 24167 | | else |
| 24168 | | echo "$as_me: failed program was:" >&5 |
| 24169 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 24170 | | |
| 24171 | | gl_cv_header_inttypes_h=no |
| 24172 | | fi |
| 24173 | | |
| 24174 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 24175 | | |
| 24176 | | fi |
| 24177 | | { echo "$as_me:$LINENO: result: $gl_cv_header_inttypes_h" >&5 |
| 24178 | | echo "${ECHO_T}$gl_cv_header_inttypes_h" >&6; } |
| 24179 | | if test $gl_cv_header_inttypes_h = yes; then |
| 24180 | | |
| 24181 | | cat >>confdefs.h <<_ACEOF |
| 24182 | | #define HAVE_INTTYPES_H 1 |
| 24183 | | _ACEOF |
| 24184 | | |
| 24185 | | fi |
| 24186 | | |
| 24187 | | |
| 24188 | | |
| 24189 | | if test $gl_cv_header_inttypes_h = yes; then |
| 24190 | | { echo "$as_me:$LINENO: checking whether the inttypes.h PRIxNN macros are broken" >&5 |
| 24191 | | echo $ECHO_N "checking whether the inttypes.h PRIxNN macros are broken... $ECHO_C" >&6; } |
| 24192 | | if test "${gt_cv_inttypes_pri_broken+set}" = set; then |
| 24193 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 24194 | | else |
| 24195 | | |
| 24196 | | cat >conftest.$ac_ext <<_ACEOF |
| 24197 | | /* confdefs.h. */ |
| 24198 | | _ACEOF |
| 24199 | | cat confdefs.h >>conftest.$ac_ext |
| 24200 | | cat >>conftest.$ac_ext <<_ACEOF |
| 24201 | | /* end confdefs.h. */ |
| 24202 | | #include <inttypes.h> |
| 24203 | | #ifdef PRId32 |
| 24204 | | char *p = PRId32; |
| 24205 | | #endif |
| 24206 | | |
| 24207 | | int |
| 24208 | | main () |
| 24209 | | { |
| 24210 | | |
| 24211 | | ; |
| 24212 | | return 0; |
| 24213 | | } |
| 24214 | | _ACEOF |
| 24215 | | rm -f conftest.$ac_objext |
| 24216 | | if { (ac_try="$ac_compile" |
| 24217 | | case "(($ac_try" in |
| 24218 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 24219 | | *) ac_try_echo=$ac_try;; |
| 24220 | | esac |
| 24221 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 24222 | | (eval "$ac_compile") 2>conftest.er1 |
| 24223 | | ac_status=$? |
| 24224 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 24225 | | rm -f conftest.er1 |
| 24226 | | cat conftest.err >&5 |
| 24227 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 24228 | | (exit $ac_status); } && { |
| 24229 | | test -z "$ac_c_werror_flag" || |
| 24230 | | test ! -s conftest.err |
| 24231 | | } && test -s conftest.$ac_objext; then |
| 24232 | | gt_cv_inttypes_pri_broken=no |
| 24233 | | else |
| 24234 | | echo "$as_me: failed program was:" >&5 |
| 24235 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 24236 | | |
| 24237 | | gt_cv_inttypes_pri_broken=yes |
| 24238 | | fi |
| 24239 | | |
| 24240 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 24241 | | |
| 24242 | | fi |
| 24243 | | { echo "$as_me:$LINENO: result: $gt_cv_inttypes_pri_broken" >&5 |
| 24244 | | echo "${ECHO_T}$gt_cv_inttypes_pri_broken" >&6; } |
| 24245 | | fi |
| 24246 | | if test "$gt_cv_inttypes_pri_broken" = yes; then |
| 24247 | | |
| 24248 | | cat >>confdefs.h <<_ACEOF |
| 24249 | | #define PRI_MACROS_BROKEN 1 |
| 24250 | | _ACEOF |
| 24251 | | |
| 24252 | | fi |
| 24253 | | |
| 24254 | | |
| 24435 | | |
| 24436 | | |
| 24437 | | |
| 24438 | | |
| 24439 | | # Check whether --enable-threads was given. |
| 24440 | | if test "${enable_threads+set}" = set; then |
| 24441 | | enableval=$enable_threads; gl_use_threads=$enableval |
| 24442 | | else |
| 24443 | | gl_use_threads=yes |
| 24444 | | fi |
| 24445 | | |
| 24446 | | gl_threads_api=none |
| 24447 | | LIBTHREAD= |
| 24448 | | LTLIBTHREAD= |
| 24449 | | LIBMULTITHREAD= |
| 24450 | | LTLIBMULTITHREAD= |
| 24451 | | if test "$gl_use_threads" != no; then |
| 24452 | | { echo "$as_me:$LINENO: checking whether imported symbols can be declared weak" >&5 |
| 24453 | | echo $ECHO_N "checking whether imported symbols can be declared weak... $ECHO_C" >&6; } |
| 24454 | | gl_have_weak=no |
| 24455 | | cat >conftest.$ac_ext <<_ACEOF |
| 24456 | | /* confdefs.h. */ |
| 24457 | | _ACEOF |
| 24458 | | cat confdefs.h >>conftest.$ac_ext |
| 24459 | | cat >>conftest.$ac_ext <<_ACEOF |
| 24460 | | /* end confdefs.h. */ |
| 24461 | | extern void xyzzy (); |
| 24462 | | #pragma weak xyzzy |
| 24463 | | int |
| 24464 | | main () |
| 24465 | | { |
| 24466 | | xyzzy(); |
| 24467 | | ; |
| 24468 | | return 0; |
| 24469 | | } |
| 24470 | | _ACEOF |
| 24471 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 24472 | | if { (ac_try="$ac_link" |
| 24473 | | case "(($ac_try" in |
| 24474 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 24475 | | *) ac_try_echo=$ac_try;; |
| 24476 | | esac |
| 24477 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 24478 | | (eval "$ac_link") 2>conftest.er1 |
| 24479 | | ac_status=$? |
| 24480 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 24481 | | rm -f conftest.er1 |
| 24482 | | cat conftest.err >&5 |
| 24483 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 24484 | | (exit $ac_status); } && { |
| 24485 | | test -z "$ac_c_werror_flag" || |
| 24486 | | test ! -s conftest.err |
| 24487 | | } && test -s conftest$ac_exeext && |
| 24488 | | $as_test_x conftest$ac_exeext; then |
| 24489 | | gl_have_weak=yes |
| 24490 | | else |
| 24491 | | echo "$as_me: failed program was:" >&5 |
| 24492 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 24493 | | |
| 24494 | | |
| 24495 | | fi |
| 24496 | | |
| 24497 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 24498 | | conftest$ac_exeext conftest.$ac_ext |
| 24499 | | { echo "$as_me:$LINENO: result: $gl_have_weak" >&5 |
| 24500 | | echo "${ECHO_T}$gl_have_weak" >&6; } |
| 24501 | | if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then |
| 24502 | | # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that |
| 24503 | | # it groks <pthread.h>. |
| 24504 | | gl_save_CPPFLAGS="$CPPFLAGS" |
| 24505 | | CPPFLAGS="$CPPFLAGS -D_REENTRANT" |
| 24506 | | if test "${ac_cv_header_pthread_h+set}" = set; then |
| 24507 | | { echo "$as_me:$LINENO: checking for pthread.h" >&5 |
| 24508 | | echo $ECHO_N "checking for pthread.h... $ECHO_C" >&6; } |
| 24509 | | if test "${ac_cv_header_pthread_h+set}" = set; then |
| 24510 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 24511 | | fi |
| 24512 | | { echo "$as_me:$LINENO: result: $ac_cv_header_pthread_h" >&5 |
| 24513 | | echo "${ECHO_T}$ac_cv_header_pthread_h" >&6; } |
| 24514 | | else |
| 24515 | | # Is the header compilable? |
| 24516 | | { echo "$as_me:$LINENO: checking pthread.h usability" >&5 |
| 24517 | | echo $ECHO_N "checking pthread.h usability... $ECHO_C" >&6; } |
| 24518 | | cat >conftest.$ac_ext <<_ACEOF |
| 24519 | | /* confdefs.h. */ |
| 24520 | | _ACEOF |
| 24521 | | cat confdefs.h >>conftest.$ac_ext |
| 24522 | | cat >>conftest.$ac_ext <<_ACEOF |
| 24523 | | /* end confdefs.h. */ |
| 24524 | | $ac_includes_default |
| 24525 | | #include <pthread.h> |
| 24526 | | _ACEOF |
| 24527 | | rm -f conftest.$ac_objext |
| 24528 | | if { (ac_try="$ac_compile" |
| 24529 | | case "(($ac_try" in |
| 24530 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 24531 | | *) ac_try_echo=$ac_try;; |
| 24532 | | esac |
| 24533 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 24534 | | (eval "$ac_compile") 2>conftest.er1 |
| 24535 | | ac_status=$? |
| 24536 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 24537 | | rm -f conftest.er1 |
| 24538 | | cat conftest.err >&5 |
| 24539 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 24540 | | (exit $ac_status); } && { |
| 24541 | | test -z "$ac_c_werror_flag" || |
| 24542 | | test ! -s conftest.err |
| 24543 | | } && test -s conftest.$ac_objext; then |
| 24544 | | ac_header_compiler=yes |
| 24545 | | else |
| 24546 | | echo "$as_me: failed program was:" >&5 |
| 24547 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 24548 | | |
| 24549 | | ac_header_compiler=no |
| 24550 | | fi |
| 24551 | | |
| 24552 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 24553 | | { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 |
| 24554 | | echo "${ECHO_T}$ac_header_compiler" >&6; } |
| 24555 | | |
| 24556 | | # Is the header present? |
| 24557 | | { echo "$as_me:$LINENO: checking pthread.h presence" >&5 |
| 24558 | | echo $ECHO_N "checking pthread.h presence... $ECHO_C" >&6; } |
| 24559 | | cat >conftest.$ac_ext <<_ACEOF |
| 24560 | | /* confdefs.h. */ |
| 24561 | | _ACEOF |
| 24562 | | cat confdefs.h >>conftest.$ac_ext |
| 24563 | | cat >>conftest.$ac_ext <<_ACEOF |
| 24564 | | /* end confdefs.h. */ |
| 24565 | | #include <pthread.h> |
| 24566 | | _ACEOF |
| 24567 | | if { (ac_try="$ac_cpp conftest.$ac_ext" |
| 24568 | | case "(($ac_try" in |
| 24569 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 24570 | | *) ac_try_echo=$ac_try;; |
| 24571 | | esac |
| 24572 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 24573 | | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 |
| 24574 | | ac_status=$? |
| 24575 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 24576 | | rm -f conftest.er1 |
| 24577 | | cat conftest.err >&5 |
| 24578 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 24579 | | (exit $ac_status); } >/dev/null && { |
| 24580 | | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| 24581 | | test ! -s conftest.err |
| 24582 | | }; then |
| 24583 | | ac_header_preproc=yes |
| 24584 | | else |
| 24585 | | echo "$as_me: failed program was:" >&5 |
| 24586 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 24587 | | |
| 24588 | | ac_header_preproc=no |
| 24589 | | fi |
| 24590 | | |
| 24591 | | rm -f conftest.err conftest.$ac_ext |
| 24592 | | { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 |
| 24593 | | echo "${ECHO_T}$ac_header_preproc" >&6; } |
| 24594 | | |
| 24595 | | # So? What about this header? |
| 24596 | | case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in |
| 24597 | | yes:no: ) |
| 24598 | | { echo "$as_me:$LINENO: WARNING: pthread.h: accepted by the compiler, rejected by the preprocessor!" >&5 |
| 24599 | | echo "$as_me: WARNING: pthread.h: accepted by the compiler, rejected by the preprocessor!" >&2;} |
| 24600 | | { echo "$as_me:$LINENO: WARNING: pthread.h: proceeding with the compiler's result" >&5 |
| 24601 | | echo "$as_me: WARNING: pthread.h: proceeding with the compiler's result" >&2;} |
| 24602 | | ac_header_preproc=yes |
| 24603 | | ;; |
| 24604 | | no:yes:* ) |
| 24605 | | { echo "$as_me:$LINENO: WARNING: pthread.h: present but cannot be compiled" >&5 |
| 24606 | | echo "$as_me: WARNING: pthread.h: present but cannot be compiled" >&2;} |
| 24607 | | { echo "$as_me:$LINENO: WARNING: pthread.h: check for missing prerequisite headers?" >&5 |
| 24608 | | echo "$as_me: WARNING: pthread.h: check for missing prerequisite headers?" >&2;} |
| 24609 | | { echo "$as_me:$LINENO: WARNING: pthread.h: see the Autoconf documentation" >&5 |
| 24610 | | echo "$as_me: WARNING: pthread.h: see the Autoconf documentation" >&2;} |
| 24611 | | { echo "$as_me:$LINENO: WARNING: pthread.h: section \"Present But Cannot Be Compiled\"" >&5 |
| 24612 | | echo "$as_me: WARNING: pthread.h: section \"Present But Cannot Be Compiled\"" >&2;} |
| 24613 | | { echo "$as_me:$LINENO: WARNING: pthread.h: proceeding with the preprocessor's result" >&5 |
| 24614 | | echo "$as_me: WARNING: pthread.h: proceeding with the preprocessor's result" >&2;} |
| 24615 | | { echo "$as_me:$LINENO: WARNING: pthread.h: in the future, the compiler will take precedence" >&5 |
| 24616 | | echo "$as_me: WARNING: pthread.h: in the future, the compiler will take precedence" >&2;} |
| 24617 | | |
| 24618 | | ;; |
| 24619 | | esac |
| 24620 | | { echo "$as_me:$LINENO: checking for pthread.h" >&5 |
| 24621 | | echo $ECHO_N "checking for pthread.h... $ECHO_C" >&6; } |
| 24622 | | if test "${ac_cv_header_pthread_h+set}" = set; then |
| 24623 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 24624 | | else |
| 24625 | | ac_cv_header_pthread_h=$ac_header_preproc |
| 24626 | | fi |
| 24627 | | { echo "$as_me:$LINENO: result: $ac_cv_header_pthread_h" >&5 |
| 24628 | | echo "${ECHO_T}$ac_cv_header_pthread_h" >&6; } |
| 24629 | | |
| 24630 | | fi |
| 24631 | | if test $ac_cv_header_pthread_h = yes; then |
| 24632 | | gl_have_pthread_h=yes |
| 24633 | | else |
| 24634 | | gl_have_pthread_h=no |
| 24635 | | fi |
| 24636 | | |
| 24637 | | |
| 24638 | | CPPFLAGS="$gl_save_CPPFLAGS" |
| 24639 | | if test "$gl_have_pthread_h" = yes; then |
| 24640 | | # Other possible tests: |
| 24641 | | # -lpthreads (FSU threads, PCthreads) |
| 24642 | | # -lgthreads |
| 24643 | | case "$host_os" in |
| 24644 | | osf*) |
| 24645 | | # On OSF/1, the compiler needs the flag -D_REENTRANT so that it |
| 24646 | | # groks <pthread.h>. cc also understands the flag -pthread, but |
| 24647 | | # we don't use it because 1. gcc-2.95 doesn't understand -pthread, |
| 24648 | | # 2. putting a flag into CPPFLAGS that has an effect on the linker |
| 24649 | | # causes the AC_TRY_LINK test below to succeed unexpectedly, |
| 24650 | | # leading to wrong values of LIBTHREAD and LTLIBTHREAD. |
| 24651 | | CPPFLAGS="$CPPFLAGS -D_REENTRANT" |
| 24652 | | ;; |
| 24653 | | esac |
| 24654 | | gl_have_pthread= |
| 24655 | | # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist |
| 24656 | | # in libc. IRIX 6.5 has the first one in both libc and libpthread, but |
| 24657 | | # the second one only in libpthread, and lock.c needs it. |
| 24658 | | cat >conftest.$ac_ext <<_ACEOF |
| 24659 | | /* confdefs.h. */ |
| 24660 | | _ACEOF |
| 24661 | | cat confdefs.h >>conftest.$ac_ext |
| 24662 | | cat >>conftest.$ac_ext <<_ACEOF |
| 24663 | | /* end confdefs.h. */ |
| 24664 | | #include <pthread.h> |
| 24665 | | int |
| 24666 | | main () |
| 24667 | | { |
| 24668 | | pthread_mutex_lock((pthread_mutex_t*)0); |
| 24669 | | pthread_mutexattr_init((pthread_mutexattr_t*)0); |
| 24670 | | ; |
| 24671 | | return 0; |
| 24672 | | } |
| 24673 | | _ACEOF |
| 24674 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 24675 | | if { (ac_try="$ac_link" |
| 24676 | | case "(($ac_try" in |
| 24677 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 24678 | | *) ac_try_echo=$ac_try;; |
| 24679 | | esac |
| 24680 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 24681 | | (eval "$ac_link") 2>conftest.er1 |
| 24682 | | ac_status=$? |
| 24683 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 24684 | | rm -f conftest.er1 |
| 24685 | | cat conftest.err >&5 |
| 24686 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 24687 | | (exit $ac_status); } && { |
| 24688 | | test -z "$ac_c_werror_flag" || |
| 24689 | | test ! -s conftest.err |
| 24690 | | } && test -s conftest$ac_exeext && |
| 24691 | | $as_test_x conftest$ac_exeext; then |
| 24692 | | gl_have_pthread=yes |
| 24693 | | else |
| 24694 | | echo "$as_me: failed program was:" >&5 |
| 24695 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 24696 | | |
| 24697 | | |
| 24698 | | fi |
| 24699 | | |
| 24700 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 24701 | | conftest$ac_exeext conftest.$ac_ext |
| 24702 | | # Test for libpthread by looking for pthread_kill. (Not pthread_self, |
| 24703 | | # since it is defined as a macro on OSF/1.) |
| 24704 | | if test -n "$gl_have_pthread"; then |
| 24705 | | # The program links fine without libpthread. But it may actually |
| 24706 | | # need to link with libpthread in order to create multiple threads. |
| 24707 | | { echo "$as_me:$LINENO: checking for pthread_kill in -lpthread" >&5 |
| 24708 | | echo $ECHO_N "checking for pthread_kill in -lpthread... $ECHO_C" >&6; } |
| 24709 | | if test "${ac_cv_lib_pthread_pthread_kill+set}" = set; then |
| 24710 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 24711 | | else |
| 24712 | | ac_check_lib_save_LIBS=$LIBS |
| 24713 | | LIBS="-lpthread $LIBS" |
| 24714 | | cat >conftest.$ac_ext <<_ACEOF |
| 24715 | | /* confdefs.h. */ |
| 24716 | | _ACEOF |
| 24717 | | cat confdefs.h >>conftest.$ac_ext |
| 24718 | | cat >>conftest.$ac_ext <<_ACEOF |
| 24719 | | /* end confdefs.h. */ |
| 24720 | | |
| 24721 | | /* Override any GCC internal prototype to avoid an error. |
| 24722 | | Use char because int might match the return type of a GCC |
| 24723 | | builtin and then its argument prototype would still apply. */ |
| 24724 | | #ifdef __cplusplus |
| 24725 | | extern "C" |
| 24726 | | #endif |
| 24727 | | char pthread_kill (); |
| 24728 | | int |
| 24729 | | main () |
| 24730 | | { |
| 24731 | | return pthread_kill (); |
| 24732 | | ; |
| 24733 | | return 0; |
| 24734 | | } |
| 24735 | | _ACEOF |
| 24736 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 24737 | | if { (ac_try="$ac_link" |
| 24738 | | case "(($ac_try" in |
| 24739 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 24740 | | *) ac_try_echo=$ac_try;; |
| 24741 | | esac |
| 24742 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 24743 | | (eval "$ac_link") 2>conftest.er1 |
| 24744 | | ac_status=$? |
| 24745 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 24746 | | rm -f conftest.er1 |
| 24747 | | cat conftest.err >&5 |
| 24748 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 24749 | | (exit $ac_status); } && { |
| 24750 | | test -z "$ac_c_werror_flag" || |
| 24751 | | test ! -s conftest.err |
| 24752 | | } && test -s conftest$ac_exeext && |
| 24753 | | $as_test_x conftest$ac_exeext; then |
| 24754 | | ac_cv_lib_pthread_pthread_kill=yes |
| 24755 | | else |
| 24756 | | echo "$as_me: failed program was:" >&5 |
| 24757 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 24758 | | |
| 24759 | | ac_cv_lib_pthread_pthread_kill=no |
| 24760 | | fi |
| 24761 | | |
| 24762 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 24763 | | conftest$ac_exeext conftest.$ac_ext |
| 24764 | | LIBS=$ac_check_lib_save_LIBS |
| 24765 | | fi |
| 24766 | | { echo "$as_me:$LINENO: result: $ac_cv_lib_pthread_pthread_kill" >&5 |
| 24767 | | echo "${ECHO_T}$ac_cv_lib_pthread_pthread_kill" >&6; } |
| 24768 | | if test $ac_cv_lib_pthread_pthread_kill = yes; then |
| 24769 | | LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread |
| 24770 | | # On Solaris and HP-UX, most pthread functions exist also in libc. |
| 24771 | | # Therefore pthread_in_use() needs to actually try to create a |
| 24772 | | # thread: pthread_create from libc will fail, whereas |
| 24773 | | # pthread_create will actually create a thread. |
| 24774 | | case "$host_os" in |
| 24775 | | solaris* | hpux*) |
| 24776 | | |
| 24777 | | cat >>confdefs.h <<\_ACEOF |
| 24778 | | #define PTHREAD_IN_USE_DETECTION_HARD 1 |
| 24779 | | _ACEOF |
| 24780 | | |
| 24781 | | esac |
| 24782 | | |
| 24783 | | fi |
| 24784 | | |
| 24785 | | else |
| 24786 | | # Some library is needed. Try libpthread and libc_r. |
| 24787 | | { echo "$as_me:$LINENO: checking for pthread_kill in -lpthread" >&5 |
| 24788 | | echo $ECHO_N "checking for pthread_kill in -lpthread... $ECHO_C" >&6; } |
| 24789 | | if test "${ac_cv_lib_pthread_pthread_kill+set}" = set; then |
| 24790 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 24791 | | else |
| 24792 | | ac_check_lib_save_LIBS=$LIBS |
| 24793 | | LIBS="-lpthread $LIBS" |
| 24794 | | cat >conftest.$ac_ext <<_ACEOF |
| 24795 | | /* confdefs.h. */ |
| 24796 | | _ACEOF |
| 24797 | | cat confdefs.h >>conftest.$ac_ext |
| 24798 | | cat >>conftest.$ac_ext <<_ACEOF |
| 24799 | | /* end confdefs.h. */ |
| 24800 | | |
| 24801 | | /* Override any GCC internal prototype to avoid an error. |
| 24802 | | Use char because int might match the return type of a GCC |
| 24803 | | builtin and then its argument prototype would still apply. */ |
| 24804 | | #ifdef __cplusplus |
| 24805 | | extern "C" |
| 24806 | | #endif |
| 24807 | | char pthread_kill (); |
| 24808 | | int |
| 24809 | | main () |
| 24810 | | { |
| 24811 | | return pthread_kill (); |
| 24812 | | ; |
| 24813 | | return 0; |
| 24814 | | } |
| 24815 | | _ACEOF |
| 24816 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 24817 | | if { (ac_try="$ac_link" |
| 24818 | | case "(($ac_try" in |
| 24819 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 24820 | | *) ac_try_echo=$ac_try;; |
| 24821 | | esac |
| 24822 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 24823 | | (eval "$ac_link") 2>conftest.er1 |
| 24824 | | ac_status=$? |
| 24825 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 24826 | | rm -f conftest.er1 |
| 24827 | | cat conftest.err >&5 |
| 24828 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 24829 | | (exit $ac_status); } && { |
| 24830 | | test -z "$ac_c_werror_flag" || |
| 24831 | | test ! -s conftest.err |
| 24832 | | } && test -s conftest$ac_exeext && |
| 24833 | | $as_test_x conftest$ac_exeext; then |
| 24834 | | ac_cv_lib_pthread_pthread_kill=yes |
| 24835 | | else |
| 24836 | | echo "$as_me: failed program was:" >&5 |
| 24837 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 24838 | | |
| 24839 | | ac_cv_lib_pthread_pthread_kill=no |
| 24840 | | fi |
| 24841 | | |
| 24842 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 24843 | | conftest$ac_exeext conftest.$ac_ext |
| 24844 | | LIBS=$ac_check_lib_save_LIBS |
| 24845 | | fi |
| 24846 | | { echo "$as_me:$LINENO: result: $ac_cv_lib_pthread_pthread_kill" >&5 |
| 24847 | | echo "${ECHO_T}$ac_cv_lib_pthread_pthread_kill" >&6; } |
| 24848 | | if test $ac_cv_lib_pthread_pthread_kill = yes; then |
| 24849 | | gl_have_pthread=yes |
| 24850 | | LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread |
| 24851 | | LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread |
| 24852 | | fi |
| 24853 | | |
| 24854 | | if test -z "$gl_have_pthread"; then |
| 24855 | | # For FreeBSD 4. |
| 24856 | | { echo "$as_me:$LINENO: checking for pthread_kill in -lc_r" >&5 |
| 24857 | | echo $ECHO_N "checking for pthread_kill in -lc_r... $ECHO_C" >&6; } |
| 24858 | | if test "${ac_cv_lib_c_r_pthread_kill+set}" = set; then |
| 24859 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 24860 | | else |
| 24861 | | ac_check_lib_save_LIBS=$LIBS |
| 24862 | | LIBS="-lc_r $LIBS" |
| 24863 | | cat >conftest.$ac_ext <<_ACEOF |
| 24864 | | /* confdefs.h. */ |
| 24865 | | _ACEOF |
| 24866 | | cat confdefs.h >>conftest.$ac_ext |
| 24867 | | cat >>conftest.$ac_ext <<_ACEOF |
| 24868 | | /* end confdefs.h. */ |
| 24869 | | |
| 24870 | | /* Override any GCC internal prototype to avoid an error. |
| 24871 | | Use char because int might match the return type of a GCC |
| 24872 | | builtin and then its argument prototype would still apply. */ |
| 24873 | | #ifdef __cplusplus |
| 24874 | | extern "C" |
| 24875 | | #endif |
| 24876 | | char pthread_kill (); |
| 24877 | | int |
| 24878 | | main () |
| 24879 | | { |
| 24880 | | return pthread_kill (); |
| 24881 | | ; |
| 24882 | | return 0; |
| 24883 | | } |
| 24884 | | _ACEOF |
| 24885 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 24886 | | if { (ac_try="$ac_link" |
| 24887 | | case "(($ac_try" in |
| 24888 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 24889 | | *) ac_try_echo=$ac_try;; |
| 24890 | | esac |
| 24891 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 24892 | | (eval "$ac_link") 2>conftest.er1 |
| 24893 | | ac_status=$? |
| 24894 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 24895 | | rm -f conftest.er1 |
| 24896 | | cat conftest.err >&5 |
| 24897 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 24898 | | (exit $ac_status); } && { |
| 24899 | | test -z "$ac_c_werror_flag" || |
| 24900 | | test ! -s conftest.err |
| 24901 | | } && test -s conftest$ac_exeext && |
| 24902 | | $as_test_x conftest$ac_exeext; then |
| 24903 | | ac_cv_lib_c_r_pthread_kill=yes |
| 24904 | | else |
| 24905 | | echo "$as_me: failed program was:" >&5 |
| 24906 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 24907 | | |
| 24908 | | ac_cv_lib_c_r_pthread_kill=no |
| 24909 | | fi |
| 24910 | | |
| 24911 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 24912 | | conftest$ac_exeext conftest.$ac_ext |
| 24913 | | LIBS=$ac_check_lib_save_LIBS |
| 24914 | | fi |
| 24915 | | { echo "$as_me:$LINENO: result: $ac_cv_lib_c_r_pthread_kill" >&5 |
| 24916 | | echo "${ECHO_T}$ac_cv_lib_c_r_pthread_kill" >&6; } |
| 24917 | | if test $ac_cv_lib_c_r_pthread_kill = yes; then |
| 24918 | | gl_have_pthread=yes |
| 24919 | | LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r |
| 24920 | | LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r |
| 24921 | | fi |
| 24922 | | |
| 24923 | | fi |
| 24924 | | fi |
| 24925 | | if test -n "$gl_have_pthread"; then |
| 24926 | | gl_threads_api=posix |
| 24927 | | |
| 24928 | | cat >>confdefs.h <<\_ACEOF |
| 24929 | | #define USE_POSIX_THREADS 1 |
| 24930 | | _ACEOF |
| 24931 | | |
| 24932 | | if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then |
| 24933 | | if test $gl_have_weak = yes; then |
| 24934 | | |
| 24935 | | cat >>confdefs.h <<\_ACEOF |
| 24936 | | #define USE_POSIX_THREADS_WEAK 1 |
| 24937 | | _ACEOF |
| 24938 | | |
| 24939 | | LIBTHREAD= |
| 24940 | | LTLIBTHREAD= |
| 24941 | | fi |
| 24942 | | fi |
| 24943 | | # OSF/1 4.0 and MacOS X 10.1 lack the pthread_rwlock_t type and the |
| 24944 | | # pthread_rwlock_* functions. |
| 24945 | | { echo "$as_me:$LINENO: checking for pthread_rwlock_t" >&5 |
| 24946 | | echo $ECHO_N "checking for pthread_rwlock_t... $ECHO_C" >&6; } |
| 24947 | | if test "${ac_cv_type_pthread_rwlock_t+set}" = set; then |
| 24948 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 24949 | | else |
| 24950 | | cat >conftest.$ac_ext <<_ACEOF |
| 24951 | | /* confdefs.h. */ |
| 24952 | | _ACEOF |
| 24953 | | cat confdefs.h >>conftest.$ac_ext |
| 24954 | | cat >>conftest.$ac_ext <<_ACEOF |
| 24955 | | /* end confdefs.h. */ |
| 24956 | | #include <pthread.h> |
| 24957 | | |
| 24958 | | typedef pthread_rwlock_t ac__type_new_; |
| 24959 | | int |
| 24960 | | main () |
| 24961 | | { |
| 24962 | | if ((ac__type_new_ *) 0) |
| 24963 | | return 0; |
| 24964 | | if (sizeof (ac__type_new_)) |
| 24965 | | return 0; |
| 24966 | | ; |
| 24967 | | return 0; |
| 24968 | | } |
| 24969 | | _ACEOF |
| 24970 | | rm -f conftest.$ac_objext |
| 24971 | | if { (ac_try="$ac_compile" |
| 24972 | | case "(($ac_try" in |
| 24973 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 24974 | | *) ac_try_echo=$ac_try;; |
| 24975 | | esac |
| 24976 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 24977 | | (eval "$ac_compile") 2>conftest.er1 |
| 24978 | | ac_status=$? |
| 24979 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 24980 | | rm -f conftest.er1 |
| 24981 | | cat conftest.err >&5 |
| 24982 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 24983 | | (exit $ac_status); } && { |
| 24984 | | test -z "$ac_c_werror_flag" || |
| 24985 | | test ! -s conftest.err |
| 24986 | | } && test -s conftest.$ac_objext; then |
| 24987 | | ac_cv_type_pthread_rwlock_t=yes |
| 24988 | | else |
| 24989 | | echo "$as_me: failed program was:" >&5 |
| 24990 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 24991 | | |
| 24992 | | ac_cv_type_pthread_rwlock_t=no |
| 24993 | | fi |
| 24994 | | |
| 24995 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 24996 | | fi |
| 24997 | | { echo "$as_me:$LINENO: result: $ac_cv_type_pthread_rwlock_t" >&5 |
| 24998 | | echo "${ECHO_T}$ac_cv_type_pthread_rwlock_t" >&6; } |
| 24999 | | if test $ac_cv_type_pthread_rwlock_t = yes; then |
| 25000 | | |
| 25001 | | cat >>confdefs.h <<\_ACEOF |
| 25002 | | #define HAVE_PTHREAD_RWLOCK 1 |
| 25003 | | _ACEOF |
| 25004 | | |
| 25005 | | fi |
| 25006 | | |
| 25007 | | # glibc defines PTHREAD_MUTEX_RECURSIVE as enum, not as a macro. |
| 25008 | | cat >conftest.$ac_ext <<_ACEOF |
| 25009 | | /* confdefs.h. */ |
| 25010 | | _ACEOF |
| 25011 | | cat confdefs.h >>conftest.$ac_ext |
| 25012 | | cat >>conftest.$ac_ext <<_ACEOF |
| 25013 | | /* end confdefs.h. */ |
| 25014 | | #include <pthread.h> |
| 25015 | | int |
| 25016 | | main () |
| 25017 | | { |
| 25018 | | #if __FreeBSD__ == 4 |
| 25019 | | error "No, in FreeBSD 4.0 recursive mutexes actually don't work." |
| 25020 | | #else |
| 25021 | | int x = (int)PTHREAD_MUTEX_RECURSIVE; |
| 25022 | | #endif |
| 25023 | | ; |
| 25024 | | return 0; |
| 25025 | | } |
| 25026 | | _ACEOF |
| 25027 | | rm -f conftest.$ac_objext |
| 25028 | | if { (ac_try="$ac_compile" |
| 25029 | | case "(($ac_try" in |
| 25030 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 25031 | | *) ac_try_echo=$ac_try;; |
| 25032 | | esac |
| 25033 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 25034 | | (eval "$ac_compile") 2>conftest.er1 |
| 25035 | | ac_status=$? |
| 25036 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 25037 | | rm -f conftest.er1 |
| 25038 | | cat conftest.err >&5 |
| 25039 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 25040 | | (exit $ac_status); } && { |
| 25041 | | test -z "$ac_c_werror_flag" || |
| 25042 | | test ! -s conftest.err |
| 25043 | | } && test -s conftest.$ac_objext; then |
| 25044 | | |
| 25045 | | cat >>confdefs.h <<\_ACEOF |
| 25046 | | #define HAVE_PTHREAD_MUTEX_RECURSIVE 1 |
| 25047 | | _ACEOF |
| 25048 | | |
| 25049 | | else |
| 25050 | | echo "$as_me: failed program was:" >&5 |
| 25051 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 25052 | | |
| 25053 | | |
| 25054 | | fi |
| 25055 | | |
| 25056 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 25057 | | # Some systems optimize for single-threaded programs by default, and |
| 25058 | | # need special flags to disable these optimizations. For example, the |
| 25059 | | # definition of 'errno' in <errno.h>. |
| 25060 | | case "$host_os" in |
| 25061 | | aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;; |
| 25062 | | solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;; |
| 25063 | | esac |
| 25064 | | fi |
| 25065 | | fi |
| 25066 | | fi |
| 25067 | | if test -z "$gl_have_pthread"; then |
| 25068 | | if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then |
| 25069 | | gl_have_solaristhread= |
| 25070 | | gl_save_LIBS="$LIBS" |
| 25071 | | LIBS="$LIBS -lthread" |
| 25072 | | cat >conftest.$ac_ext <<_ACEOF |
| 25073 | | /* confdefs.h. */ |
| 25074 | | _ACEOF |
| 25075 | | cat confdefs.h >>conftest.$ac_ext |
| 25076 | | cat >>conftest.$ac_ext <<_ACEOF |
| 25077 | | /* end confdefs.h. */ |
| 25078 | | #include <thread.h> |
| 25079 | | #include <synch.h> |
| 25080 | | int |
| 25081 | | main () |
| 25082 | | { |
| 25083 | | thr_self(); |
| 25084 | | ; |
| 25085 | | return 0; |
| 25086 | | } |
| 25087 | | _ACEOF |
| 25088 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 25089 | | if { (ac_try="$ac_link" |
| 25090 | | case "(($ac_try" in |
| 25091 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 25092 | | *) ac_try_echo=$ac_try;; |
| 25093 | | esac |
| 25094 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 25095 | | (eval "$ac_link") 2>conftest.er1 |
| 25096 | | ac_status=$? |
| 25097 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 25098 | | rm -f conftest.er1 |
| 25099 | | cat conftest.err >&5 |
| 25100 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 25101 | | (exit $ac_status); } && { |
| 25102 | | test -z "$ac_c_werror_flag" || |
| 25103 | | test ! -s conftest.err |
| 25104 | | } && test -s conftest$ac_exeext && |
| 25105 | | $as_test_x conftest$ac_exeext; then |
| 25106 | | gl_have_solaristhread=yes |
| 25107 | | else |
| 25108 | | echo "$as_me: failed program was:" >&5 |
| 25109 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 25110 | | |
| 25111 | | |
| 25112 | | fi |
| 25113 | | |
| 25114 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 25115 | | conftest$ac_exeext conftest.$ac_ext |
| 25116 | | LIBS="$gl_save_LIBS" |
| 25117 | | if test -n "$gl_have_solaristhread"; then |
| 25118 | | gl_threads_api=solaris |
| 25119 | | LIBTHREAD=-lthread |
| 25120 | | LTLIBTHREAD=-lthread |
| 25121 | | LIBMULTITHREAD="$LIBTHREAD" |
| 25122 | | LTLIBMULTITHREAD="$LTLIBTHREAD" |
| 25123 | | |
| 25124 | | cat >>confdefs.h <<\_ACEOF |
| 25125 | | #define USE_SOLARIS_THREADS 1 |
| 25126 | | _ACEOF |
| 25127 | | |
| 25128 | | if test $gl_have_weak = yes; then |
| 25129 | | |
| 25130 | | cat >>confdefs.h <<\_ACEOF |
| 25131 | | #define USE_SOLARIS_THREADS_WEAK 1 |
| 25132 | | _ACEOF |
| 25133 | | |
| 25134 | | LIBTHREAD= |
| 25135 | | LTLIBTHREAD= |
| 25136 | | fi |
| 25137 | | fi |
| 25138 | | fi |
| 25139 | | fi |
| 25140 | | if test "$gl_use_threads" = pth; then |
| 25141 | | gl_save_CPPFLAGS="$CPPFLAGS" |
| 25142 | | |
| 25143 | | |
| 25144 | | |
| 25145 | | |
| 25146 | | |
| 25147 | | { echo "$as_me:$LINENO: checking how to link with libpth" >&5 |
| 25148 | | echo $ECHO_N "checking how to link with libpth... $ECHO_C" >&6; } |
| 25149 | | if test "${ac_cv_libpth_libs+set}" = set; then |
| 25150 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 25151 | | else |
| 25152 | | |
| 25153 | | |
| 25154 | | |
| 25155 | | |
| 25156 | | use_additional=yes |
| 25157 | | |
| 25158 | | acl_save_prefix="$prefix" |
| 25159 | | prefix="$acl_final_prefix" |
| 25160 | | acl_save_exec_prefix="$exec_prefix" |
| 25161 | | exec_prefix="$acl_final_exec_prefix" |
| 25162 | | |
| 25163 | | eval additional_includedir=\"$includedir\" |
| 25164 | | eval additional_libdir=\"$libdir\" |
| 25165 | | |
| 25166 | | exec_prefix="$acl_save_exec_prefix" |
| 25167 | | prefix="$acl_save_prefix" |
| 25168 | | |
| 25169 | | |
| 25170 | | # Check whether --with-libpth-prefix was given. |
| 25171 | | if test "${with_libpth_prefix+set}" = set; then |
| 25172 | | withval=$with_libpth_prefix; |
| 25173 | | if test "X$withval" = "Xno"; then |
| 25174 | | use_additional=no |
| 25175 | | else |
| 25176 | | if test "X$withval" = "X"; then |
| 25177 | | |
| 25178 | | acl_save_prefix="$prefix" |
| 25179 | | prefix="$acl_final_prefix" |
| 25180 | | acl_save_exec_prefix="$exec_prefix" |
| 25181 | | exec_prefix="$acl_final_exec_prefix" |
| 25182 | | |
| 25183 | | eval additional_includedir=\"$includedir\" |
| 25184 | | eval additional_libdir=\"$libdir\" |
| 25185 | | |
| 25186 | | exec_prefix="$acl_save_exec_prefix" |
| 25187 | | prefix="$acl_save_prefix" |
| 25188 | | |
| 25189 | | else |
| 25190 | | additional_includedir="$withval/include" |
| 25191 | | additional_libdir="$withval/$acl_libdirstem" |
| 25192 | | fi |
| 25193 | | fi |
| 25194 | | |
| 25195 | | fi |
| 25196 | | |
| 25197 | | LIBPTH= |
| 25198 | | LTLIBPTH= |
| 25199 | | INCPTH= |
| 25200 | | rpathdirs= |
| 25201 | | ltrpathdirs= |
| 25202 | | names_already_handled= |
| 25203 | | names_next_round='pth ' |
| 25204 | | while test -n "$names_next_round"; do |
| 25205 | | names_this_round="$names_next_round" |
| 25206 | | names_next_round= |
| 25207 | | for name in $names_this_round; do |
| 25208 | | already_handled= |
| 25209 | | for n in $names_already_handled; do |
| 25210 | | if test "$n" = "$name"; then |
| 25211 | | already_handled=yes |
| 25212 | | break |
| 25213 | | fi |
| 25214 | | done |
| 25215 | | if test -z "$already_handled"; then |
| 25216 | | names_already_handled="$names_already_handled $name" |
| 25217 | | uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'` |
| 25218 | | eval value=\"\$HAVE_LIB$uppername\" |
| 25219 | | if test -n "$value"; then |
| 25220 | | if test "$value" = yes; then |
| 25221 | | eval value=\"\$LIB$uppername\" |
| 25222 | | test -z "$value" || LIBPTH="${LIBPTH}${LIBPTH:+ }$value" |
| 25223 | | eval value=\"\$LTLIB$uppername\" |
| 25224 | | test -z "$value" || LTLIBPTH="${LTLIBPTH}${LTLIBPTH:+ }$value" |
| 25225 | | else |
| 25226 | | : |
| 25227 | | fi |
| 25228 | | else |
| 25229 | | found_dir= |
| 25230 | | found_la= |
| 25231 | | found_so= |
| 25232 | | found_a= |
| 25233 | | if test $use_additional = yes; then |
| 25234 | | if test -n "$shlibext" && test -f "$additional_libdir/lib$name.$shlibext"; then |
| 25235 | | found_dir="$additional_libdir" |
| 25236 | | found_so="$additional_libdir/lib$name.$shlibext" |
| 25237 | | if test -f "$additional_libdir/lib$name.la"; then |
| 25238 | | found_la="$additional_libdir/lib$name.la" |
| 25239 | | fi |
| 25240 | | else |
| 25241 | | if test -f "$additional_libdir/lib$name.$libext"; then |
| 25242 | | found_dir="$additional_libdir" |
| 25243 | | found_a="$additional_libdir/lib$name.$libext" |
| 25244 | | if test -f "$additional_libdir/lib$name.la"; then |
| 25245 | | found_la="$additional_libdir/lib$name.la" |
| 25246 | | fi |
| 25247 | | fi |
| 25248 | | fi |
| 25249 | | fi |
| 25250 | | if test "X$found_dir" = "X"; then |
| 25251 | | for x in $LDFLAGS $LTLIBPTH; do |
| 25252 | | |
| 25253 | | acl_save_prefix="$prefix" |
| 25254 | | prefix="$acl_final_prefix" |
| 25255 | | acl_save_exec_prefix="$exec_prefix" |
| 25256 | | exec_prefix="$acl_final_exec_prefix" |
| 25257 | | eval x=\"$x\" |
| 25258 | | exec_prefix="$acl_save_exec_prefix" |
| 25259 | | prefix="$acl_save_prefix" |
| 25260 | | |
| 25261 | | case "$x" in |
| 25262 | | -L*) |
| 25263 | | dir=`echo "X$x" | sed -e 's/^X-L//'` |
| 25264 | | if test -n "$shlibext" && test -f "$dir/lib$name.$shlibext"; then |
| 25265 | | found_dir="$dir" |
| 25266 | | found_so="$dir/lib$name.$shlibext" |
| 25267 | | if test -f "$dir/lib$name.la"; then |
| 25268 | | found_la="$dir/lib$name.la" |
| 25269 | | fi |
| 25270 | | else |
| 25271 | | if test -f "$dir/lib$name.$libext"; then |
| 25272 | | found_dir="$dir" |
| 25273 | | found_a="$dir/lib$name.$libext" |
| 25274 | | if test -f "$dir/lib$name.la"; then |
| 25275 | | found_la="$dir/lib$name.la" |
| 25276 | | fi |
| 25277 | | fi |
| 25278 | | fi |
| 25279 | | ;; |
| 25280 | | esac |
| 25281 | | if test "X$found_dir" != "X"; then |
| 25282 | | break |
| 25283 | | fi |
| 25284 | | done |
| 25285 | | fi |
| 25286 | | if test "X$found_dir" != "X"; then |
| 25287 | | LTLIBPTH="${LTLIBPTH}${LTLIBPTH:+ }-L$found_dir -l$name" |
| 25288 | | if test "X$found_so" != "X"; then |
| 25289 | | if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/$acl_libdirstem"; then |
| 25290 | | LIBPTH="${LIBPTH}${LIBPTH:+ }$found_so" |
| 25291 | | else |
| 25292 | | haveit= |
| 25293 | | for x in $ltrpathdirs; do |
| 25294 | | if test "X$x" = "X$found_dir"; then |
| 25295 | | haveit=yes |
| 25296 | | break |
| 25297 | | fi |
| 25298 | | done |
| 25299 | | if test -z "$haveit"; then |
| 25300 | | ltrpathdirs="$ltrpathdirs $found_dir" |
| 25301 | | fi |
| 25302 | | if test "$hardcode_direct" = yes; then |
| 25303 | | LIBPTH="${LIBPTH}${LIBPTH:+ }$found_so" |
| 25304 | | else |
| 25305 | | if test -n "$hardcode_libdir_flag_spec" && test "$hardcode_minus_L" = no; then |
| 25306 | | LIBPTH="${LIBPTH}${LIBPTH:+ }$found_so" |
| 25307 | | haveit= |
| 25308 | | for x in $rpathdirs; do |
| 25309 | | if test "X$x" = "X$found_dir"; then |
| 25310 | | haveit=yes |
| 25311 | | break |
| 25312 | | fi |
| 25313 | | done |
| 25314 | | if test -z "$haveit"; then |
| 25315 | | rpathdirs="$rpathdirs $found_dir" |
| 25316 | | fi |
| 25317 | | else |
| 25318 | | haveit= |
| 25319 | | for x in $LDFLAGS $LIBPTH; do |
| 25320 | | |
| 25321 | | acl_save_prefix="$prefix" |
| 25322 | | prefix="$acl_final_prefix" |
| 25323 | | acl_save_exec_prefix="$exec_prefix" |
| 25324 | | exec_prefix="$acl_final_exec_prefix" |
| 25325 | | eval x=\"$x\" |
| 25326 | | exec_prefix="$acl_save_exec_prefix" |
| 25327 | | prefix="$acl_save_prefix" |
| 25328 | | |
| 25329 | | if test "X$x" = "X-L$found_dir"; then |
| 25330 | | haveit=yes |
| 25331 | | break |
| 25332 | | fi |
| 25333 | | done |
| 25334 | | if test -z "$haveit"; then |
| 25335 | | LIBPTH="${LIBPTH}${LIBPTH:+ }-L$found_dir" |
| 25336 | | fi |
| 25337 | | if test "$hardcode_minus_L" != no; then |
| 25338 | | LIBPTH="${LIBPTH}${LIBPTH:+ }$found_so" |
| 25339 | | else |
| 25340 | | LIBPTH="${LIBPTH}${LIBPTH:+ }-l$name" |
| 25341 | | fi |
| 25342 | | fi |
| 25343 | | fi |
| 25344 | | fi |
| 25345 | | else |
| 25346 | | if test "X$found_a" != "X"; then |
| 25347 | | LIBPTH="${LIBPTH}${LIBPTH:+ }$found_a" |
| 25348 | | else |
| 25349 | | LIBPTH="${LIBPTH}${LIBPTH:+ }-L$found_dir -l$name" |
| 25350 | | fi |
| 25351 | | fi |
| 25352 | | additional_includedir= |
| 25353 | | case "$found_dir" in |
| 25354 | | */$acl_libdirstem | */$acl_libdirstem/) |
| 25355 | | basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'` |
| 25356 | | additional_includedir="$basedir/include" |
| 25357 | | ;; |
| 25358 | | esac |
| 25359 | | if test "X$additional_includedir" != "X"; then |
| 25360 | | if test "X$additional_includedir" != "X/usr/include"; then |
| 25361 | | haveit= |
| 25362 | | if test "X$additional_includedir" = "X/usr/local/include"; then |
| 25363 | | if test -n "$GCC"; then |
| 25364 | | case $host_os in |
| 25365 | | linux* | gnu* | k*bsd*-gnu) haveit=yes;; |
| 25366 | | esac |
| 25367 | | fi |
| 25368 | | fi |
| 25369 | | if test -z "$haveit"; then |
| 25370 | | for x in $CPPFLAGS $INCPTH; do |
| 25371 | | |
| 25372 | | acl_save_prefix="$prefix" |
| 25373 | | prefix="$acl_final_prefix" |
| 25374 | | acl_save_exec_prefix="$exec_prefix" |
| 25375 | | exec_prefix="$acl_final_exec_prefix" |
| 25376 | | eval x=\"$x\" |
| 25377 | | exec_prefix="$acl_save_exec_prefix" |
| 25378 | | prefix="$acl_save_prefix" |
| 25379 | | |
| 25380 | | if test "X$x" = "X-I$additional_includedir"; then |
| 25381 | | haveit=yes |
| 25382 | | break |
| 25383 | | fi |
| 25384 | | done |
| 25385 | | if test -z "$haveit"; then |
| 25386 | | if test -d "$additional_includedir"; then |
| 25387 | | INCPTH="${INCPTH}${INCPTH:+ }-I$additional_includedir" |
| 25388 | | fi |
| 25389 | | fi |
| 25390 | | fi |
| 25391 | | fi |
| 25392 | | fi |
| 25393 | | if test -n "$found_la"; then |
| 25394 | | save_libdir="$libdir" |
| 25395 | | case "$found_la" in |
| 25396 | | */* | *\\*) . "$found_la" ;; |
| 25397 | | *) . "./$found_la" ;; |
| 25398 | | esac |
| 25399 | | libdir="$save_libdir" |
| 25400 | | for dep in $dependency_libs; do |
| 25401 | | case "$dep" in |
| 25402 | | -L*) |
| 25403 | | additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'` |
| 25404 | | if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then |
| 25405 | | haveit= |
| 25406 | | if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then |
| 25407 | | if test -n "$GCC"; then |
| 25408 | | case $host_os in |
| 25409 | | linux* | gnu* | k*bsd*-gnu) haveit=yes;; |
| 25410 | | esac |
| 25411 | | fi |
| 25412 | | fi |
| 25413 | | if test -z "$haveit"; then |
| 25414 | | haveit= |
| 25415 | | for x in $LDFLAGS $LIBPTH; do |
| 25416 | | |
| 25417 | | acl_save_prefix="$prefix" |
| 25418 | | prefix="$acl_final_prefix" |
| 25419 | | acl_save_exec_prefix="$exec_prefix" |
| 25420 | | exec_prefix="$acl_final_exec_prefix" |
| 25421 | | eval x=\"$x\" |
| 25422 | | exec_prefix="$acl_save_exec_prefix" |
| 25423 | | prefix="$acl_save_prefix" |
| 25424 | | |
| 25425 | | if test "X$x" = "X-L$additional_libdir"; then |
| 25426 | | haveit=yes |
| 25427 | | break |
| 25428 | | fi |
| 25429 | | done |
| 25430 | | if test -z "$haveit"; then |
| 25431 | | if test -d "$additional_libdir"; then |
| 25432 | | LIBPTH="${LIBPTH}${LIBPTH:+ }-L$additional_libdir" |
| 25433 | | fi |
| 25434 | | fi |
| 25435 | | haveit= |
| 25436 | | for x in $LDFLAGS $LTLIBPTH; do |
| 25437 | | |
| 25438 | | acl_save_prefix="$prefix" |
| 25439 | | prefix="$acl_final_prefix" |
| 25440 | | acl_save_exec_prefix="$exec_prefix" |
| 25441 | | exec_prefix="$acl_final_exec_prefix" |
| 25442 | | eval x=\"$x\" |
| 25443 | | exec_prefix="$acl_save_exec_prefix" |
| 25444 | | prefix="$acl_save_prefix" |
| 25445 | | |
| 25446 | | if test "X$x" = "X-L$additional_libdir"; then |
| 25447 | | haveit=yes |
| 25448 | | break |
| 25449 | | fi |
| 25450 | | done |
| 25451 | | if test -z "$haveit"; then |
| 25452 | | if test -d "$additional_libdir"; then |
| 25453 | | LTLIBPTH="${LTLIBPTH}${LTLIBPTH:+ }-L$additional_libdir" |
| 25454 | | fi |
| 25455 | | fi |
| 25456 | | fi |
| 25457 | | fi |
| 25458 | | ;; |
| 25459 | | -R*) |
| 25460 | | dir=`echo "X$dep" | sed -e 's/^X-R//'` |
| 25461 | | if test "$enable_rpath" != no; then |
| 25462 | | haveit= |
| 25463 | | for x in $rpathdirs; do |
| 25464 | | if test "X$x" = "X$dir"; then |
| 25465 | | haveit=yes |
| 25466 | | break |
| 25467 | | fi |
| 25468 | | done |
| 25469 | | if test -z "$haveit"; then |
| 25470 | | rpathdirs="$rpathdirs $dir" |
| 25471 | | fi |
| 25472 | | haveit= |
| 25473 | | for x in $ltrpathdirs; do |
| 25474 | | if test "X$x" = "X$dir"; then |
| 25475 | | haveit=yes |
| 25476 | | break |
| 25477 | | fi |
| 25478 | | done |
| 25479 | | if test -z "$haveit"; then |
| 25480 | | ltrpathdirs="$ltrpathdirs $dir" |
| 25481 | | fi |
| 25482 | | fi |
| 25483 | | ;; |
| 25484 | | -l*) |
| 25485 | | names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'` |
| 25486 | | ;; |
| 25487 | | *.la) |
| 25488 | | names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'` |
| 25489 | | ;; |
| 25490 | | *) |
| 25491 | | LIBPTH="${LIBPTH}${LIBPTH:+ }$dep" |
| 25492 | | LTLIBPTH="${LTLIBPTH}${LTLIBPTH:+ }$dep" |
| 25493 | | ;; |
| 25494 | | esac |
| 25495 | | done |
| 25496 | | fi |
| 25497 | | else |
| 25498 | | LIBPTH="${LIBPTH}${LIBPTH:+ }-l$name" |
| 25499 | | LTLIBPTH="${LTLIBPTH}${LTLIBPTH:+ }-l$name" |
| 25500 | | fi |
| 25501 | | fi |
| 25502 | | fi |
| 25503 | | done |
| 25504 | | done |
| 25505 | | if test "X$rpathdirs" != "X"; then |
| 25506 | | if test -n "$hardcode_libdir_separator"; then |
| 25507 | | alldirs= |
| 25508 | | for found_dir in $rpathdirs; do |
| 25509 | | alldirs="${alldirs}${alldirs:+$hardcode_libdir_separator}$found_dir" |
| 25510 | | done |
| 25511 | | acl_save_libdir="$libdir" |
| 25512 | | libdir="$alldirs" |
| 25513 | | eval flag=\"$hardcode_libdir_flag_spec\" |
| 25514 | | libdir="$acl_save_libdir" |
| 25515 | | LIBPTH="${LIBPTH}${LIBPTH:+ }$flag" |
| 25516 | | else |
| 25517 | | for found_dir in $rpathdirs; do |
| 25518 | | acl_save_libdir="$libdir" |
| 25519 | | libdir="$found_dir" |
| 25520 | | eval flag=\"$hardcode_libdir_flag_spec\" |
| 25521 | | libdir="$acl_save_libdir" |
| 25522 | | LIBPTH="${LIBPTH}${LIBPTH:+ }$flag" |
| 25523 | | done |
| 25524 | | fi |
| 25525 | | fi |
| 25526 | | if test "X$ltrpathdirs" != "X"; then |
| 25527 | | for found_dir in $ltrpathdirs; do |
| 25528 | | LTLIBPTH="${LTLIBPTH}${LTLIBPTH:+ }-R$found_dir" |
| 25529 | | done |
| 25530 | | fi |
| 25531 | | |
| 25532 | | ac_cv_libpth_libs="$LIBPTH" |
| 25533 | | ac_cv_libpth_ltlibs="$LTLIBPTH" |
| 25534 | | ac_cv_libpth_cppflags="$INCPTH" |
| 25535 | | |
| 25536 | | fi |
| 25537 | | { echo "$as_me:$LINENO: result: $ac_cv_libpth_libs" >&5 |
| 25538 | | echo "${ECHO_T}$ac_cv_libpth_libs" >&6; } |
| 25539 | | LIBPTH="$ac_cv_libpth_libs" |
| 25540 | | LTLIBPTH="$ac_cv_libpth_ltlibs" |
| 25541 | | INCPTH="$ac_cv_libpth_cppflags" |
| 25542 | | |
| 25543 | | for element in $INCPTH; do |
| 25544 | | haveit= |
| 25545 | | for x in $CPPFLAGS; do |
| 25546 | | |
| 25547 | | acl_save_prefix="$prefix" |
| 25548 | | prefix="$acl_final_prefix" |
| 25549 | | acl_save_exec_prefix="$exec_prefix" |
| 25550 | | exec_prefix="$acl_final_exec_prefix" |
| 25551 | | eval x=\"$x\" |
| 25552 | | exec_prefix="$acl_save_exec_prefix" |
| 25553 | | prefix="$acl_save_prefix" |
| 25554 | | |
| 25555 | | if test "X$x" = "X$element"; then |
| 25556 | | haveit=yes |
| 25557 | | break |
| 25558 | | fi |
| 25559 | | done |
| 25560 | | if test -z "$haveit"; then |
| 25561 | | CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }$element" |
| 25562 | | fi |
| 25563 | | done |
| 25564 | | |
| 25565 | | |
| 25566 | | |
| 25567 | | HAVE_LIBPTH=yes |
| 25568 | | |
| 25569 | | |
| 25570 | | |
| 25571 | | gl_have_pth= |
| 25572 | | gl_save_LIBS="$LIBS" |
| 25573 | | LIBS="$LIBS -lpth" |
| 25574 | | cat >conftest.$ac_ext <<_ACEOF |
| 25575 | | /* confdefs.h. */ |
| 25576 | | _ACEOF |
| 25577 | | cat confdefs.h >>conftest.$ac_ext |
| 25578 | | cat >>conftest.$ac_ext <<_ACEOF |
| 25579 | | /* end confdefs.h. */ |
| 25580 | | #include <pth.h> |
| 25581 | | int |
| 25582 | | main () |
| 25583 | | { |
| 25584 | | pth_self(); |
| 25585 | | ; |
| 25586 | | return 0; |
| 25587 | | } |
| 25588 | | _ACEOF |
| 25589 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 25590 | | if { (ac_try="$ac_link" |
| 25591 | | case "(($ac_try" in |
| 25592 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 25593 | | *) ac_try_echo=$ac_try;; |
| 25594 | | esac |
| 25595 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 25596 | | (eval "$ac_link") 2>conftest.er1 |
| 25597 | | ac_status=$? |
| 25598 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 25599 | | rm -f conftest.er1 |
| 25600 | | cat conftest.err >&5 |
| 25601 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 25602 | | (exit $ac_status); } && { |
| 25603 | | test -z "$ac_c_werror_flag" || |
| 25604 | | test ! -s conftest.err |
| 25605 | | } && test -s conftest$ac_exeext && |
| 25606 | | $as_test_x conftest$ac_exeext; then |
| 25607 | | gl_have_pth=yes |
| 25608 | | else |
| 25609 | | echo "$as_me: failed program was:" >&5 |
| 25610 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 25611 | | |
| 25612 | | |
| 25613 | | fi |
| 25614 | | |
| 25615 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 25616 | | conftest$ac_exeext conftest.$ac_ext |
| 25617 | | LIBS="$gl_save_LIBS" |
| 25618 | | if test -n "$gl_have_pth"; then |
| 25619 | | gl_threads_api=pth |
| 25620 | | LIBTHREAD="$LIBPTH" |
| 25621 | | LTLIBTHREAD="$LTLIBPTH" |
| 25622 | | LIBMULTITHREAD="$LIBTHREAD" |
| 25623 | | LTLIBMULTITHREAD="$LTLIBTHREAD" |
| 25624 | | |
| 25625 | | cat >>confdefs.h <<\_ACEOF |
| 25626 | | #define USE_PTH_THREADS 1 |
| 25627 | | _ACEOF |
| 25628 | | |
| 25629 | | if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then |
| 25630 | | if test $gl_have_weak = yes; then |
| 25631 | | |
| 25632 | | cat >>confdefs.h <<\_ACEOF |
| 25633 | | #define USE_PTH_THREADS_WEAK 1 |
| 25634 | | _ACEOF |
| 25635 | | |
| 25636 | | LIBTHREAD= |
| 25637 | | LTLIBTHREAD= |
| 25638 | | fi |
| 25639 | | fi |
| 25640 | | else |
| 25641 | | CPPFLAGS="$gl_save_CPPFLAGS" |
| 25642 | | fi |
| 25643 | | fi |
| 25644 | | if test -z "$gl_have_pthread"; then |
| 25645 | | if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then |
| 25646 | | if { case "$host_os" in |
| 25647 | | mingw*) true;; |
| 25648 | | *) false;; |
| 25649 | | esac |
| 25650 | | }; then |
| 25651 | | gl_threads_api=win32 |
| 25652 | | |
| 25653 | | cat >>confdefs.h <<\_ACEOF |
| 25654 | | #define USE_WIN32_THREADS 1 |
| 25655 | | _ACEOF |
| 25656 | | |
| 25657 | | fi |
| 25658 | | fi |
| 25659 | | fi |
| 25660 | | fi |
| 25661 | | { echo "$as_me:$LINENO: checking for multithread API to use" >&5 |
| 25662 | | echo $ECHO_N "checking for multithread API to use... $ECHO_C" >&6; } |
| 25663 | | { echo "$as_me:$LINENO: result: $gl_threads_api" >&5 |
| 25664 | | echo "${ECHO_T}$gl_threads_api" >&6; } |
| 25665 | | |
| 25666 | | |
| 25667 | | |
| 25668 | | |
| 25669 | | |
| 25670 | | |
| 25671 | | |
| 25672 | | |
| 25673 | | |
| 25674 | | |
| 26657 | | if test "$am_cv_func_iconv" = yes; then |
| 26658 | | { echo "$as_me:$LINENO: checking for iconv declaration" >&5 |
| 26659 | | echo $ECHO_N "checking for iconv declaration... $ECHO_C" >&6; } |
| 26660 | | if test "${am_cv_proto_iconv+set}" = set; then |
| 26661 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 26662 | | else |
| 26663 | | |
| 26664 | | cat >conftest.$ac_ext <<_ACEOF |
| 26665 | | /* confdefs.h. */ |
| 26666 | | _ACEOF |
| 26667 | | cat confdefs.h >>conftest.$ac_ext |
| 26668 | | cat >>conftest.$ac_ext <<_ACEOF |
| 26669 | | /* end confdefs.h. */ |
| 26670 | | |
| 26671 | | #include <stdlib.h> |
| 26672 | | #include <iconv.h> |
| 26673 | | extern |
| 26674 | | #ifdef __cplusplus |
| 26675 | | "C" |
| 26676 | | #endif |
| 26677 | | #if defined(__STDC__) || defined(__cplusplus) |
| 26678 | | size_t iconv (iconv_t cd, char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft); |
| 26679 | | #else |
| 26680 | | size_t iconv(); |
| 26681 | | #endif |
| 26682 | | |
| 26683 | | int |
| 26684 | | main () |
| 26685 | | { |
| 26686 | | |
| 26687 | | ; |
| 26688 | | return 0; |
| 26689 | | } |
| 26690 | | _ACEOF |
| 26691 | | rm -f conftest.$ac_objext |
| 26692 | | if { (ac_try="$ac_compile" |
| 26693 | | case "(($ac_try" in |
| 26694 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 26695 | | *) ac_try_echo=$ac_try;; |
| 26696 | | esac |
| 26697 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 26698 | | (eval "$ac_compile") 2>conftest.er1 |
| 26699 | | ac_status=$? |
| 26700 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 26701 | | rm -f conftest.er1 |
| 26702 | | cat conftest.err >&5 |
| 26703 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 26704 | | (exit $ac_status); } && { |
| 26705 | | test -z "$ac_c_werror_flag" || |
| 26706 | | test ! -s conftest.err |
| 26707 | | } && test -s conftest.$ac_objext; then |
| 26708 | | am_cv_proto_iconv_arg1="" |
| 26709 | | else |
| 26710 | | echo "$as_me: failed program was:" >&5 |
| 26711 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 26712 | | |
| 26713 | | am_cv_proto_iconv_arg1="const" |
| 26714 | | fi |
| 26715 | | |
| 26716 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 26717 | | am_cv_proto_iconv="extern size_t iconv (iconv_t cd, $am_cv_proto_iconv_arg1 char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);" |
| 26718 | | fi |
| 26719 | | |
| 26720 | | am_cv_proto_iconv=`echo "$am_cv_proto_iconv" | tr -s ' ' | sed -e 's/( /(/'` |
| 26721 | | { echo "$as_me:$LINENO: result: ${ac_t:- |
| 26722 | | }$am_cv_proto_iconv" >&5 |
| 26723 | | echo "${ECHO_T}${ac_t:- |
| 26724 | | }$am_cv_proto_iconv" >&6; } |
| 26725 | | |
| 26726 | | cat >>confdefs.h <<_ACEOF |
| 26727 | | #define ICONV_CONST $am_cv_proto_iconv_arg1 |
| 26728 | | _ACEOF |
| 26729 | | |
| 26730 | | fi |
| 26731 | | |
| 26732 | | |
| 26733 | | { echo "$as_me:$LINENO: checking for NL_LOCALE_NAME macro" >&5 |
| 26734 | | echo $ECHO_N "checking for NL_LOCALE_NAME macro... $ECHO_C" >&6; } |
| 26735 | | if test "${gt_cv_nl_locale_name+set}" = set; then |
| 26736 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 26737 | | else |
| 26738 | | cat >conftest.$ac_ext <<_ACEOF |
| 26739 | | /* confdefs.h. */ |
| 26740 | | _ACEOF |
| 26741 | | cat confdefs.h >>conftest.$ac_ext |
| 26742 | | cat >>conftest.$ac_ext <<_ACEOF |
| 26743 | | /* end confdefs.h. */ |
| 26744 | | #include <langinfo.h> |
| 26745 | | #include <locale.h> |
| 26746 | | int |
| 26747 | | main () |
| 26748 | | { |
| 26749 | | char* cs = nl_langinfo(_NL_LOCALE_NAME(LC_MESSAGES)); |
| 26750 | | ; |
| 26751 | | return 0; |
| 26752 | | } |
| 26753 | | _ACEOF |
| 26754 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 26755 | | if { (ac_try="$ac_link" |
| 26756 | | case "(($ac_try" in |
| 26757 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 26758 | | *) ac_try_echo=$ac_try;; |
| 26759 | | esac |
| 26760 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 26761 | | (eval "$ac_link") 2>conftest.er1 |
| 26762 | | ac_status=$? |
| 26763 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 26764 | | rm -f conftest.er1 |
| 26765 | | cat conftest.err >&5 |
| 26766 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 26767 | | (exit $ac_status); } && { |
| 26768 | | test -z "$ac_c_werror_flag" || |
| 26769 | | test ! -s conftest.err |
| 26770 | | } && test -s conftest$ac_exeext && |
| 26771 | | $as_test_x conftest$ac_exeext; then |
| 26772 | | gt_cv_nl_locale_name=yes |
| 26773 | | else |
| 26774 | | echo "$as_me: failed program was:" >&5 |
| 26775 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 26776 | | |
| 26777 | | gt_cv_nl_locale_name=no |
| 26778 | | fi |
| 26779 | | |
| 26780 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 26781 | | conftest$ac_exeext conftest.$ac_ext |
| 26782 | | |
| 26783 | | fi |
| 26784 | | { echo "$as_me:$LINENO: result: $gt_cv_nl_locale_name" >&5 |
| 26785 | | echo "${ECHO_T}$gt_cv_nl_locale_name" >&6; } |
| 26786 | | if test $gt_cv_nl_locale_name = yes; then |
| 26787 | | |
| 26788 | | cat >>confdefs.h <<\_ACEOF |
| 26789 | | #define HAVE_NL_LOCALE_NAME 1 |
| 26790 | | _ACEOF |
| 26791 | | |
| 26792 | | fi |
| 26793 | | |
| 26794 | | for ac_prog in bison |
| 26795 | | do |
| 26796 | | # Extract the first word of "$ac_prog", so it can be a program name with args. |
| 26797 | | set dummy $ac_prog; ac_word=$2 |
| 26798 | | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| 26799 | | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| 26800 | | if test "${ac_cv_prog_INTLBISON+set}" = set; then |
| 26801 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 26802 | | else |
| 26803 | | if test -n "$INTLBISON"; then |
| 26804 | | ac_cv_prog_INTLBISON="$INTLBISON" # Let the user override the test. |
| 26805 | | else |
| 26806 | | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| 26807 | | for as_dir in $PATH |
| 26808 | | do |
| 26809 | | IFS=$as_save_IFS |
| 26810 | | test -z "$as_dir" && as_dir=. |
| 26811 | | for ac_exec_ext in '' $ac_executable_extensions; do |
| 26812 | | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| 26813 | | ac_cv_prog_INTLBISON="$ac_prog" |
| 26814 | | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| 26815 | | break 2 |
| 26816 | | fi |
| 26817 | | done |
| 26818 | | done |
| 26819 | | IFS=$as_save_IFS |
| 26820 | | |
| 26821 | | fi |
| 26822 | | fi |
| 26823 | | INTLBISON=$ac_cv_prog_INTLBISON |
| 26824 | | if test -n "$INTLBISON"; then |
| 26825 | | { echo "$as_me:$LINENO: result: $INTLBISON" >&5 |
| 26826 | | echo "${ECHO_T}$INTLBISON" >&6; } |
| 26827 | | else |
| 26828 | | { echo "$as_me:$LINENO: result: no" >&5 |
| 26829 | | echo "${ECHO_T}no" >&6; } |
| 26830 | | fi |
| 26831 | | |
| 26832 | | |
| 26833 | | test -n "$INTLBISON" && break |
| 26834 | | done |
| 26835 | | |
| 26836 | | if test -z "$INTLBISON"; then |
| 26837 | | ac_verc_fail=yes |
| 26838 | | else |
| 26839 | | { echo "$as_me:$LINENO: checking version of bison" >&5 |
| 26840 | | echo $ECHO_N "checking version of bison... $ECHO_C" >&6; } |
| 26841 | | ac_prog_version=`$INTLBISON --version 2>&1 | sed -n 's/^.*GNU Bison.* \([0-9]*\.[0-9.]*\).*$/\1/p'` |
| 26842 | | case $ac_prog_version in |
| 26843 | | '') ac_prog_version="v. ?.??, bad"; ac_verc_fail=yes;; |
| 26844 | | 1.2[6-9]* | 1.[3-9][0-9]* | [2-9].*) |
| 26845 | | ac_prog_version="$ac_prog_version, ok"; ac_verc_fail=no;; |
| 26846 | | *) ac_prog_version="$ac_prog_version, bad"; ac_verc_fail=yes;; |
| 26847 | | esac |
| 26848 | | { echo "$as_me:$LINENO: result: $ac_prog_version" >&5 |
| 26849 | | echo "${ECHO_T}$ac_prog_version" >&6; } |
| 26850 | | fi |
| 26851 | | if test $ac_verc_fail = yes; then |
| 26852 | | INTLBISON=: |
| 26853 | | fi |
| 26854 | | |
| 26855 | | |
| 26856 | | { echo "$as_me:$LINENO: checking for signed" >&5 |
| 26857 | | echo $ECHO_N "checking for signed... $ECHO_C" >&6; } |
| 26858 | | if test "${bh_cv_c_signed+set}" = set; then |
| 26859 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 26860 | | else |
| 26861 | | cat >conftest.$ac_ext <<_ACEOF |
| 26862 | | /* confdefs.h. */ |
| 26863 | | _ACEOF |
| 26864 | | cat confdefs.h >>conftest.$ac_ext |
| 26865 | | cat >>conftest.$ac_ext <<_ACEOF |
| 26866 | | /* end confdefs.h. */ |
| 26867 | | |
| 26868 | | int |
| 26869 | | main () |
| 26870 | | { |
| 26871 | | signed char x; |
| 26872 | | ; |
| 26873 | | return 0; |
| 26874 | | } |
| 26875 | | _ACEOF |
| 26876 | | rm -f conftest.$ac_objext |
| 26877 | | if { (ac_try="$ac_compile" |
| 26878 | | case "(($ac_try" in |
| 26879 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 26880 | | *) ac_try_echo=$ac_try;; |
| 26881 | | esac |
| 26882 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 26883 | | (eval "$ac_compile") 2>conftest.er1 |
| 26884 | | ac_status=$? |
| 26885 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 26886 | | rm -f conftest.er1 |
| 26887 | | cat conftest.err >&5 |
| 26888 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 26889 | | (exit $ac_status); } && { |
| 26890 | | test -z "$ac_c_werror_flag" || |
| 26891 | | test ! -s conftest.err |
| 26892 | | } && test -s conftest.$ac_objext; then |
| 26893 | | bh_cv_c_signed=yes |
| 26894 | | else |
| 26895 | | echo "$as_me: failed program was:" >&5 |
| 26896 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 26897 | | |
| 26898 | | bh_cv_c_signed=no |
| 26899 | | fi |
| 26900 | | |
| 26901 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 26902 | | fi |
| 26903 | | { echo "$as_me:$LINENO: result: $bh_cv_c_signed" >&5 |
| 26904 | | echo "${ECHO_T}$bh_cv_c_signed" >&6; } |
| 26905 | | if test $bh_cv_c_signed = no; then |
| 26906 | | |
| 26907 | | cat >>confdefs.h <<\_ACEOF |
| 26908 | | #define signed |
| 26909 | | _ACEOF |
| 26910 | | |
| 26911 | | fi |
| 26912 | | |
| 26913 | | |
| 26914 | | { echo "$as_me:$LINENO: checking for long long" >&5 |
| 26915 | | echo $ECHO_N "checking for long long... $ECHO_C" >&6; } |
| 26916 | | if test "${ac_cv_type_long_long+set}" = set; then |
| 26917 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 26918 | | else |
| 26919 | | cat >conftest.$ac_ext <<_ACEOF |
| 26920 | | /* confdefs.h. */ |
| 26921 | | _ACEOF |
| 26922 | | cat confdefs.h >>conftest.$ac_ext |
| 26923 | | cat >>conftest.$ac_ext <<_ACEOF |
| 26924 | | /* end confdefs.h. */ |
| 26925 | | long long ll = 1LL; int i = 63; |
| 26926 | | int |
| 26927 | | main () |
| 26928 | | { |
| 26929 | | long long llmax = (long long) -1; |
| 26930 | | return ll << i | ll >> i | llmax / ll | llmax % ll; |
| 26931 | | ; |
| 26932 | | return 0; |
| 26933 | | } |
| 26934 | | _ACEOF |
| 26935 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 26936 | | if { (ac_try="$ac_link" |
| 26937 | | case "(($ac_try" in |
| 26938 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 26939 | | *) ac_try_echo=$ac_try;; |
| 26940 | | esac |
| 26941 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 26942 | | (eval "$ac_link") 2>conftest.er1 |
| 26943 | | ac_status=$? |
| 26944 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 26945 | | rm -f conftest.er1 |
| 26946 | | cat conftest.err >&5 |
| 26947 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 26948 | | (exit $ac_status); } && { |
| 26949 | | test -z "$ac_c_werror_flag" || |
| 26950 | | test ! -s conftest.err |
| 26951 | | } && test -s conftest$ac_exeext && |
| 26952 | | $as_test_x conftest$ac_exeext; then |
| 26953 | | ac_cv_type_long_long=yes |
| 26954 | | else |
| 26955 | | echo "$as_me: failed program was:" >&5 |
| 26956 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 26957 | | |
| 26958 | | ac_cv_type_long_long=no |
| 26959 | | fi |
| 26960 | | |
| 26961 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 26962 | | conftest$ac_exeext conftest.$ac_ext |
| 26963 | | fi |
| 26964 | | { echo "$as_me:$LINENO: result: $ac_cv_type_long_long" >&5 |
| 26965 | | echo "${ECHO_T}$ac_cv_type_long_long" >&6; } |
| 26966 | | if test $ac_cv_type_long_long = yes; then |
| 26967 | | |
| 26968 | | cat >>confdefs.h <<\_ACEOF |
| 26969 | | #define HAVE_LONG_LONG 1 |
| 26970 | | _ACEOF |
| 26971 | | |
| 26972 | | fi |
| 26973 | | |
| 26974 | | |
| 26975 | | { echo "$as_me:$LINENO: checking for long double" >&5 |
| 26976 | | echo $ECHO_N "checking for long double... $ECHO_C" >&6; } |
| 26977 | | if test "${gt_cv_c_long_double+set}" = set; then |
| 26978 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 26979 | | else |
| 26980 | | if test "$GCC" = yes; then |
| 26981 | | gt_cv_c_long_double=yes |
| 26982 | | else |
| 26983 | | cat >conftest.$ac_ext <<_ACEOF |
| 26984 | | /* confdefs.h. */ |
| 26985 | | _ACEOF |
| 26986 | | cat confdefs.h >>conftest.$ac_ext |
| 26987 | | cat >>conftest.$ac_ext <<_ACEOF |
| 26988 | | /* end confdefs.h. */ |
| 26989 | | |
| 26990 | | /* The Stardent Vistra knows sizeof(long double), but does not support it. */ |
| 26991 | | long double foo = 0.0; |
| 26992 | | /* On Ultrix 4.3 cc, long double is 4 and double is 8. */ |
| 26993 | | int array [2*(sizeof(long double) >= sizeof(double)) - 1]; |
| 26994 | | |
| 26995 | | int |
| 26996 | | main () |
| 26997 | | { |
| 26998 | | |
| 26999 | | ; |
| 27000 | | return 0; |
| 27001 | | } |
| 27002 | | _ACEOF |
| 27003 | | rm -f conftest.$ac_objext |
| 27004 | | if { (ac_try="$ac_compile" |
| 27005 | | case "(($ac_try" in |
| 27006 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27007 | | *) ac_try_echo=$ac_try;; |
| 27008 | | esac |
| 27009 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27010 | | (eval "$ac_compile") 2>conftest.er1 |
| 27011 | | ac_status=$? |
| 27012 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 27013 | | rm -f conftest.er1 |
| 27014 | | cat conftest.err >&5 |
| 27015 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 27016 | | (exit $ac_status); } && { |
| 27017 | | test -z "$ac_c_werror_flag" || |
| 27018 | | test ! -s conftest.err |
| 27019 | | } && test -s conftest.$ac_objext; then |
| 27020 | | gt_cv_c_long_double=yes |
| 27021 | | else |
| 27022 | | echo "$as_me: failed program was:" >&5 |
| 27023 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 27024 | | |
| 27025 | | gt_cv_c_long_double=no |
| 27026 | | fi |
| 27027 | | |
| 27028 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 27029 | | fi |
| 27030 | | fi |
| 27031 | | { echo "$as_me:$LINENO: result: $gt_cv_c_long_double" >&5 |
| 27032 | | echo "${ECHO_T}$gt_cv_c_long_double" >&6; } |
| 27033 | | if test $gt_cv_c_long_double = yes; then |
| 27034 | | |
| 27035 | | cat >>confdefs.h <<\_ACEOF |
| 27036 | | #define HAVE_LONG_DOUBLE 1 |
| 27037 | | _ACEOF |
| 27038 | | |
| 27039 | | fi |
| 27040 | | |
| 27041 | | |
| 27042 | | { echo "$as_me:$LINENO: checking for wchar_t" >&5 |
| 27043 | | echo $ECHO_N "checking for wchar_t... $ECHO_C" >&6; } |
| 27044 | | if test "${gt_cv_c_wchar_t+set}" = set; then |
| 27045 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 27046 | | else |
| 27047 | | cat >conftest.$ac_ext <<_ACEOF |
| 27048 | | /* confdefs.h. */ |
| 27049 | | _ACEOF |
| 27050 | | cat confdefs.h >>conftest.$ac_ext |
| 27051 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27052 | | /* end confdefs.h. */ |
| 27053 | | #include <stddef.h> |
| 27054 | | wchar_t foo = (wchar_t)'\0'; |
| 27055 | | int |
| 27056 | | main () |
| 27057 | | { |
| 27058 | | |
| 27059 | | ; |
| 27060 | | return 0; |
| 27061 | | } |
| 27062 | | _ACEOF |
| 27063 | | rm -f conftest.$ac_objext |
| 27064 | | if { (ac_try="$ac_compile" |
| 27065 | | case "(($ac_try" in |
| 27066 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27067 | | *) ac_try_echo=$ac_try;; |
| 27068 | | esac |
| 27069 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27070 | | (eval "$ac_compile") 2>conftest.er1 |
| 27071 | | ac_status=$? |
| 27072 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 27073 | | rm -f conftest.er1 |
| 27074 | | cat conftest.err >&5 |
| 27075 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 27076 | | (exit $ac_status); } && { |
| 27077 | | test -z "$ac_c_werror_flag" || |
| 27078 | | test ! -s conftest.err |
| 27079 | | } && test -s conftest.$ac_objext; then |
| 27080 | | gt_cv_c_wchar_t=yes |
| 27081 | | else |
| 27082 | | echo "$as_me: failed program was:" >&5 |
| 27083 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 27084 | | |
| 27085 | | gt_cv_c_wchar_t=no |
| 27086 | | fi |
| 27087 | | |
| 27088 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 27089 | | fi |
| 27090 | | { echo "$as_me:$LINENO: result: $gt_cv_c_wchar_t" >&5 |
| 27091 | | echo "${ECHO_T}$gt_cv_c_wchar_t" >&6; } |
| 27092 | | if test $gt_cv_c_wchar_t = yes; then |
| 27093 | | |
| 27094 | | cat >>confdefs.h <<\_ACEOF |
| 27095 | | #define HAVE_WCHAR_T 1 |
| 27096 | | _ACEOF |
| 27097 | | |
| 27098 | | fi |
| 27099 | | |
| 27100 | | |
| 27101 | | { echo "$as_me:$LINENO: checking for wint_t" >&5 |
| 27102 | | echo $ECHO_N "checking for wint_t... $ECHO_C" >&6; } |
| 27103 | | if test "${gt_cv_c_wint_t+set}" = set; then |
| 27104 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 27105 | | else |
| 27106 | | cat >conftest.$ac_ext <<_ACEOF |
| 27107 | | /* confdefs.h. */ |
| 27108 | | _ACEOF |
| 27109 | | cat confdefs.h >>conftest.$ac_ext |
| 27110 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27111 | | /* end confdefs.h. */ |
| 27112 | | #include <wchar.h> |
| 27113 | | wint_t foo = (wchar_t)'\0'; |
| 27114 | | int |
| 27115 | | main () |
| 27116 | | { |
| 27117 | | |
| 27118 | | ; |
| 27119 | | return 0; |
| 27120 | | } |
| 27121 | | _ACEOF |
| 27122 | | rm -f conftest.$ac_objext |
| 27123 | | if { (ac_try="$ac_compile" |
| 27124 | | case "(($ac_try" in |
| 27125 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27126 | | *) ac_try_echo=$ac_try;; |
| 27127 | | esac |
| 27128 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27129 | | (eval "$ac_compile") 2>conftest.er1 |
| 27130 | | ac_status=$? |
| 27131 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 27132 | | rm -f conftest.er1 |
| 27133 | | cat conftest.err >&5 |
| 27134 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 27135 | | (exit $ac_status); } && { |
| 27136 | | test -z "$ac_c_werror_flag" || |
| 27137 | | test ! -s conftest.err |
| 27138 | | } && test -s conftest.$ac_objext; then |
| 27139 | | gt_cv_c_wint_t=yes |
| 27140 | | else |
| 27141 | | echo "$as_me: failed program was:" >&5 |
| 27142 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 27143 | | |
| 27144 | | gt_cv_c_wint_t=no |
| 27145 | | fi |
| 27146 | | |
| 27147 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 27148 | | fi |
| 27149 | | { echo "$as_me:$LINENO: result: $gt_cv_c_wint_t" >&5 |
| 27150 | | echo "${ECHO_T}$gt_cv_c_wint_t" >&6; } |
| 27151 | | if test $gt_cv_c_wint_t = yes; then |
| 27152 | | |
| 27153 | | cat >>confdefs.h <<\_ACEOF |
| 27154 | | #define HAVE_WINT_T 1 |
| 27155 | | _ACEOF |
| 27156 | | |
| 27157 | | fi |
| 27158 | | |
| 27159 | | |
| 27160 | | |
| 27161 | | |
| 27162 | | { echo "$as_me:$LINENO: checking for intmax_t" >&5 |
| 27163 | | echo $ECHO_N "checking for intmax_t... $ECHO_C" >&6; } |
| 27164 | | if test "${gt_cv_c_intmax_t+set}" = set; then |
| 27165 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 27166 | | else |
| 27167 | | cat >conftest.$ac_ext <<_ACEOF |
| 27168 | | /* confdefs.h. */ |
| 27169 | | _ACEOF |
| 27170 | | cat confdefs.h >>conftest.$ac_ext |
| 27171 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27172 | | /* end confdefs.h. */ |
| 27173 | | |
| 27174 | | #include <stddef.h> |
| 27175 | | #include <stdlib.h> |
| 27176 | | #if HAVE_STDINT_H_WITH_UINTMAX |
| 27177 | | #include <stdint.h> |
| 27178 | | #endif |
| 27179 | | #if HAVE_INTTYPES_H_WITH_UINTMAX |
| 27180 | | #include <inttypes.h> |
| 27181 | | #endif |
| 27182 | | |
| 27183 | | int |
| 27184 | | main () |
| 27185 | | { |
| 27186 | | intmax_t x = -1; |
| 27187 | | ; |
| 27188 | | return 0; |
| 27189 | | } |
| 27190 | | _ACEOF |
| 27191 | | rm -f conftest.$ac_objext |
| 27192 | | if { (ac_try="$ac_compile" |
| 27193 | | case "(($ac_try" in |
| 27194 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27195 | | *) ac_try_echo=$ac_try;; |
| 27196 | | esac |
| 27197 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27198 | | (eval "$ac_compile") 2>conftest.er1 |
| 27199 | | ac_status=$? |
| 27200 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 27201 | | rm -f conftest.er1 |
| 27202 | | cat conftest.err >&5 |
| 27203 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 27204 | | (exit $ac_status); } && { |
| 27205 | | test -z "$ac_c_werror_flag" || |
| 27206 | | test ! -s conftest.err |
| 27207 | | } && test -s conftest.$ac_objext; then |
| 27208 | | gt_cv_c_intmax_t=yes |
| 27209 | | else |
| 27210 | | echo "$as_me: failed program was:" >&5 |
| 27211 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 27212 | | |
| 27213 | | gt_cv_c_intmax_t=no |
| 27214 | | fi |
| 27215 | | |
| 27216 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 27217 | | fi |
| 27218 | | { echo "$as_me:$LINENO: result: $gt_cv_c_intmax_t" >&5 |
| 27219 | | echo "${ECHO_T}$gt_cv_c_intmax_t" >&6; } |
| 27220 | | if test $gt_cv_c_intmax_t = yes; then |
| 27221 | | |
| 27222 | | cat >>confdefs.h <<\_ACEOF |
| 27223 | | #define HAVE_INTMAX_T 1 |
| 27224 | | _ACEOF |
| 27225 | | |
| 27226 | | fi |
| 27227 | | |
| 27228 | | |
| 27229 | | |
| 27230 | | { echo "$as_me:$LINENO: checking whether printf() supports POSIX/XSI format strings" >&5 |
| 27231 | | echo $ECHO_N "checking whether printf() supports POSIX/XSI format strings... $ECHO_C" >&6; } |
| 27232 | | if test "${gt_cv_func_printf_posix+set}" = set; then |
| 27233 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 27234 | | else |
| 27235 | | |
| 27236 | | if test "$cross_compiling" = yes; then |
| 27237 | | |
| 27238 | | cat >conftest.$ac_ext <<_ACEOF |
| 27239 | | /* confdefs.h. */ |
| 27240 | | _ACEOF |
| 27241 | | cat confdefs.h >>conftest.$ac_ext |
| 27242 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27243 | | /* end confdefs.h. */ |
| 27244 | | |
| 27245 | | #if defined __NetBSD__ || defined _MSC_VER || defined __MINGW32__ || defined __CYGWIN__ |
| 27246 | | notposix |
| 27247 | | #endif |
| 27248 | | |
| 27249 | | _ACEOF |
| 27250 | | if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | |
| 27251 | | $EGREP "notposix" >/dev/null 2>&1; then |
| 27252 | | gt_cv_func_printf_posix="guessing no" |
| 27253 | | else |
| 27254 | | gt_cv_func_printf_posix="guessing yes" |
| 27255 | | fi |
| 27256 | | rm -f conftest* |
| 27257 | | |
| 27258 | | |
| 27259 | | else |
| 27260 | | cat >conftest.$ac_ext <<_ACEOF |
| 27261 | | /* confdefs.h. */ |
| 27262 | | _ACEOF |
| 27263 | | cat confdefs.h >>conftest.$ac_ext |
| 27264 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27265 | | /* end confdefs.h. */ |
| 27266 | | |
| 27267 | | #include <stdio.h> |
| 27268 | | #include <string.h> |
| 27269 | | /* The string "%2$d %1$d", with dollar characters protected from the shell's |
| 27270 | | dollar expansion (possibly an autoconf bug). */ |
| 27271 | | static char format[] = { '%', '2', '$', 'd', ' ', '%', '1', '$', 'd', '\0' }; |
| 27272 | | static char buf[100]; |
| 27273 | | int main () |
| 27274 | | { |
| 27275 | | sprintf (buf, format, 33, 55); |
| 27276 | | return (strcmp (buf, "55 33") != 0); |
| 27277 | | } |
| 27278 | | _ACEOF |
| 27279 | | rm -f conftest$ac_exeext |
| 27280 | | if { (ac_try="$ac_link" |
| 27281 | | case "(($ac_try" in |
| 27282 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27283 | | *) ac_try_echo=$ac_try;; |
| 27284 | | esac |
| 27285 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27286 | | (eval "$ac_link") 2>&5 |
| 27287 | | ac_status=$? |
| 27288 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 27289 | | (exit $ac_status); } && { ac_try='./conftest$ac_exeext' |
| 27290 | | { (case "(($ac_try" in |
| 27291 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27292 | | *) ac_try_echo=$ac_try;; |
| 27293 | | esac |
| 27294 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27295 | | (eval "$ac_try") 2>&5 |
| 27296 | | ac_status=$? |
| 27297 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 27298 | | (exit $ac_status); }; }; then |
| 27299 | | gt_cv_func_printf_posix=yes |
| 27300 | | else |
| 27301 | | echo "$as_me: program exited with status $ac_status" >&5 |
| 27302 | | echo "$as_me: failed program was:" >&5 |
| 27303 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 27304 | | |
| 27305 | | ( exit $ac_status ) |
| 27306 | | gt_cv_func_printf_posix=no |
| 27307 | | fi |
| 27308 | | rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext |
| 27309 | | fi |
| 27310 | | |
| 27311 | | |
| 27312 | | |
| 27313 | | fi |
| 27314 | | { echo "$as_me:$LINENO: result: $gt_cv_func_printf_posix" >&5 |
| 27315 | | echo "${ECHO_T}$gt_cv_func_printf_posix" >&6; } |
| 27316 | | case $gt_cv_func_printf_posix in |
| 27317 | | *yes) |
| 27318 | | |
| 27319 | | cat >>confdefs.h <<\_ACEOF |
| 27320 | | #define HAVE_POSIX_PRINTF 1 |
| 27321 | | _ACEOF |
| 27322 | | |
| 27323 | | ;; |
| 27324 | | esac |
| 27325 | | |
| 27326 | | |
| 27327 | | { echo "$as_me:$LINENO: checking whether we are using the GNU C Library 2.1 or newer" >&5 |
| 27328 | | echo $ECHO_N "checking whether we are using the GNU C Library 2.1 or newer... $ECHO_C" >&6; } |
| 27329 | | if test "${ac_cv_gnu_library_2_1+set}" = set; then |
| 27330 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 27331 | | else |
| 27332 | | cat >conftest.$ac_ext <<_ACEOF |
| 27333 | | /* confdefs.h. */ |
| 27334 | | _ACEOF |
| 27335 | | cat confdefs.h >>conftest.$ac_ext |
| 27336 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27337 | | /* end confdefs.h. */ |
| 27338 | | |
| 27339 | | #include <features.h> |
| 27340 | | #ifdef __GNU_LIBRARY__ |
| 27341 | | #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2) |
| 27342 | | Lucky GNU user |
| 27343 | | #endif |
| 27344 | | #endif |
| 27345 | | |
| 27346 | | _ACEOF |
| 27347 | | if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | |
| 27348 | | $EGREP "Lucky GNU user" >/dev/null 2>&1; then |
| 27349 | | ac_cv_gnu_library_2_1=yes |
| 27350 | | else |
| 27351 | | ac_cv_gnu_library_2_1=no |
| 27352 | | fi |
| 27353 | | rm -f conftest* |
| 27354 | | |
| 27355 | | |
| 27356 | | |
| 27357 | | fi |
| 27358 | | { echo "$as_me:$LINENO: result: $ac_cv_gnu_library_2_1" >&5 |
| 27359 | | echo "${ECHO_T}$ac_cv_gnu_library_2_1" >&6; } |
| 27360 | | |
| 27361 | | GLIBC21="$ac_cv_gnu_library_2_1" |
| 27362 | | |
| 27363 | | |
| 27364 | | |
| 27365 | | |
| 27366 | | for ac_header in stdint.h |
| 27367 | | do |
| 27368 | | as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` |
| 27369 | | if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then |
| 27370 | | { echo "$as_me:$LINENO: checking for $ac_header" >&5 |
| 27371 | | echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } |
| 27372 | | if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then |
| 27373 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 27374 | | fi |
| 27375 | | ac_res=`eval echo '${'$as_ac_Header'}'` |
| 27376 | | { echo "$as_me:$LINENO: result: $ac_res" >&5 |
| 27377 | | echo "${ECHO_T}$ac_res" >&6; } |
| 27378 | | else |
| 27379 | | # Is the header compilable? |
| 27380 | | { echo "$as_me:$LINENO: checking $ac_header usability" >&5 |
| 27381 | | echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; } |
| 27382 | | cat >conftest.$ac_ext <<_ACEOF |
| 27383 | | /* confdefs.h. */ |
| 27384 | | _ACEOF |
| 27385 | | cat confdefs.h >>conftest.$ac_ext |
| 27386 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27387 | | /* end confdefs.h. */ |
| 27388 | | $ac_includes_default |
| 27389 | | #include <$ac_header> |
| 27390 | | _ACEOF |
| 27391 | | rm -f conftest.$ac_objext |
| 27392 | | if { (ac_try="$ac_compile" |
| 27393 | | case "(($ac_try" in |
| 27394 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27395 | | *) ac_try_echo=$ac_try;; |
| 27396 | | esac |
| 27397 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27398 | | (eval "$ac_compile") 2>conftest.er1 |
| 27399 | | ac_status=$? |
| 27400 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 27401 | | rm -f conftest.er1 |
| 27402 | | cat conftest.err >&5 |
| 27403 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 27404 | | (exit $ac_status); } && { |
| 27405 | | test -z "$ac_c_werror_flag" || |
| 27406 | | test ! -s conftest.err |
| 27407 | | } && test -s conftest.$ac_objext; then |
| 27408 | | ac_header_compiler=yes |
| 27409 | | else |
| 27410 | | echo "$as_me: failed program was:" >&5 |
| 27411 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 27412 | | |
| 27413 | | ac_header_compiler=no |
| 27414 | | fi |
| 27415 | | |
| 27416 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 27417 | | { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 |
| 27418 | | echo "${ECHO_T}$ac_header_compiler" >&6; } |
| 27419 | | |
| 27420 | | # Is the header present? |
| 27421 | | { echo "$as_me:$LINENO: checking $ac_header presence" >&5 |
| 27422 | | echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; } |
| 27423 | | cat >conftest.$ac_ext <<_ACEOF |
| 27424 | | /* confdefs.h. */ |
| 27425 | | _ACEOF |
| 27426 | | cat confdefs.h >>conftest.$ac_ext |
| 27427 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27428 | | /* end confdefs.h. */ |
| 27429 | | #include <$ac_header> |
| 27430 | | _ACEOF |
| 27431 | | if { (ac_try="$ac_cpp conftest.$ac_ext" |
| 27432 | | case "(($ac_try" in |
| 27433 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27434 | | *) ac_try_echo=$ac_try;; |
| 27435 | | esac |
| 27436 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27437 | | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 |
| 27438 | | ac_status=$? |
| 27439 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 27440 | | rm -f conftest.er1 |
| 27441 | | cat conftest.err >&5 |
| 27442 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 27443 | | (exit $ac_status); } >/dev/null && { |
| 27444 | | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| 27445 | | test ! -s conftest.err |
| 27446 | | }; then |
| 27447 | | ac_header_preproc=yes |
| 27448 | | else |
| 27449 | | echo "$as_me: failed program was:" >&5 |
| 27450 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 27451 | | |
| 27452 | | ac_header_preproc=no |
| 27453 | | fi |
| 27454 | | |
| 27455 | | rm -f conftest.err conftest.$ac_ext |
| 27456 | | { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 |
| 27457 | | echo "${ECHO_T}$ac_header_preproc" >&6; } |
| 27458 | | |
| 27459 | | # So? What about this header? |
| 27460 | | case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in |
| 27461 | | yes:no: ) |
| 27462 | | { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 |
| 27463 | | echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} |
| 27464 | | { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5 |
| 27465 | | echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;} |
| 27466 | | ac_header_preproc=yes |
| 27467 | | ;; |
| 27468 | | no:yes:* ) |
| 27469 | | { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 |
| 27470 | | echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} |
| 27471 | | { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 |
| 27472 | | echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} |
| 27473 | | { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5 |
| 27474 | | echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;} |
| 27475 | | { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5 |
| 27476 | | echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;} |
| 27477 | | { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 |
| 27478 | | echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} |
| 27479 | | { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5 |
| 27480 | | echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;} |
| 27481 | | |
| 27482 | | ;; |
| 27483 | | esac |
| 27484 | | { echo "$as_me:$LINENO: checking for $ac_header" >&5 |
| 27485 | | echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } |
| 27486 | | if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then |
| 27487 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 27488 | | else |
| 27489 | | eval "$as_ac_Header=\$ac_header_preproc" |
| 27490 | | fi |
| 27491 | | ac_res=`eval echo '${'$as_ac_Header'}'` |
| 27492 | | { echo "$as_me:$LINENO: result: $ac_res" >&5 |
| 27493 | | echo "${ECHO_T}$ac_res" >&6; } |
| 27494 | | |
| 27495 | | fi |
| 27496 | | if test `eval echo '${'$as_ac_Header'}'` = yes; then |
| 27497 | | cat >>confdefs.h <<_ACEOF |
| 27498 | | #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 |
| 27499 | | _ACEOF |
| 27500 | | |
| 27501 | | fi |
| 27502 | | |
| 27503 | | done |
| 27504 | | |
| 27505 | | { echo "$as_me:$LINENO: checking for SIZE_MAX" >&5 |
| 27506 | | echo $ECHO_N "checking for SIZE_MAX... $ECHO_C" >&6; } |
| 27507 | | result= |
| 27508 | | cat >conftest.$ac_ext <<_ACEOF |
| 27509 | | /* confdefs.h. */ |
| 27510 | | _ACEOF |
| 27511 | | cat confdefs.h >>conftest.$ac_ext |
| 27512 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27513 | | /* end confdefs.h. */ |
| 27514 | | |
| 27515 | | #include <limits.h> |
| 27516 | | #if HAVE_STDINT_H |
| 27517 | | #include <stdint.h> |
| 27518 | | #endif |
| 27519 | | #ifdef SIZE_MAX |
| 27520 | | Found it |
| 27521 | | #endif |
| 27522 | | |
| 27523 | | _ACEOF |
| 27524 | | if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | |
| 27525 | | $EGREP "Found it" >/dev/null 2>&1; then |
| 27526 | | result=yes |
| 27527 | | fi |
| 27528 | | rm -f conftest* |
| 27529 | | |
| 27530 | | if test -z "$result"; then |
| 27531 | | if test "$cross_compiling" = yes; then |
| 27532 | | # Depending upon the size, compute the lo and hi bounds. |
| 27533 | | cat >conftest.$ac_ext <<_ACEOF |
| 27534 | | /* confdefs.h. */ |
| 27535 | | _ACEOF |
| 27536 | | cat confdefs.h >>conftest.$ac_ext |
| 27537 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27538 | | /* end confdefs.h. */ |
| 27539 | | #include <stddef.h> |
| 27540 | | #include <limits.h> |
| 27541 | | int |
| 27542 | | main () |
| 27543 | | { |
| 27544 | | static int test_array [1 - 2 * !((sizeof (size_t) * CHAR_BIT - 1) >= 0)]; |
| 27545 | | test_array [0] = 0 |
| 27546 | | |
| 27547 | | ; |
| 27548 | | return 0; |
| 27549 | | } |
| 27550 | | _ACEOF |
| 27551 | | rm -f conftest.$ac_objext |
| 27552 | | if { (ac_try="$ac_compile" |
| 27553 | | case "(($ac_try" in |
| 27554 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27555 | | *) ac_try_echo=$ac_try;; |
| 27556 | | esac |
| 27557 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27558 | | (eval "$ac_compile") 2>conftest.er1 |
| 27559 | | ac_status=$? |
| 27560 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 27561 | | rm -f conftest.er1 |
| 27562 | | cat conftest.err >&5 |
| 27563 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 27564 | | (exit $ac_status); } && { |
| 27565 | | test -z "$ac_c_werror_flag" || |
| 27566 | | test ! -s conftest.err |
| 27567 | | } && test -s conftest.$ac_objext; then |
| 27568 | | ac_lo=0 ac_mid=0 |
| 27569 | | while :; do |
| 27570 | | cat >conftest.$ac_ext <<_ACEOF |
| 27571 | | /* confdefs.h. */ |
| 27572 | | _ACEOF |
| 27573 | | cat confdefs.h >>conftest.$ac_ext |
| 27574 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27575 | | /* end confdefs.h. */ |
| 27576 | | #include <stddef.h> |
| 27577 | | #include <limits.h> |
| 27578 | | int |
| 27579 | | main () |
| 27580 | | { |
| 27581 | | static int test_array [1 - 2 * !((sizeof (size_t) * CHAR_BIT - 1) <= $ac_mid)]; |
| 27582 | | test_array [0] = 0 |
| 27583 | | |
| 27584 | | ; |
| 27585 | | return 0; |
| 27586 | | } |
| 27587 | | _ACEOF |
| 27588 | | rm -f conftest.$ac_objext |
| 27589 | | if { (ac_try="$ac_compile" |
| 27590 | | case "(($ac_try" in |
| 27591 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27592 | | *) ac_try_echo=$ac_try;; |
| 27593 | | esac |
| 27594 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27595 | | (eval "$ac_compile") 2>conftest.er1 |
| 27596 | | ac_status=$? |
| 27597 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 27598 | | rm -f conftest.er1 |
| 27599 | | cat conftest.err >&5 |
| 27600 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 27601 | | (exit $ac_status); } && { |
| 27602 | | test -z "$ac_c_werror_flag" || |
| 27603 | | test ! -s conftest.err |
| 27604 | | } && test -s conftest.$ac_objext; then |
| 27605 | | ac_hi=$ac_mid; break |
| 27606 | | else |
| 27607 | | echo "$as_me: failed program was:" >&5 |
| 27608 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 27609 | | |
| 27610 | | ac_lo=`expr $ac_mid + 1` |
| 27611 | | if test $ac_lo -le $ac_mid; then |
| 27612 | | ac_lo= ac_hi= |
| 27613 | | break |
| 27614 | | fi |
| 27615 | | ac_mid=`expr 2 '*' $ac_mid + 1` |
| 27616 | | fi |
| 27617 | | |
| 27618 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 27619 | | done |
| 27620 | | else |
| 27621 | | echo "$as_me: failed program was:" >&5 |
| 27622 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 27623 | | |
| 27624 | | cat >conftest.$ac_ext <<_ACEOF |
| 27625 | | /* confdefs.h. */ |
| 27626 | | _ACEOF |
| 27627 | | cat confdefs.h >>conftest.$ac_ext |
| 27628 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27629 | | /* end confdefs.h. */ |
| 27630 | | #include <stddef.h> |
| 27631 | | #include <limits.h> |
| 27632 | | int |
| 27633 | | main () |
| 27634 | | { |
| 27635 | | static int test_array [1 - 2 * !((sizeof (size_t) * CHAR_BIT - 1) < 0)]; |
| 27636 | | test_array [0] = 0 |
| 27637 | | |
| 27638 | | ; |
| 27639 | | return 0; |
| 27640 | | } |
| 27641 | | _ACEOF |
| 27642 | | rm -f conftest.$ac_objext |
| 27643 | | if { (ac_try="$ac_compile" |
| 27644 | | case "(($ac_try" in |
| 27645 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27646 | | *) ac_try_echo=$ac_try;; |
| 27647 | | esac |
| 27648 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27649 | | (eval "$ac_compile") 2>conftest.er1 |
| 27650 | | ac_status=$? |
| 27651 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 27652 | | rm -f conftest.er1 |
| 27653 | | cat conftest.err >&5 |
| 27654 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 27655 | | (exit $ac_status); } && { |
| 27656 | | test -z "$ac_c_werror_flag" || |
| 27657 | | test ! -s conftest.err |
| 27658 | | } && test -s conftest.$ac_objext; then |
| 27659 | | ac_hi=-1 ac_mid=-1 |
| 27660 | | while :; do |
| 27661 | | cat >conftest.$ac_ext <<_ACEOF |
| 27662 | | /* confdefs.h. */ |
| 27663 | | _ACEOF |
| 27664 | | cat confdefs.h >>conftest.$ac_ext |
| 27665 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27666 | | /* end confdefs.h. */ |
| 27667 | | #include <stddef.h> |
| 27668 | | #include <limits.h> |
| 27669 | | int |
| 27670 | | main () |
| 27671 | | { |
| 27672 | | static int test_array [1 - 2 * !((sizeof (size_t) * CHAR_BIT - 1) >= $ac_mid)]; |
| 27673 | | test_array [0] = 0 |
| 27674 | | |
| 27675 | | ; |
| 27676 | | return 0; |
| 27677 | | } |
| 27678 | | _ACEOF |
| 27679 | | rm -f conftest.$ac_objext |
| 27680 | | if { (ac_try="$ac_compile" |
| 27681 | | case "(($ac_try" in |
| 27682 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27683 | | *) ac_try_echo=$ac_try;; |
| 27684 | | esac |
| 27685 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27686 | | (eval "$ac_compile") 2>conftest.er1 |
| 27687 | | ac_status=$? |
| 27688 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 27689 | | rm -f conftest.er1 |
| 27690 | | cat conftest.err >&5 |
| 27691 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 27692 | | (exit $ac_status); } && { |
| 27693 | | test -z "$ac_c_werror_flag" || |
| 27694 | | test ! -s conftest.err |
| 27695 | | } && test -s conftest.$ac_objext; then |
| 27696 | | ac_lo=$ac_mid; break |
| 27697 | | else |
| 27698 | | echo "$as_me: failed program was:" >&5 |
| 27699 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 27700 | | |
| 27701 | | ac_hi=`expr '(' $ac_mid ')' - 1` |
| 27702 | | if test $ac_mid -le $ac_hi; then |
| 27703 | | ac_lo= ac_hi= |
| 27704 | | break |
| 27705 | | fi |
| 27706 | | ac_mid=`expr 2 '*' $ac_mid` |
| 27707 | | fi |
| 27708 | | |
| 27709 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 27710 | | done |
| 27711 | | else |
| 27712 | | echo "$as_me: failed program was:" >&5 |
| 27713 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 27714 | | |
| 27715 | | ac_lo= ac_hi= |
| 27716 | | fi |
| 27717 | | |
| 27718 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 27719 | | fi |
| 27720 | | |
| 27721 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 27722 | | # Binary search between lo and hi bounds. |
| 27723 | | while test "x$ac_lo" != "x$ac_hi"; do |
| 27724 | | ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` |
| 27725 | | cat >conftest.$ac_ext <<_ACEOF |
| 27726 | | /* confdefs.h. */ |
| 27727 | | _ACEOF |
| 27728 | | cat confdefs.h >>conftest.$ac_ext |
| 27729 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27730 | | /* end confdefs.h. */ |
| 27731 | | #include <stddef.h> |
| 27732 | | #include <limits.h> |
| 27733 | | int |
| 27734 | | main () |
| 27735 | | { |
| 27736 | | static int test_array [1 - 2 * !((sizeof (size_t) * CHAR_BIT - 1) <= $ac_mid)]; |
| 27737 | | test_array [0] = 0 |
| 27738 | | |
| 27739 | | ; |
| 27740 | | return 0; |
| 27741 | | } |
| 27742 | | _ACEOF |
| 27743 | | rm -f conftest.$ac_objext |
| 27744 | | if { (ac_try="$ac_compile" |
| 27745 | | case "(($ac_try" in |
| 27746 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27747 | | *) ac_try_echo=$ac_try;; |
| 27748 | | esac |
| 27749 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27750 | | (eval "$ac_compile") 2>conftest.er1 |
| 27751 | | ac_status=$? |
| 27752 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 27753 | | rm -f conftest.er1 |
| 27754 | | cat conftest.err >&5 |
| 27755 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 27756 | | (exit $ac_status); } && { |
| 27757 | | test -z "$ac_c_werror_flag" || |
| 27758 | | test ! -s conftest.err |
| 27759 | | } && test -s conftest.$ac_objext; then |
| 27760 | | ac_hi=$ac_mid |
| 27761 | | else |
| 27762 | | echo "$as_me: failed program was:" >&5 |
| 27763 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 27764 | | |
| 27765 | | ac_lo=`expr '(' $ac_mid ')' + 1` |
| 27766 | | fi |
| 27767 | | |
| 27768 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 27769 | | done |
| 27770 | | case $ac_lo in |
| 27771 | | ?*) size_t_bits_minus_1=$ac_lo;; |
| 27772 | | '') size_t_bits_minus_1= ;; |
| 27773 | | esac |
| 27774 | | else |
| 27775 | | cat >conftest.$ac_ext <<_ACEOF |
| 27776 | | /* confdefs.h. */ |
| 27777 | | _ACEOF |
| 27778 | | cat confdefs.h >>conftest.$ac_ext |
| 27779 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27780 | | /* end confdefs.h. */ |
| 27781 | | #include <stddef.h> |
| 27782 | | #include <limits.h> |
| 27783 | | static long int longval () { return sizeof (size_t) * CHAR_BIT - 1; } |
| 27784 | | static unsigned long int ulongval () { return sizeof (size_t) * CHAR_BIT - 1; } |
| 27785 | | #include <stdio.h> |
| 27786 | | #include <stdlib.h> |
| 27787 | | int |
| 27788 | | main () |
| 27789 | | { |
| 27790 | | |
| 27791 | | FILE *f = fopen ("conftest.val", "w"); |
| 27792 | | if (! f) |
| 27793 | | return 1; |
| 27794 | | if ((sizeof (size_t) * CHAR_BIT - 1) < 0) |
| 27795 | | { |
| 27796 | | long int i = longval (); |
| 27797 | | if (i != (sizeof (size_t) * CHAR_BIT - 1)) |
| 27798 | | return 1; |
| 27799 | | fprintf (f, "%ld\n", i); |
| 27800 | | } |
| 27801 | | else |
| 27802 | | { |
| 27803 | | unsigned long int i = ulongval (); |
| 27804 | | if (i != (sizeof (size_t) * CHAR_BIT - 1)) |
| 27805 | | return 1; |
| 27806 | | fprintf (f, "%lu\n", i); |
| 27807 | | } |
| 27808 | | return ferror (f) || fclose (f) != 0; |
| 27809 | | |
| 27810 | | ; |
| 27811 | | return 0; |
| 27812 | | } |
| 27813 | | _ACEOF |
| 27814 | | rm -f conftest$ac_exeext |
| 27815 | | if { (ac_try="$ac_link" |
| 27816 | | case "(($ac_try" in |
| 27817 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27818 | | *) ac_try_echo=$ac_try;; |
| 27819 | | esac |
| 27820 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27821 | | (eval "$ac_link") 2>&5 |
| 27822 | | ac_status=$? |
| 27823 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 27824 | | (exit $ac_status); } && { ac_try='./conftest$ac_exeext' |
| 27825 | | { (case "(($ac_try" in |
| 27826 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27827 | | *) ac_try_echo=$ac_try;; |
| 27828 | | esac |
| 27829 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27830 | | (eval "$ac_try") 2>&5 |
| 27831 | | ac_status=$? |
| 27832 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 27833 | | (exit $ac_status); }; }; then |
| 27834 | | size_t_bits_minus_1=`cat conftest.val` |
| 27835 | | else |
| 27836 | | echo "$as_me: program exited with status $ac_status" >&5 |
| 27837 | | echo "$as_me: failed program was:" >&5 |
| 27838 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 27839 | | |
| 27840 | | ( exit $ac_status ) |
| 27841 | | size_t_bits_minus_1= |
| 27842 | | fi |
| 27843 | | rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext |
| 27844 | | fi |
| 27845 | | rm -f conftest.val |
| 27846 | | |
| 27847 | | if test "$cross_compiling" = yes; then |
| 27848 | | # Depending upon the size, compute the lo and hi bounds. |
| 27849 | | cat >conftest.$ac_ext <<_ACEOF |
| 27850 | | /* confdefs.h. */ |
| 27851 | | _ACEOF |
| 27852 | | cat confdefs.h >>conftest.$ac_ext |
| 27853 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27854 | | /* end confdefs.h. */ |
| 27855 | | #include <stddef.h> |
| 27856 | | int |
| 27857 | | main () |
| 27858 | | { |
| 27859 | | static int test_array [1 - 2 * !((sizeof (size_t) <= sizeof (unsigned int)) >= 0)]; |
| 27860 | | test_array [0] = 0 |
| 27861 | | |
| 27862 | | ; |
| 27863 | | return 0; |
| 27864 | | } |
| 27865 | | _ACEOF |
| 27866 | | rm -f conftest.$ac_objext |
| 27867 | | if { (ac_try="$ac_compile" |
| 27868 | | case "(($ac_try" in |
| 27869 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27870 | | *) ac_try_echo=$ac_try;; |
| 27871 | | esac |
| 27872 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27873 | | (eval "$ac_compile") 2>conftest.er1 |
| 27874 | | ac_status=$? |
| 27875 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 27876 | | rm -f conftest.er1 |
| 27877 | | cat conftest.err >&5 |
| 27878 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 27879 | | (exit $ac_status); } && { |
| 27880 | | test -z "$ac_c_werror_flag" || |
| 27881 | | test ! -s conftest.err |
| 27882 | | } && test -s conftest.$ac_objext; then |
| 27883 | | ac_lo=0 ac_mid=0 |
| 27884 | | while :; do |
| 27885 | | cat >conftest.$ac_ext <<_ACEOF |
| 27886 | | /* confdefs.h. */ |
| 27887 | | _ACEOF |
| 27888 | | cat confdefs.h >>conftest.$ac_ext |
| 27889 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27890 | | /* end confdefs.h. */ |
| 27891 | | #include <stddef.h> |
| 27892 | | int |
| 27893 | | main () |
| 27894 | | { |
| 27895 | | static int test_array [1 - 2 * !((sizeof (size_t) <= sizeof (unsigned int)) <= $ac_mid)]; |
| 27896 | | test_array [0] = 0 |
| 27897 | | |
| 27898 | | ; |
| 27899 | | return 0; |
| 27900 | | } |
| 27901 | | _ACEOF |
| 27902 | | rm -f conftest.$ac_objext |
| 27903 | | if { (ac_try="$ac_compile" |
| 27904 | | case "(($ac_try" in |
| 27905 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27906 | | *) ac_try_echo=$ac_try;; |
| 27907 | | esac |
| 27908 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27909 | | (eval "$ac_compile") 2>conftest.er1 |
| 27910 | | ac_status=$? |
| 27911 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 27912 | | rm -f conftest.er1 |
| 27913 | | cat conftest.err >&5 |
| 27914 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 27915 | | (exit $ac_status); } && { |
| 27916 | | test -z "$ac_c_werror_flag" || |
| 27917 | | test ! -s conftest.err |
| 27918 | | } && test -s conftest.$ac_objext; then |
| 27919 | | ac_hi=$ac_mid; break |
| 27920 | | else |
| 27921 | | echo "$as_me: failed program was:" >&5 |
| 27922 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 27923 | | |
| 27924 | | ac_lo=`expr $ac_mid + 1` |
| 27925 | | if test $ac_lo -le $ac_mid; then |
| 27926 | | ac_lo= ac_hi= |
| 27927 | | break |
| 27928 | | fi |
| 27929 | | ac_mid=`expr 2 '*' $ac_mid + 1` |
| 27930 | | fi |
| 27931 | | |
| 27932 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 27933 | | done |
| 27934 | | else |
| 27935 | | echo "$as_me: failed program was:" >&5 |
| 27936 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 27937 | | |
| 27938 | | cat >conftest.$ac_ext <<_ACEOF |
| 27939 | | /* confdefs.h. */ |
| 27940 | | _ACEOF |
| 27941 | | cat confdefs.h >>conftest.$ac_ext |
| 27942 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27943 | | /* end confdefs.h. */ |
| 27944 | | #include <stddef.h> |
| 27945 | | int |
| 27946 | | main () |
| 27947 | | { |
| 27948 | | static int test_array [1 - 2 * !((sizeof (size_t) <= sizeof (unsigned int)) < 0)]; |
| 27949 | | test_array [0] = 0 |
| 27950 | | |
| 27951 | | ; |
| 27952 | | return 0; |
| 27953 | | } |
| 27954 | | _ACEOF |
| 27955 | | rm -f conftest.$ac_objext |
| 27956 | | if { (ac_try="$ac_compile" |
| 27957 | | case "(($ac_try" in |
| 27958 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27959 | | *) ac_try_echo=$ac_try;; |
| 27960 | | esac |
| 27961 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27962 | | (eval "$ac_compile") 2>conftest.er1 |
| 27963 | | ac_status=$? |
| 27964 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 27965 | | rm -f conftest.er1 |
| 27966 | | cat conftest.err >&5 |
| 27967 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 27968 | | (exit $ac_status); } && { |
| 27969 | | test -z "$ac_c_werror_flag" || |
| 27970 | | test ! -s conftest.err |
| 27971 | | } && test -s conftest.$ac_objext; then |
| 27972 | | ac_hi=-1 ac_mid=-1 |
| 27973 | | while :; do |
| 27974 | | cat >conftest.$ac_ext <<_ACEOF |
| 27975 | | /* confdefs.h. */ |
| 27976 | | _ACEOF |
| 27977 | | cat confdefs.h >>conftest.$ac_ext |
| 27978 | | cat >>conftest.$ac_ext <<_ACEOF |
| 27979 | | /* end confdefs.h. */ |
| 27980 | | #include <stddef.h> |
| 27981 | | int |
| 27982 | | main () |
| 27983 | | { |
| 27984 | | static int test_array [1 - 2 * !((sizeof (size_t) <= sizeof (unsigned int)) >= $ac_mid)]; |
| 27985 | | test_array [0] = 0 |
| 27986 | | |
| 27987 | | ; |
| 27988 | | return 0; |
| 27989 | | } |
| 27990 | | _ACEOF |
| 27991 | | rm -f conftest.$ac_objext |
| 27992 | | if { (ac_try="$ac_compile" |
| 27993 | | case "(($ac_try" in |
| 27994 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 27995 | | *) ac_try_echo=$ac_try;; |
| 27996 | | esac |
| 27997 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 27998 | | (eval "$ac_compile") 2>conftest.er1 |
| 27999 | | ac_status=$? |
| 28000 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 28001 | | rm -f conftest.er1 |
| 28002 | | cat conftest.err >&5 |
| 28003 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 28004 | | (exit $ac_status); } && { |
| 28005 | | test -z "$ac_c_werror_flag" || |
| 28006 | | test ! -s conftest.err |
| 28007 | | } && test -s conftest.$ac_objext; then |
| 28008 | | ac_lo=$ac_mid; break |
| 28009 | | else |
| 28010 | | echo "$as_me: failed program was:" >&5 |
| 28011 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 28012 | | |
| 28013 | | ac_hi=`expr '(' $ac_mid ')' - 1` |
| 28014 | | if test $ac_mid -le $ac_hi; then |
| 28015 | | ac_lo= ac_hi= |
| 28016 | | break |
| 28017 | | fi |
| 28018 | | ac_mid=`expr 2 '*' $ac_mid` |
| 28019 | | fi |
| 28020 | | |
| 28021 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 28022 | | done |
| 28023 | | else |
| 28024 | | echo "$as_me: failed program was:" >&5 |
| 28025 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 28026 | | |
| 28027 | | ac_lo= ac_hi= |
| 28028 | | fi |
| 28029 | | |
| 28030 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 28031 | | fi |
| 28032 | | |
| 28033 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 28034 | | # Binary search between lo and hi bounds. |
| 28035 | | while test "x$ac_lo" != "x$ac_hi"; do |
| 28036 | | ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` |
| 28037 | | cat >conftest.$ac_ext <<_ACEOF |
| 28038 | | /* confdefs.h. */ |
| 28039 | | _ACEOF |
| 28040 | | cat confdefs.h >>conftest.$ac_ext |
| 28041 | | cat >>conftest.$ac_ext <<_ACEOF |
| 28042 | | /* end confdefs.h. */ |
| 28043 | | #include <stddef.h> |
| 28044 | | int |
| 28045 | | main () |
| 28046 | | { |
| 28047 | | static int test_array [1 - 2 * !((sizeof (size_t) <= sizeof (unsigned int)) <= $ac_mid)]; |
| 28048 | | test_array [0] = 0 |
| 28049 | | |
| 28050 | | ; |
| 28051 | | return 0; |
| 28052 | | } |
| 28053 | | _ACEOF |
| 28054 | | rm -f conftest.$ac_objext |
| 28055 | | if { (ac_try="$ac_compile" |
| 28056 | | case "(($ac_try" in |
| 28057 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 28058 | | *) ac_try_echo=$ac_try;; |
| 28059 | | esac |
| 28060 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 28061 | | (eval "$ac_compile") 2>conftest.er1 |
| 28062 | | ac_status=$? |
| 28063 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 28064 | | rm -f conftest.er1 |
| 28065 | | cat conftest.err >&5 |
| 28066 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 28067 | | (exit $ac_status); } && { |
| 28068 | | test -z "$ac_c_werror_flag" || |
| 28069 | | test ! -s conftest.err |
| 28070 | | } && test -s conftest.$ac_objext; then |
| 28071 | | ac_hi=$ac_mid |
| 28072 | | else |
| 28073 | | echo "$as_me: failed program was:" >&5 |
| 28074 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 28075 | | |
| 28076 | | ac_lo=`expr '(' $ac_mid ')' + 1` |
| 28077 | | fi |
| 28078 | | |
| 28079 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 28080 | | done |
| 28081 | | case $ac_lo in |
| 28082 | | ?*) fits_in_uint=$ac_lo;; |
| 28083 | | '') fits_in_uint= ;; |
| 28084 | | esac |
| 28085 | | else |
| 28086 | | cat >conftest.$ac_ext <<_ACEOF |
| 28087 | | /* confdefs.h. */ |
| 28088 | | _ACEOF |
| 28089 | | cat confdefs.h >>conftest.$ac_ext |
| 28090 | | cat >>conftest.$ac_ext <<_ACEOF |
| 28091 | | /* end confdefs.h. */ |
| 28092 | | #include <stddef.h> |
| 28093 | | static long int longval () { return sizeof (size_t) <= sizeof (unsigned int); } |
| 28094 | | static unsigned long int ulongval () { return sizeof (size_t) <= sizeof (unsigned int); } |
| 28095 | | #include <stdio.h> |
| 28096 | | #include <stdlib.h> |
| 28097 | | int |
| 28098 | | main () |
| 28099 | | { |
| 28100 | | |
| 28101 | | FILE *f = fopen ("conftest.val", "w"); |
| 28102 | | if (! f) |
| 28103 | | return 1; |
| 28104 | | if ((sizeof (size_t) <= sizeof (unsigned int)) < 0) |
| 28105 | | { |
| 28106 | | long int i = longval (); |
| 28107 | | if (i != (sizeof (size_t) <= sizeof (unsigned int))) |
| 28108 | | return 1; |
| 28109 | | fprintf (f, "%ld\n", i); |
| 28110 | | } |
| 28111 | | else |
| 28112 | | { |
| 28113 | | unsigned long int i = ulongval (); |
| 28114 | | if (i != (sizeof (size_t) <= sizeof (unsigned int))) |
| 28115 | | return 1; |
| 28116 | | fprintf (f, "%lu\n", i); |
| 28117 | | } |
| 28118 | | return ferror (f) || fclose (f) != 0; |
| 28119 | | |
| 28120 | | ; |
| 28121 | | return 0; |
| 28122 | | } |
| 28123 | | _ACEOF |
| 28124 | | rm -f conftest$ac_exeext |
| 28125 | | if { (ac_try="$ac_link" |
| 28126 | | case "(($ac_try" in |
| 28127 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 28128 | | *) ac_try_echo=$ac_try;; |
| 28129 | | esac |
| 28130 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 28131 | | (eval "$ac_link") 2>&5 |
| 28132 | | ac_status=$? |
| 28133 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 28134 | | (exit $ac_status); } && { ac_try='./conftest$ac_exeext' |
| 28135 | | { (case "(($ac_try" in |
| 28136 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 28137 | | *) ac_try_echo=$ac_try;; |
| 28138 | | esac |
| 28139 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 28140 | | (eval "$ac_try") 2>&5 |
| 28141 | | ac_status=$? |
| 28142 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 28143 | | (exit $ac_status); }; }; then |
| 28144 | | fits_in_uint=`cat conftest.val` |
| 28145 | | else |
| 28146 | | echo "$as_me: program exited with status $ac_status" >&5 |
| 28147 | | echo "$as_me: failed program was:" >&5 |
| 28148 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 28149 | | |
| 28150 | | ( exit $ac_status ) |
| 28151 | | fits_in_uint= |
| 28152 | | fi |
| 28153 | | rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext |
| 28154 | | fi |
| 28155 | | rm -f conftest.val |
| 28156 | | |
| 28157 | | if test -n "$size_t_bits_minus_1" && test -n "$fits_in_uint"; then |
| 28158 | | if test $fits_in_uint = 1; then |
| 28159 | | cat >conftest.$ac_ext <<_ACEOF |
| 28160 | | /* confdefs.h. */ |
| 28161 | | _ACEOF |
| 28162 | | cat confdefs.h >>conftest.$ac_ext |
| 28163 | | cat >>conftest.$ac_ext <<_ACEOF |
| 28164 | | /* end confdefs.h. */ |
| 28165 | | #include <stddef.h> |
| 28166 | | extern size_t foo; |
| 28167 | | extern unsigned long foo; |
| 28168 | | |
| 28169 | | int |
| 28170 | | main () |
| 28171 | | { |
| 28172 | | |
| 28173 | | ; |
| 28174 | | return 0; |
| 28175 | | } |
| 28176 | | _ACEOF |
| 28177 | | rm -f conftest.$ac_objext |
| 28178 | | if { (ac_try="$ac_compile" |
| 28179 | | case "(($ac_try" in |
| 28180 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 28181 | | *) ac_try_echo=$ac_try;; |
| 28182 | | esac |
| 28183 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 28184 | | (eval "$ac_compile") 2>conftest.er1 |
| 28185 | | ac_status=$? |
| 28186 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 28187 | | rm -f conftest.er1 |
| 28188 | | cat conftest.err >&5 |
| 28189 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 28190 | | (exit $ac_status); } && { |
| 28191 | | test -z "$ac_c_werror_flag" || |
| 28192 | | test ! -s conftest.err |
| 28193 | | } && test -s conftest.$ac_objext; then |
| 28194 | | fits_in_uint=0 |
| 28195 | | else |
| 28196 | | echo "$as_me: failed program was:" >&5 |
| 28197 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 28198 | | |
| 28199 | | |
| 28200 | | fi |
| 28201 | | |
| 28202 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 28203 | | fi |
| 28204 | | if test $fits_in_uint = 1; then |
| 28205 | | result="(((1U << $size_t_bits_minus_1) - 1) * 2 + 1)" |
| 28206 | | else |
| 28207 | | result="(((1UL << $size_t_bits_minus_1) - 1) * 2 + 1)" |
| 28208 | | fi |
| 28209 | | else |
| 28210 | | result='((size_t)~(size_t)0)' |
| 28211 | | fi |
| 28212 | | fi |
| 28213 | | { echo "$as_me:$LINENO: result: $result" >&5 |
| 28214 | | echo "${ECHO_T}$result" >&6; } |
| 28215 | | if test "$result" != yes; then |
| 28216 | | |
| 28217 | | cat >>confdefs.h <<_ACEOF |
| 28218 | | #define SIZE_MAX $result |
| 28219 | | _ACEOF |
| 28220 | | |
| 28221 | | fi |
| 28222 | | |
| 28223 | | |
| 28224 | | |
| 28225 | | |
| 28226 | | |
| 28227 | | for ac_header in stdint.h |
| 28228 | | do |
| 28229 | | as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` |
| 28230 | | if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then |
| 28231 | | { echo "$as_me:$LINENO: checking for $ac_header" >&5 |
| 28232 | | echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } |
| 28233 | | if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then |
| 28234 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 28235 | | fi |
| 28236 | | ac_res=`eval echo '${'$as_ac_Header'}'` |
| 28237 | | { echo "$as_me:$LINENO: result: $ac_res" >&5 |
| 28238 | | echo "${ECHO_T}$ac_res" >&6; } |
| 28239 | | else |
| 28240 | | # Is the header compilable? |
| 28241 | | { echo "$as_me:$LINENO: checking $ac_header usability" >&5 |
| 28242 | | echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; } |
| 28243 | | cat >conftest.$ac_ext <<_ACEOF |
| 28244 | | /* confdefs.h. */ |
| 28245 | | _ACEOF |
| 28246 | | cat confdefs.h >>conftest.$ac_ext |
| 28247 | | cat >>conftest.$ac_ext <<_ACEOF |
| 28248 | | /* end confdefs.h. */ |
| 28249 | | $ac_includes_default |
| 28250 | | #include <$ac_header> |
| 28251 | | _ACEOF |
| 28252 | | rm -f conftest.$ac_objext |
| 28253 | | if { (ac_try="$ac_compile" |
| 28254 | | case "(($ac_try" in |
| 28255 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 28256 | | *) ac_try_echo=$ac_try;; |
| 28257 | | esac |
| 28258 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 28259 | | (eval "$ac_compile") 2>conftest.er1 |
| 28260 | | ac_status=$? |
| 28261 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 28262 | | rm -f conftest.er1 |
| 28263 | | cat conftest.err >&5 |
| 28264 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 28265 | | (exit $ac_status); } && { |
| 28266 | | test -z "$ac_c_werror_flag" || |
| 28267 | | test ! -s conftest.err |
| 28268 | | } && test -s conftest.$ac_objext; then |
| 28269 | | ac_header_compiler=yes |
| 28270 | | else |
| 28271 | | echo "$as_me: failed program was:" >&5 |
| 28272 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 28273 | | |
| 28274 | | ac_header_compiler=no |
| 28275 | | fi |
| 28276 | | |
| 28277 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 28278 | | { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 |
| 28279 | | echo "${ECHO_T}$ac_header_compiler" >&6; } |
| 28280 | | |
| 28281 | | # Is the header present? |
| 28282 | | { echo "$as_me:$LINENO: checking $ac_header presence" >&5 |
| 28283 | | echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; } |
| 28284 | | cat >conftest.$ac_ext <<_ACEOF |
| 28285 | | /* confdefs.h. */ |
| 28286 | | _ACEOF |
| 28287 | | cat confdefs.h >>conftest.$ac_ext |
| 28288 | | cat >>conftest.$ac_ext <<_ACEOF |
| 28289 | | /* end confdefs.h. */ |
| 28290 | | #include <$ac_header> |
| 28291 | | _ACEOF |
| 28292 | | if { (ac_try="$ac_cpp conftest.$ac_ext" |
| 28293 | | case "(($ac_try" in |
| 28294 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 28295 | | *) ac_try_echo=$ac_try;; |
| 28296 | | esac |
| 28297 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 28298 | | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 |
| 28299 | | ac_status=$? |
| 28300 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 28301 | | rm -f conftest.er1 |
| 28302 | | cat conftest.err >&5 |
| 28303 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 28304 | | (exit $ac_status); } >/dev/null && { |
| 28305 | | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| 28306 | | test ! -s conftest.err |
| 28307 | | }; then |
| 28308 | | ac_header_preproc=yes |
| 28309 | | else |
| 28310 | | echo "$as_me: failed program was:" >&5 |
| 28311 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 28312 | | |
| 28313 | | ac_header_preproc=no |
| 28314 | | fi |
| 28315 | | |
| 28316 | | rm -f conftest.err conftest.$ac_ext |
| 28317 | | { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 |
| 28318 | | echo "${ECHO_T}$ac_header_preproc" >&6; } |
| 28319 | | |
| 28320 | | # So? What about this header? |
| 28321 | | case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in |
| 28322 | | yes:no: ) |
| 28323 | | { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 |
| 28324 | | echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} |
| 28325 | | { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5 |
| 28326 | | echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;} |
| 28327 | | ac_header_preproc=yes |
| 28328 | | ;; |
| 28329 | | no:yes:* ) |
| 28330 | | { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 |
| 28331 | | echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} |
| 28332 | | { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 |
| 28333 | | echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} |
| 28334 | | { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5 |
| 28335 | | echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;} |
| 28336 | | { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5 |
| 28337 | | echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;} |
| 28338 | | { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 |
| 28339 | | echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} |
| 28340 | | { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5 |
| 28341 | | echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;} |
| 28342 | | |
| 28343 | | ;; |
| 28344 | | esac |
| 28345 | | { echo "$as_me:$LINENO: checking for $ac_header" >&5 |
| 28346 | | echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } |
| 28347 | | if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then |
| 28348 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 28349 | | else |
| 28350 | | eval "$as_ac_Header=\$ac_header_preproc" |
| 28351 | | fi |
| 28352 | | ac_res=`eval echo '${'$as_ac_Header'}'` |
| 28353 | | { echo "$as_me:$LINENO: result: $ac_res" >&5 |
| 28354 | | echo "${ECHO_T}$ac_res" >&6; } |
| 28355 | | |
| 28356 | | fi |
| 28357 | | if test `eval echo '${'$as_ac_Header'}'` = yes; then |
| 28358 | | cat >>confdefs.h <<_ACEOF |
| 28359 | | #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 |
| 28360 | | _ACEOF |
| 28361 | | |
| 28362 | | fi |
| 28363 | | |
| 28364 | | done |
| 28365 | | |
| 28366 | | |
| 28367 | | |
| 28368 | | { echo "$as_me:$LINENO: checking for CFPreferencesCopyAppValue" >&5 |
| 28369 | | echo $ECHO_N "checking for CFPreferencesCopyAppValue... $ECHO_C" >&6; } |
| 28370 | | if test "${gt_cv_func_CFPreferencesCopyAppValue+set}" = set; then |
| 28371 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 28372 | | else |
| 28373 | | gt_save_LIBS="$LIBS" |
| 28374 | | LIBS="$LIBS -Wl,-framework -Wl,CoreFoundation" |
| 28375 | | cat >conftest.$ac_ext <<_ACEOF |
| 28376 | | /* confdefs.h. */ |
| 28377 | | _ACEOF |
| 28378 | | cat confdefs.h >>conftest.$ac_ext |
| 28379 | | cat >>conftest.$ac_ext <<_ACEOF |
| 28380 | | /* end confdefs.h. */ |
| 28381 | | #include <CoreFoundation/CFPreferences.h> |
| 28382 | | int |
| 28383 | | main () |
| 28384 | | { |
| 28385 | | CFPreferencesCopyAppValue(NULL, NULL) |
| 28386 | | ; |
| 28387 | | return 0; |
| 28388 | | } |
| 28389 | | _ACEOF |
| 28390 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 28391 | | if { (ac_try="$ac_link" |
| 28392 | | case "(($ac_try" in |
| 28393 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 28394 | | *) ac_try_echo=$ac_try;; |
| 28395 | | esac |
| 28396 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 28397 | | (eval "$ac_link") 2>conftest.er1 |
| 28398 | | ac_status=$? |
| 28399 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 28400 | | rm -f conftest.er1 |
| 28401 | | cat conftest.err >&5 |
| 28402 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 28403 | | (exit $ac_status); } && { |
| 28404 | | test -z "$ac_c_werror_flag" || |
| 28405 | | test ! -s conftest.err |
| 28406 | | } && test -s conftest$ac_exeext && |
| 28407 | | $as_test_x conftest$ac_exeext; then |
| 28408 | | gt_cv_func_CFPreferencesCopyAppValue=yes |
| 28409 | | else |
| 28410 | | echo "$as_me: failed program was:" >&5 |
| 28411 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 28412 | | |
| 28413 | | gt_cv_func_CFPreferencesCopyAppValue=no |
| 28414 | | fi |
| 28415 | | |
| 28416 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 28417 | | conftest$ac_exeext conftest.$ac_ext |
| 28418 | | LIBS="$gt_save_LIBS" |
| 28419 | | fi |
| 28420 | | { echo "$as_me:$LINENO: result: $gt_cv_func_CFPreferencesCopyAppValue" >&5 |
| 28421 | | echo "${ECHO_T}$gt_cv_func_CFPreferencesCopyAppValue" >&6; } |
| 28422 | | if test $gt_cv_func_CFPreferencesCopyAppValue = yes; then |
| 28423 | | |
| 28424 | | cat >>confdefs.h <<\_ACEOF |
| 28425 | | #define HAVE_CFPREFERENCESCOPYAPPVALUE 1 |
| 28426 | | _ACEOF |
| 28427 | | |
| 28428 | | fi |
| 28429 | | { echo "$as_me:$LINENO: checking for CFLocaleCopyCurrent" >&5 |
| 28430 | | echo $ECHO_N "checking for CFLocaleCopyCurrent... $ECHO_C" >&6; } |
| 28431 | | if test "${gt_cv_func_CFLocaleCopyCurrent+set}" = set; then |
| 28432 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 28433 | | else |
| 28434 | | gt_save_LIBS="$LIBS" |
| 28435 | | LIBS="$LIBS -Wl,-framework -Wl,CoreFoundation" |
| 28436 | | cat >conftest.$ac_ext <<_ACEOF |
| 28437 | | /* confdefs.h. */ |
| 28438 | | _ACEOF |
| 28439 | | cat confdefs.h >>conftest.$ac_ext |
| 28440 | | cat >>conftest.$ac_ext <<_ACEOF |
| 28441 | | /* end confdefs.h. */ |
| 28442 | | #include <CoreFoundation/CFLocale.h> |
| 28443 | | int |
| 28444 | | main () |
| 28445 | | { |
| 28446 | | CFLocaleCopyCurrent(); |
| 28447 | | ; |
| 28448 | | return 0; |
| 28449 | | } |
| 28450 | | _ACEOF |
| 28451 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 28452 | | if { (ac_try="$ac_link" |
| 28453 | | case "(($ac_try" in |
| 28454 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 28455 | | *) ac_try_echo=$ac_try;; |
| 28456 | | esac |
| 28457 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 28458 | | (eval "$ac_link") 2>conftest.er1 |
| 28459 | | ac_status=$? |
| 28460 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 28461 | | rm -f conftest.er1 |
| 28462 | | cat conftest.err >&5 |
| 28463 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 28464 | | (exit $ac_status); } && { |
| 28465 | | test -z "$ac_c_werror_flag" || |
| 28466 | | test ! -s conftest.err |
| 28467 | | } && test -s conftest$ac_exeext && |
| 28468 | | $as_test_x conftest$ac_exeext; then |
| 28469 | | gt_cv_func_CFLocaleCopyCurrent=yes |
| 28470 | | else |
| 28471 | | echo "$as_me: failed program was:" >&5 |
| 28472 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 28473 | | |
| 28474 | | gt_cv_func_CFLocaleCopyCurrent=no |
| 28475 | | fi |
| 28476 | | |
| 28477 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 28478 | | conftest$ac_exeext conftest.$ac_ext |
| 28479 | | LIBS="$gt_save_LIBS" |
| 28480 | | fi |
| 28481 | | { echo "$as_me:$LINENO: result: $gt_cv_func_CFLocaleCopyCurrent" >&5 |
| 28482 | | echo "${ECHO_T}$gt_cv_func_CFLocaleCopyCurrent" >&6; } |
| 28483 | | if test $gt_cv_func_CFLocaleCopyCurrent = yes; then |
| 28484 | | |
| 28485 | | cat >>confdefs.h <<\_ACEOF |
| 28486 | | #define HAVE_CFLOCALECOPYCURRENT 1 |
| 28487 | | _ACEOF |
| 28488 | | |
| 28489 | | fi |
| 28490 | | INTL_MACOSX_LIBS= |
| 28491 | | if test $gt_cv_func_CFPreferencesCopyAppValue = yes || test $gt_cv_func_CFLocaleCopyCurrent = yes; then |
| 28492 | | INTL_MACOSX_LIBS="-Wl,-framework -Wl,CoreFoundation" |
| 28493 | | fi |
| 28494 | | |
| 28495 | | |
| 28496 | | |
| 28497 | | |
| 28498 | | |
| 28499 | | |
| 28500 | | |
| 28501 | | { echo "$as_me:$LINENO: checking for ptrdiff_t" >&5 |
| 28502 | | echo $ECHO_N "checking for ptrdiff_t... $ECHO_C" >&6; } |
| 28503 | | if test "${ac_cv_type_ptrdiff_t+set}" = set; then |
| 28504 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 28505 | | else |
| 28506 | | cat >conftest.$ac_ext <<_ACEOF |
| 28507 | | /* confdefs.h. */ |
| 28508 | | _ACEOF |
| 28509 | | cat confdefs.h >>conftest.$ac_ext |
| 28510 | | cat >>conftest.$ac_ext <<_ACEOF |
| 28511 | | /* end confdefs.h. */ |
| 28512 | | $ac_includes_default |
| 28513 | | typedef ptrdiff_t ac__type_new_; |
| 28514 | | int |
| 28515 | | main () |
| 28516 | | { |
| 28517 | | if ((ac__type_new_ *) 0) |
| 28518 | | return 0; |
| 28519 | | if (sizeof (ac__type_new_)) |
| 28520 | | return 0; |
| 28521 | | ; |
| 28522 | | return 0; |
| 28523 | | } |
| 28524 | | _ACEOF |
| 28525 | | rm -f conftest.$ac_objext |
| 28526 | | if { (ac_try="$ac_compile" |
| 28527 | | case "(($ac_try" in |
| 28528 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 28529 | | *) ac_try_echo=$ac_try;; |
| 28530 | | esac |
| 28531 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 28532 | | (eval "$ac_compile") 2>conftest.er1 |
| 28533 | | ac_status=$? |
| 28534 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 28535 | | rm -f conftest.er1 |
| 28536 | | cat conftest.err >&5 |
| 28537 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 28538 | | (exit $ac_status); } && { |
| 28539 | | test -z "$ac_c_werror_flag" || |
| 28540 | | test ! -s conftest.err |
| 28541 | | } && test -s conftest.$ac_objext; then |
| 28542 | | ac_cv_type_ptrdiff_t=yes |
| 28543 | | else |
| 28544 | | echo "$as_me: failed program was:" >&5 |
| 28545 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 28546 | | |
| 28547 | | ac_cv_type_ptrdiff_t=no |
| 28548 | | fi |
| 28549 | | |
| 28550 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 28551 | | fi |
| 28552 | | { echo "$as_me:$LINENO: result: $ac_cv_type_ptrdiff_t" >&5 |
| 28553 | | echo "${ECHO_T}$ac_cv_type_ptrdiff_t" >&6; } |
| 28554 | | if test $ac_cv_type_ptrdiff_t = yes; then |
| 28555 | | : |
| 28556 | | else |
| 28557 | | |
| 28558 | | cat >>confdefs.h <<\_ACEOF |
| 28559 | | #define ptrdiff_t long |
| 28560 | | _ACEOF |
| 28561 | | |
| 28562 | | |
| 28563 | | fi |
| 28564 | | |
| 28565 | | |
| 28566 | | |
| 28567 | | |
| 28568 | | for ac_header in stddef.h stdlib.h string.h |
| 28569 | | do |
| 28570 | | as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` |
| 28571 | | if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then |
| 28572 | | { echo "$as_me:$LINENO: checking for $ac_header" >&5 |
| 28573 | | echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } |
| 28574 | | if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then |
| 28575 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 28576 | | fi |
| 28577 | | ac_res=`eval echo '${'$as_ac_Header'}'` |
| 28578 | | { echo "$as_me:$LINENO: result: $ac_res" >&5 |
| 28579 | | echo "${ECHO_T}$ac_res" >&6; } |
| 28580 | | else |
| 28581 | | # Is the header compilable? |
| 28582 | | { echo "$as_me:$LINENO: checking $ac_header usability" >&5 |
| 28583 | | echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; } |
| 28584 | | cat >conftest.$ac_ext <<_ACEOF |
| 28585 | | /* confdefs.h. */ |
| 28586 | | _ACEOF |
| 28587 | | cat confdefs.h >>conftest.$ac_ext |
| 28588 | | cat >>conftest.$ac_ext <<_ACEOF |
| 28589 | | /* end confdefs.h. */ |
| 28590 | | $ac_includes_default |
| 28591 | | #include <$ac_header> |
| 28592 | | _ACEOF |
| 28593 | | rm -f conftest.$ac_objext |
| 28594 | | if { (ac_try="$ac_compile" |
| 28595 | | case "(($ac_try" in |
| 28596 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 28597 | | *) ac_try_echo=$ac_try;; |
| 28598 | | esac |
| 28599 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 28600 | | (eval "$ac_compile") 2>conftest.er1 |
| 28601 | | ac_status=$? |
| 28602 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 28603 | | rm -f conftest.er1 |
| 28604 | | cat conftest.err >&5 |
| 28605 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 28606 | | (exit $ac_status); } && { |
| 28607 | | test -z "$ac_c_werror_flag" || |
| 28608 | | test ! -s conftest.err |
| 28609 | | } && test -s conftest.$ac_objext; then |
| 28610 | | ac_header_compiler=yes |
| 28611 | | else |
| 28612 | | echo "$as_me: failed program was:" >&5 |
| 28613 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 28614 | | |
| 28615 | | ac_header_compiler=no |
| 28616 | | fi |
| 28617 | | |
| 28618 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 28619 | | { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 |
| 28620 | | echo "${ECHO_T}$ac_header_compiler" >&6; } |
| 28621 | | |
| 28622 | | # Is the header present? |
| 28623 | | { echo "$as_me:$LINENO: checking $ac_header presence" >&5 |
| 28624 | | echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; } |
| 28625 | | cat >conftest.$ac_ext <<_ACEOF |
| 28626 | | /* confdefs.h. */ |
| 28627 | | _ACEOF |
| 28628 | | cat confdefs.h >>conftest.$ac_ext |
| 28629 | | cat >>conftest.$ac_ext <<_ACEOF |
| 28630 | | /* end confdefs.h. */ |
| 28631 | | #include <$ac_header> |
| 28632 | | _ACEOF |
| 28633 | | if { (ac_try="$ac_cpp conftest.$ac_ext" |
| 28634 | | case "(($ac_try" in |
| 28635 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 28636 | | *) ac_try_echo=$ac_try;; |
| 28637 | | esac |
| 28638 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 28639 | | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 |
| 28640 | | ac_status=$? |
| 28641 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 28642 | | rm -f conftest.er1 |
| 28643 | | cat conftest.err >&5 |
| 28644 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 28645 | | (exit $ac_status); } >/dev/null && { |
| 28646 | | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| 28647 | | test ! -s conftest.err |
| 28648 | | }; then |
| 28649 | | ac_header_preproc=yes |
| 28650 | | else |
| 28651 | | echo "$as_me: failed program was:" >&5 |
| 28652 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 28653 | | |
| 28654 | | ac_header_preproc=no |
| 28655 | | fi |
| 28656 | | |
| 28657 | | rm -f conftest.err conftest.$ac_ext |
| 28658 | | { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 |
| 28659 | | echo "${ECHO_T}$ac_header_preproc" >&6; } |
| 28660 | | |
| 28661 | | # So? What about this header? |
| 28662 | | case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in |
| 28663 | | yes:no: ) |
| 28664 | | { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 |
| 28665 | | echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} |
| 28666 | | { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5 |
| 28667 | | echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;} |
| 28668 | | ac_header_preproc=yes |
| 28669 | | ;; |
| 28670 | | no:yes:* ) |
| 28671 | | { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 |
| 28672 | | echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} |
| 28673 | | { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 |
| 28674 | | echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} |
| 28675 | | { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5 |
| 28676 | | echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;} |
| 28677 | | { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5 |
| 28678 | | echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;} |
| 28679 | | { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 |
| 28680 | | echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} |
| 28681 | | { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5 |
| 28682 | | echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;} |
| 28683 | | |
| 28684 | | ;; |
| 28685 | | esac |
| 28686 | | { echo "$as_me:$LINENO: checking for $ac_header" >&5 |
| 28687 | | echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } |
| 28688 | | if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then |
| 28689 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 28690 | | else |
| 28691 | | eval "$as_ac_Header=\$ac_header_preproc" |
| 28692 | | fi |
| 28693 | | ac_res=`eval echo '${'$as_ac_Header'}'` |
| 28694 | | { echo "$as_me:$LINENO: result: $ac_res" >&5 |
| 28695 | | echo "${ECHO_T}$ac_res" >&6; } |
| 28696 | | |
| 28697 | | fi |
| 28698 | | if test `eval echo '${'$as_ac_Header'}'` = yes; then |
| 28699 | | cat >>confdefs.h <<_ACEOF |
| 28700 | | #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 |
| 28701 | | _ACEOF |
| 28702 | | |
| 28703 | | fi |
| 28704 | | |
| 28705 | | done |
| 28706 | | |
| 28707 | | |
| 28708 | | |
| 28709 | | |
| 28710 | | |
| 28711 | | |
| 28712 | | |
| 28713 | | |
| 28714 | | for ac_func in asprintf fwprintf putenv setenv setlocale snprintf wcslen |
| 28715 | | do |
| 28716 | | as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` |
| 28717 | | { echo "$as_me:$LINENO: checking for $ac_func" >&5 |
| 28718 | | echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; } |
| 28719 | | if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then |
| 28720 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 28721 | | else |
| 28722 | | cat >conftest.$ac_ext <<_ACEOF |
| 28723 | | /* confdefs.h. */ |
| 28724 | | _ACEOF |
| 28725 | | cat confdefs.h >>conftest.$ac_ext |
| 28726 | | cat >>conftest.$ac_ext <<_ACEOF |
| 28727 | | /* end confdefs.h. */ |
| 28728 | | /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func. |
| 28729 | | For example, HP-UX 11i <limits.h> declares gettimeofday. */ |
| 28730 | | #define $ac_func innocuous_$ac_func |
| 28731 | | |
| 28732 | | /* System header to define __stub macros and hopefully few prototypes, |
| 28733 | | which can conflict with char $ac_func (); below. |
| 28734 | | Prefer <limits.h> to <assert.h> if __STDC__ is defined, since |
| 28735 | | <limits.h> exists even on freestanding compilers. */ |
| 28736 | | |
| 28737 | | #ifdef __STDC__ |
| 28738 | | # include <limits.h> |
| 28739 | | #else |
| 28740 | | # include <assert.h> |
| 28741 | | #endif |
| 28742 | | |
| 28743 | | #undef $ac_func |
| 28744 | | |
| 28745 | | /* Override any GCC internal prototype to avoid an error. |
| 28746 | | Use char because int might match the return type of a GCC |
| 28747 | | builtin and then its argument prototype would still apply. */ |
| 28748 | | #ifdef __cplusplus |
| 28749 | | extern "C" |
| 28750 | | #endif |
| 28751 | | char $ac_func (); |
| 28752 | | /* The GNU C library defines this for functions which it implements |
| 28753 | | to always fail with ENOSYS. Some functions are actually named |
| 28754 | | something starting with __ and the normal name is an alias. */ |
| 28755 | | #if defined __stub_$ac_func || defined __stub___$ac_func |
| 28756 | | choke me |
| 28757 | | #endif |
| 28758 | | |
| 28759 | | int |
| 28760 | | main () |
| 28761 | | { |
| 28762 | | return $ac_func (); |
| 28763 | | ; |
| 28764 | | return 0; |
| 28765 | | } |
| 28766 | | _ACEOF |
| 28767 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 28768 | | if { (ac_try="$ac_link" |
| 28769 | | case "(($ac_try" in |
| 28770 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 28771 | | *) ac_try_echo=$ac_try;; |
| 28772 | | esac |
| 28773 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 28774 | | (eval "$ac_link") 2>conftest.er1 |
| 28775 | | ac_status=$? |
| 28776 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 28777 | | rm -f conftest.er1 |
| 28778 | | cat conftest.err >&5 |
| 28779 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 28780 | | (exit $ac_status); } && { |
| 28781 | | test -z "$ac_c_werror_flag" || |
| 28782 | | test ! -s conftest.err |
| 28783 | | } && test -s conftest$ac_exeext && |
| 28784 | | $as_test_x conftest$ac_exeext; then |
| 28785 | | eval "$as_ac_var=yes" |
| 28786 | | else |
| 28787 | | echo "$as_me: failed program was:" >&5 |
| 28788 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 28789 | | |
| 28790 | | eval "$as_ac_var=no" |
| 28791 | | fi |
| 28792 | | |
| 28793 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 28794 | | conftest$ac_exeext conftest.$ac_ext |
| 28795 | | fi |
| 28796 | | ac_res=`eval echo '${'$as_ac_var'}'` |
| 28797 | | { echo "$as_me:$LINENO: result: $ac_res" >&5 |
| 28798 | | echo "${ECHO_T}$ac_res" >&6; } |
| 28799 | | if test `eval echo '${'$as_ac_var'}'` = yes; then |
| 28800 | | cat >>confdefs.h <<_ACEOF |
| 28801 | | #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1 |
| 28802 | | _ACEOF |
| 28803 | | |
| 28804 | | fi |
| 28805 | | done |
| 28806 | | |
| 28807 | | |
| 28808 | | |
| 28809 | | { echo "$as_me:$LINENO: checking whether _snprintf is declared" >&5 |
| 28810 | | echo $ECHO_N "checking whether _snprintf is declared... $ECHO_C" >&6; } |
| 28811 | | if test "${ac_cv_have_decl__snprintf+set}" = set; then |
| 28812 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 28813 | | else |
| 28814 | | cat >conftest.$ac_ext <<_ACEOF |
| 28815 | | /* confdefs.h. */ |
| 28816 | | _ACEOF |
| 28817 | | cat confdefs.h >>conftest.$ac_ext |
| 28818 | | cat >>conftest.$ac_ext <<_ACEOF |
| 28819 | | /* end confdefs.h. */ |
| 28820 | | #include <stdio.h> |
| 28821 | | int |
| 28822 | | main () |
| 28823 | | { |
| 28824 | | |
| 28825 | | #ifndef _snprintf |
| 28826 | | char *p = (char *) _snprintf; |
| 28827 | | #endif |
| 28828 | | |
| 28829 | | ; |
| 28830 | | return 0; |
| 28831 | | } |
| 28832 | | _ACEOF |
| 28833 | | rm -f conftest.$ac_objext |
| 28834 | | if { (ac_try="$ac_compile" |
| 28835 | | case "(($ac_try" in |
| 28836 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 28837 | | *) ac_try_echo=$ac_try;; |
| 28838 | | esac |
| 28839 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 28840 | | (eval "$ac_compile") 2>conftest.er1 |
| 28841 | | ac_status=$? |
| 28842 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 28843 | | rm -f conftest.er1 |
| 28844 | | cat conftest.err >&5 |
| 28845 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 28846 | | (exit $ac_status); } && { |
| 28847 | | test -z "$ac_c_werror_flag" || |
| 28848 | | test ! -s conftest.err |
| 28849 | | } && test -s conftest.$ac_objext; then |
| 28850 | | ac_cv_have_decl__snprintf=yes |
| 28851 | | else |
| 28852 | | echo "$as_me: failed program was:" >&5 |
| 28853 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 28854 | | |
| 28855 | | ac_cv_have_decl__snprintf=no |
| 28856 | | fi |
| 28857 | | |
| 28858 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 28859 | | fi |
| 28860 | | { echo "$as_me:$LINENO: result: $ac_cv_have_decl__snprintf" >&5 |
| 28861 | | echo "${ECHO_T}$ac_cv_have_decl__snprintf" >&6; } |
| 28862 | | if test $ac_cv_have_decl__snprintf = yes; then |
| 28863 | | gt_value=1 |
| 28864 | | else |
| 28865 | | gt_value=0 |
| 28866 | | fi |
| 28867 | | |
| 28868 | | cat >>confdefs.h <<_ACEOF |
| 28869 | | #define HAVE_DECL__SNPRINTF $gt_value |
| 28870 | | _ACEOF |
| 28871 | | |
| 28872 | | |
| 28873 | | |
| 28874 | | { echo "$as_me:$LINENO: checking whether _snwprintf is declared" >&5 |
| 28875 | | echo $ECHO_N "checking whether _snwprintf is declared... $ECHO_C" >&6; } |
| 28876 | | if test "${ac_cv_have_decl__snwprintf+set}" = set; then |
| 28877 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 28878 | | else |
| 28879 | | cat >conftest.$ac_ext <<_ACEOF |
| 28880 | | /* confdefs.h. */ |
| 28881 | | _ACEOF |
| 28882 | | cat confdefs.h >>conftest.$ac_ext |
| 28883 | | cat >>conftest.$ac_ext <<_ACEOF |
| 28884 | | /* end confdefs.h. */ |
| 28885 | | #include <stdio.h> |
| 28886 | | int |
| 28887 | | main () |
| 28888 | | { |
| 28889 | | |
| 28890 | | #ifndef _snwprintf |
| 28891 | | char *p = (char *) _snwprintf; |
| 28892 | | #endif |
| 28893 | | |
| 28894 | | ; |
| 28895 | | return 0; |
| 28896 | | } |
| 28897 | | _ACEOF |
| 28898 | | rm -f conftest.$ac_objext |
| 28899 | | if { (ac_try="$ac_compile" |
| 28900 | | case "(($ac_try" in |
| 28901 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 28902 | | *) ac_try_echo=$ac_try;; |
| 28903 | | esac |
| 28904 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 28905 | | (eval "$ac_compile") 2>conftest.er1 |
| 28906 | | ac_status=$? |
| 28907 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 28908 | | rm -f conftest.er1 |
| 28909 | | cat conftest.err >&5 |
| 28910 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 28911 | | (exit $ac_status); } && { |
| 28912 | | test -z "$ac_c_werror_flag" || |
| 28913 | | test ! -s conftest.err |
| 28914 | | } && test -s conftest.$ac_objext; then |
| 28915 | | ac_cv_have_decl__snwprintf=yes |
| 28916 | | else |
| 28917 | | echo "$as_me: failed program was:" >&5 |
| 28918 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 28919 | | |
| 28920 | | ac_cv_have_decl__snwprintf=no |
| 28921 | | fi |
| 28922 | | |
| 28923 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 28924 | | fi |
| 28925 | | { echo "$as_me:$LINENO: result: $ac_cv_have_decl__snwprintf" >&5 |
| 28926 | | echo "${ECHO_T}$ac_cv_have_decl__snwprintf" >&6; } |
| 28927 | | if test $ac_cv_have_decl__snwprintf = yes; then |
| 28928 | | gt_value=1 |
| 28929 | | else |
| 28930 | | gt_value=0 |
| 28931 | | fi |
| 28932 | | |
| 28933 | | cat >>confdefs.h <<_ACEOF |
| 28934 | | #define HAVE_DECL__SNWPRINTF $gt_value |
| 28935 | | _ACEOF |
| 28936 | | |
| 28937 | | |
| 28938 | | |
| 28939 | | |
| 28940 | | { echo "$as_me:$LINENO: checking whether getc_unlocked is declared" >&5 |
| 28941 | | echo $ECHO_N "checking whether getc_unlocked is declared... $ECHO_C" >&6; } |
| 28942 | | if test "${ac_cv_have_decl_getc_unlocked+set}" = set; then |
| 28943 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 28944 | | else |
| 28945 | | cat >conftest.$ac_ext <<_ACEOF |
| 28946 | | /* confdefs.h. */ |
| 28947 | | _ACEOF |
| 28948 | | cat confdefs.h >>conftest.$ac_ext |
| 28949 | | cat >>conftest.$ac_ext <<_ACEOF |
| 28950 | | /* end confdefs.h. */ |
| 28951 | | #include <stdio.h> |
| 28952 | | int |
| 28953 | | main () |
| 28954 | | { |
| 28955 | | |
| 28956 | | #ifndef getc_unlocked |
| 28957 | | char *p = (char *) getc_unlocked; |
| 28958 | | #endif |
| 28959 | | |
| 28960 | | ; |
| 28961 | | return 0; |
| 28962 | | } |
| 28963 | | _ACEOF |
| 28964 | | rm -f conftest.$ac_objext |
| 28965 | | if { (ac_try="$ac_compile" |
| 28966 | | case "(($ac_try" in |
| 28967 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 28968 | | *) ac_try_echo=$ac_try;; |
| 28969 | | esac |
| 28970 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 28971 | | (eval "$ac_compile") 2>conftest.er1 |
| 28972 | | ac_status=$? |
| 28973 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 28974 | | rm -f conftest.er1 |
| 28975 | | cat conftest.err >&5 |
| 28976 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 28977 | | (exit $ac_status); } && { |
| 28978 | | test -z "$ac_c_werror_flag" || |
| 28979 | | test ! -s conftest.err |
| 28980 | | } && test -s conftest.$ac_objext; then |
| 28981 | | ac_cv_have_decl_getc_unlocked=yes |
| 28982 | | else |
| 28983 | | echo "$as_me: failed program was:" >&5 |
| 28984 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 28985 | | |
| 28986 | | ac_cv_have_decl_getc_unlocked=no |
| 28987 | | fi |
| 28988 | | |
| 28989 | | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| 28990 | | fi |
| 28991 | | { echo "$as_me:$LINENO: result: $ac_cv_have_decl_getc_unlocked" >&5 |
| 28992 | | echo "${ECHO_T}$ac_cv_have_decl_getc_unlocked" >&6; } |
| 28993 | | if test $ac_cv_have_decl_getc_unlocked = yes; then |
| 28994 | | gt_value=1 |
| 28995 | | else |
| 28996 | | gt_value=0 |
| 28997 | | fi |
| 28998 | | |
| 28999 | | cat >>confdefs.h <<_ACEOF |
| 29000 | | #define HAVE_DECL_GETC_UNLOCKED $gt_value |
| 29001 | | _ACEOF |
| 29002 | | |
| 29003 | | |
| 29004 | | |
| 29005 | | case $gt_cv_func_printf_posix in |
| 29006 | | *yes) HAVE_POSIX_PRINTF=1 ;; |
| 29007 | | *) HAVE_POSIX_PRINTF=0 ;; |
| 29008 | | esac |
| 29009 | | |
| 29010 | | if test "$ac_cv_func_asprintf" = yes; then |
| 29011 | | HAVE_ASPRINTF=1 |
| 29012 | | else |
| 29013 | | HAVE_ASPRINTF=0 |
| 29014 | | fi |
| 29015 | | |
| 29016 | | if test "$ac_cv_func_snprintf" = yes; then |
| 29017 | | HAVE_SNPRINTF=1 |
| 29018 | | else |
| 29019 | | HAVE_SNPRINTF=0 |
| 29020 | | fi |
| 29021 | | |
| 29022 | | if test "$ac_cv_func_wprintf" = yes; then |
| 29023 | | HAVE_WPRINTF=1 |
| 29024 | | else |
| 29025 | | HAVE_WPRINTF=0 |
| 29026 | | fi |
| 29027 | | |
| 29028 | | |
| 29029 | | |
| 29030 | | { echo "$as_me:$LINENO: checking for nl_langinfo and CODESET" >&5 |
| 29031 | | echo $ECHO_N "checking for nl_langinfo and CODESET... $ECHO_C" >&6; } |
| 29032 | | if test "${am_cv_langinfo_codeset+set}" = set; then |
| 29033 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 29034 | | else |
| 29035 | | cat >conftest.$ac_ext <<_ACEOF |
| 29036 | | /* confdefs.h. */ |
| 29037 | | _ACEOF |
| 29038 | | cat confdefs.h >>conftest.$ac_ext |
| 29039 | | cat >>conftest.$ac_ext <<_ACEOF |
| 29040 | | /* end confdefs.h. */ |
| 29041 | | #include <langinfo.h> |
| 29042 | | int |
| 29043 | | main () |
| 29044 | | { |
| 29045 | | char* cs = nl_langinfo(CODESET); |
| 29046 | | ; |
| 29047 | | return 0; |
| 29048 | | } |
| 29049 | | _ACEOF |
| 29050 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 29051 | | if { (ac_try="$ac_link" |
| 29052 | | case "(($ac_try" in |
| 29053 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 29054 | | *) ac_try_echo=$ac_try;; |
| 29055 | | esac |
| 29056 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 29057 | | (eval "$ac_link") 2>conftest.er1 |
| 29058 | | ac_status=$? |
| 29059 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 29060 | | rm -f conftest.er1 |
| 29061 | | cat conftest.err >&5 |
| 29062 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 29063 | | (exit $ac_status); } && { |
| 29064 | | test -z "$ac_c_werror_flag" || |
| 29065 | | test ! -s conftest.err |
| 29066 | | } && test -s conftest$ac_exeext && |
| 29067 | | $as_test_x conftest$ac_exeext; then |
| 29068 | | am_cv_langinfo_codeset=yes |
| 29069 | | else |
| 29070 | | echo "$as_me: failed program was:" >&5 |
| 29071 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 29072 | | |
| 29073 | | am_cv_langinfo_codeset=no |
| 29074 | | fi |
| 29075 | | |
| 29076 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 29077 | | conftest$ac_exeext conftest.$ac_ext |
| 29078 | | |
| 29079 | | fi |
| 29080 | | { echo "$as_me:$LINENO: result: $am_cv_langinfo_codeset" >&5 |
| 29081 | | echo "${ECHO_T}$am_cv_langinfo_codeset" >&6; } |
| 29082 | | if test $am_cv_langinfo_codeset = yes; then |
| 29083 | | |
| 29084 | | cat >>confdefs.h <<\_ACEOF |
| 29085 | | #define HAVE_LANGINFO_CODESET 1 |
| 29086 | | _ACEOF |
| 29087 | | |
| 29088 | | fi |
| 29089 | | |
| 29090 | | |
| 29091 | | { echo "$as_me:$LINENO: checking for LC_MESSAGES" >&5 |
| 29092 | | echo $ECHO_N "checking for LC_MESSAGES... $ECHO_C" >&6; } |
| 29093 | | if test "${gt_cv_val_LC_MESSAGES+set}" = set; then |
| 29094 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 29095 | | else |
| 29096 | | cat >conftest.$ac_ext <<_ACEOF |
| 29097 | | /* confdefs.h. */ |
| 29098 | | _ACEOF |
| 29099 | | cat confdefs.h >>conftest.$ac_ext |
| 29100 | | cat >>conftest.$ac_ext <<_ACEOF |
| 29101 | | /* end confdefs.h. */ |
| 29102 | | #include <locale.h> |
| 29103 | | int |
| 29104 | | main () |
| 29105 | | { |
| 29106 | | return LC_MESSAGES |
| 29107 | | ; |
| 29108 | | return 0; |
| 29109 | | } |
| 29110 | | _ACEOF |
| 29111 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 29112 | | if { (ac_try="$ac_link" |
| 29113 | | case "(($ac_try" in |
| 29114 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 29115 | | *) ac_try_echo=$ac_try;; |
| 29116 | | esac |
| 29117 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 29118 | | (eval "$ac_link") 2>conftest.er1 |
| 29119 | | ac_status=$? |
| 29120 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 29121 | | rm -f conftest.er1 |
| 29122 | | cat conftest.err >&5 |
| 29123 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 29124 | | (exit $ac_status); } && { |
| 29125 | | test -z "$ac_c_werror_flag" || |
| 29126 | | test ! -s conftest.err |
| 29127 | | } && test -s conftest$ac_exeext && |
| 29128 | | $as_test_x conftest$ac_exeext; then |
| 29129 | | gt_cv_val_LC_MESSAGES=yes |
| 29130 | | else |
| 29131 | | echo "$as_me: failed program was:" >&5 |
| 29132 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 29133 | | |
| 29134 | | gt_cv_val_LC_MESSAGES=no |
| 29135 | | fi |
| 29136 | | |
| 29137 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 29138 | | conftest$ac_exeext conftest.$ac_ext |
| 29139 | | fi |
| 29140 | | { echo "$as_me:$LINENO: result: $gt_cv_val_LC_MESSAGES" >&5 |
| 29141 | | echo "${ECHO_T}$gt_cv_val_LC_MESSAGES" >&6; } |
| 29142 | | if test $gt_cv_val_LC_MESSAGES = yes; then |
| 29143 | | |
| 29144 | | cat >>confdefs.h <<\_ACEOF |
| 29145 | | #define HAVE_LC_MESSAGES 1 |
| 29146 | | _ACEOF |
| 29147 | | |
| 29148 | | fi |
| 29149 | | |
| 29150 | | |
| 29151 | | if test "$enable_shared" = yes; then |
| 29152 | | case "$host_os" in |
| 29153 | | cygwin*) is_woe32dll=yes ;; |
| 29154 | | *) is_woe32dll=no ;; |
| 29155 | | esac |
| 29156 | | else |
| 29157 | | is_woe32dll=no |
| 29158 | | fi |
| 29159 | | WOE32DLL=$is_woe32dll |
| 29160 | | |
| 29161 | | |
| 29162 | | |
| 29163 | | |
| 29164 | | |
| 29165 | | |
| 29166 | | |
| 29167 | | |
| 29168 | | |
| 29169 | | |
| 29170 | | |
| 29171 | | |
| 29172 | | |
| 29173 | | |
| 29174 | | |
| 29175 | | |
| 29176 | | |
| 29177 | | |
| 29178 | | |
| 29179 | | |
| 29180 | | { echo "$as_me:$LINENO: checking for CFPreferencesCopyAppValue" >&5 |
| 29181 | | echo $ECHO_N "checking for CFPreferencesCopyAppValue... $ECHO_C" >&6; } |
| 29182 | | if test "${gt_cv_func_CFPreferencesCopyAppValue+set}" = set; then |
| 29183 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 29184 | | else |
| 29185 | | gt_save_LIBS="$LIBS" |
| 29186 | | LIBS="$LIBS -Wl,-framework -Wl,CoreFoundation" |
| 29187 | | cat >conftest.$ac_ext <<_ACEOF |
| 29188 | | /* confdefs.h. */ |
| 29189 | | _ACEOF |
| 29190 | | cat confdefs.h >>conftest.$ac_ext |
| 29191 | | cat >>conftest.$ac_ext <<_ACEOF |
| 29192 | | /* end confdefs.h. */ |
| 29193 | | #include <CoreFoundation/CFPreferences.h> |
| 29194 | | int |
| 29195 | | main () |
| 29196 | | { |
| 29197 | | CFPreferencesCopyAppValue(NULL, NULL) |
| 29198 | | ; |
| 29199 | | return 0; |
| 29200 | | } |
| 29201 | | _ACEOF |
| 29202 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 29203 | | if { (ac_try="$ac_link" |
| 29204 | | case "(($ac_try" in |
| 29205 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 29206 | | *) ac_try_echo=$ac_try;; |
| 29207 | | esac |
| 29208 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 29209 | | (eval "$ac_link") 2>conftest.er1 |
| 29210 | | ac_status=$? |
| 29211 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 29212 | | rm -f conftest.er1 |
| 29213 | | cat conftest.err >&5 |
| 29214 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 29215 | | (exit $ac_status); } && { |
| 29216 | | test -z "$ac_c_werror_flag" || |
| 29217 | | test ! -s conftest.err |
| 29218 | | } && test -s conftest$ac_exeext && |
| 29219 | | $as_test_x conftest$ac_exeext; then |
| 29220 | | gt_cv_func_CFPreferencesCopyAppValue=yes |
| 29221 | | else |
| 29222 | | echo "$as_me: failed program was:" >&5 |
| 29223 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 29224 | | |
| 29225 | | gt_cv_func_CFPreferencesCopyAppValue=no |
| 29226 | | fi |
| 29227 | | |
| 29228 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 29229 | | conftest$ac_exeext conftest.$ac_ext |
| 29230 | | LIBS="$gt_save_LIBS" |
| 29231 | | fi |
| 29232 | | { echo "$as_me:$LINENO: result: $gt_cv_func_CFPreferencesCopyAppValue" >&5 |
| 29233 | | echo "${ECHO_T}$gt_cv_func_CFPreferencesCopyAppValue" >&6; } |
| 29234 | | if test $gt_cv_func_CFPreferencesCopyAppValue = yes; then |
| 29235 | | |
| 29236 | | cat >>confdefs.h <<\_ACEOF |
| 29237 | | #define HAVE_CFPREFERENCESCOPYAPPVALUE 1 |
| 29238 | | _ACEOF |
| 29239 | | |
| 29240 | | fi |
| 29241 | | { echo "$as_me:$LINENO: checking for CFLocaleCopyCurrent" >&5 |
| 29242 | | echo $ECHO_N "checking for CFLocaleCopyCurrent... $ECHO_C" >&6; } |
| 29243 | | if test "${gt_cv_func_CFLocaleCopyCurrent+set}" = set; then |
| 29244 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 29245 | | else |
| 29246 | | gt_save_LIBS="$LIBS" |
| 29247 | | LIBS="$LIBS -Wl,-framework -Wl,CoreFoundation" |
| 29248 | | cat >conftest.$ac_ext <<_ACEOF |
| 29249 | | /* confdefs.h. */ |
| 29250 | | _ACEOF |
| 29251 | | cat confdefs.h >>conftest.$ac_ext |
| 29252 | | cat >>conftest.$ac_ext <<_ACEOF |
| 29253 | | /* end confdefs.h. */ |
| 29254 | | #include <CoreFoundation/CFLocale.h> |
| 29255 | | int |
| 29256 | | main () |
| 29257 | | { |
| 29258 | | CFLocaleCopyCurrent(); |
| 29259 | | ; |
| 29260 | | return 0; |
| 29261 | | } |
| 29262 | | _ACEOF |
| 29263 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 29264 | | if { (ac_try="$ac_link" |
| 29265 | | case "(($ac_try" in |
| 29266 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 29267 | | *) ac_try_echo=$ac_try;; |
| 29268 | | esac |
| 29269 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 29270 | | (eval "$ac_link") 2>conftest.er1 |
| 29271 | | ac_status=$? |
| 29272 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 29273 | | rm -f conftest.er1 |
| 29274 | | cat conftest.err >&5 |
| 29275 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 29276 | | (exit $ac_status); } && { |
| 29277 | | test -z "$ac_c_werror_flag" || |
| 29278 | | test ! -s conftest.err |
| 29279 | | } && test -s conftest$ac_exeext && |
| 29280 | | $as_test_x conftest$ac_exeext; then |
| 29281 | | gt_cv_func_CFLocaleCopyCurrent=yes |
| 29282 | | else |
| 29283 | | echo "$as_me: failed program was:" >&5 |
| 29284 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 29285 | | |
| 29286 | | gt_cv_func_CFLocaleCopyCurrent=no |
| 29287 | | fi |
| 29288 | | |
| 29289 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 29290 | | conftest$ac_exeext conftest.$ac_ext |
| 29291 | | LIBS="$gt_save_LIBS" |
| 29292 | | fi |
| 29293 | | { echo "$as_me:$LINENO: result: $gt_cv_func_CFLocaleCopyCurrent" >&5 |
| 29294 | | echo "${ECHO_T}$gt_cv_func_CFLocaleCopyCurrent" >&6; } |
| 29295 | | if test $gt_cv_func_CFLocaleCopyCurrent = yes; then |
| 29296 | | |
| 29297 | | cat >>confdefs.h <<\_ACEOF |
| 29298 | | #define HAVE_CFLOCALECOPYCURRENT 1 |
| 29299 | | _ACEOF |
| 29300 | | |
| 29301 | | fi |
| 29302 | | INTL_MACOSX_LIBS= |
| 29303 | | if test $gt_cv_func_CFPreferencesCopyAppValue = yes || test $gt_cv_func_CFLocaleCopyCurrent = yes; then |
| 29304 | | INTL_MACOSX_LIBS="-Wl,-framework -Wl,CoreFoundation" |
| 29305 | | fi |
| 29306 | | |
| 29307 | | |
| 29308 | | |
| 29309 | | |
| 29310 | | |
| 29311 | | |
| 29312 | | BUILD_INCLUDED_LIBINTL=no |
| 29313 | | USE_INCLUDED_LIBINTL=no |
| 29314 | | |
| 29315 | | LIBINTL= |
| 29316 | | LTLIBINTL= |
| 29317 | | POSUB= |
| 29318 | | |
| 29319 | | if test "$USE_NLS" = "yes"; then |
| 29320 | | gt_use_preinstalled_gnugettext=no |
| 29321 | | |
| 29322 | | { echo "$as_me:$LINENO: checking whether included gettext is requested" >&5 |
| 29323 | | echo $ECHO_N "checking whether included gettext is requested... $ECHO_C" >&6; } |
| 29324 | | |
| 29325 | | # Check whether --with-included-gettext was given. |
| 29326 | | if test "${with_included_gettext+set}" = set; then |
| 29327 | | withval=$with_included_gettext; nls_cv_force_use_gnu_gettext=$withval |
| 29328 | | else |
| 29329 | | nls_cv_force_use_gnu_gettext=no |
| 29330 | | fi |
| 29331 | | |
| 29332 | | { echo "$as_me:$LINENO: result: $nls_cv_force_use_gnu_gettext" >&5 |
| 29333 | | echo "${ECHO_T}$nls_cv_force_use_gnu_gettext" >&6; } |
| 29334 | | |
| 29335 | | nls_cv_use_gnu_gettext="$nls_cv_force_use_gnu_gettext" |
| 29336 | | if test "$nls_cv_force_use_gnu_gettext" != "yes"; then |
| 29337 | | |
| 29338 | | |
| 29339 | | |
| 29340 | | |
| 29341 | | |
| 29342 | | |
| 29343 | | { echo "$as_me:$LINENO: checking for GNU gettext in libc" >&5 |
| 29344 | | echo $ECHO_N "checking for GNU gettext in libc... $ECHO_C" >&6; } |
| 29345 | | if test "${gt_cv_func_gnugettext1_libc+set}" = set; then |
| 29346 | | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| 29347 | | else |
| 29348 | | cat >conftest.$ac_ext <<_ACEOF |
| 29349 | | /* confdefs.h. */ |
| 29350 | | _ACEOF |
| 29351 | | cat confdefs.h >>conftest.$ac_ext |
| 29352 | | cat >>conftest.$ac_ext <<_ACEOF |
| 29353 | | /* end confdefs.h. */ |
| 29354 | | #include <libintl.h> |
| 29355 | | extern int _nl_msg_cat_cntr; |
| 29356 | | extern int *_nl_domain_bindings; |
| 29357 | | int |
| 29358 | | main () |
| 29359 | | { |
| 29360 | | bindtextdomain ("", ""); |
| 29361 | | return * gettext ("") + _nl_msg_cat_cntr + *_nl_domain_bindings |
| 29362 | | ; |
| 29363 | | return 0; |
| 29364 | | } |
| 29365 | | _ACEOF |
| 29366 | | rm -f conftest.$ac_objext conftest$ac_exeext |
| 29367 | | if { (ac_try="$ac_link" |
| 29368 | | case "(($ac_try" in |
| 29369 | | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| 29370 | | *) ac_try_echo=$ac_try;; |
| 29371 | | esac |
| 29372 | | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| 29373 | | (eval "$ac_link") 2>conftest.er1 |
| 29374 | | ac_status=$? |
| 29375 | | grep -v '^ *+' conftest.er1 >conftest.err |
| 29376 | | rm -f conftest.er1 |
| 29377 | | cat conftest.err >&5 |
| 29378 | | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| 29379 | | (exit $ac_status); } && { |
| 29380 | | test -z "$ac_c_werror_flag" || |
| 29381 | | test ! -s conftest.err |
| 29382 | | } && test -s conftest$ac_exeext && |
| 29383 | | $as_test_x conftest$ac_exeext; then |
| 29384 | | gt_cv_func_gnugettext1_libc=yes |
| 29385 | | else |
| 29386 | | echo "$as_me: failed program was:" >&5 |
| 29387 | | sed 's/^/| /' conftest.$ac_ext >&5 |
| 29388 | | |
| 29389 | | gt_cv_func_gnugettext1_libc=no |
| 29390 | | fi |
| 29391 | | |
| 29392 | | rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ |
| 29393 | | conftest$ac_exeext conftest.$ac_ext |
| 29394 | | fi |
| 29395 | | { echo "$as_me:$LINENO: result: $gt_cv_func_gnugettext1_libc" >&5 |
| 29396 | | echo "${ECHO_T}$gt_cv_func_gnugettext1_libc" >&6; } |
| 29397 | | |
| 29398 | | if test "$gt_cv_func_gnugettext1_libc" != "yes"; then |
| 30093 | | CFPreferencesCopyAppValue(NULL, NULL) |
| | 21970 | #ifndef __GNUC__ |
| | 21971 | choke me |
| | 21972 | #endif |
| | 21973 | |
| | 21974 | ; |
| | 21975 | return 0; |
| | 21976 | } |
| | 21977 | _ACEOF |
| | 21978 | rm -f conftest.$ac_objext |
| | 21979 | if { (ac_try="$ac_compile" |
| | 21980 | case "(($ac_try" in |
| | 21981 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 21982 | *) ac_try_echo=$ac_try;; |
| | 21983 | esac |
| | 21984 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 21985 | (eval "$ac_compile") 2>conftest.er1 |
| | 21986 | ac_status=$? |
| | 21987 | grep -v '^ *+' conftest.er1 >conftest.err |
| | 21988 | rm -f conftest.er1 |
| | 21989 | cat conftest.err >&5 |
| | 21990 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 21991 | (exit $ac_status); } && { |
| | 21992 | test -z "$ac_c_werror_flag" || |
| | 21993 | test ! -s conftest.err |
| | 21994 | } && test -s conftest.$ac_objext; then |
| | 21995 | ac_compiler_gnu=yes |
| | 21996 | else |
| | 21997 | echo "$as_me: failed program was:" >&5 |
| | 21998 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 21999 | |
| | 22000 | ac_compiler_gnu=no |
| | 22001 | fi |
| | 22002 | |
| | 22003 | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| | 22004 | ac_cv_c_compiler_gnu=$ac_compiler_gnu |
| | 22005 | |
| | 22006 | fi |
| | 22007 | { echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5 |
| | 22008 | echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; } |
| | 22009 | GCC=`test $ac_compiler_gnu = yes && echo yes` |
| | 22010 | ac_test_CFLAGS=${CFLAGS+set} |
| | 22011 | ac_save_CFLAGS=$CFLAGS |
| | 22012 | { echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5 |
| | 22013 | echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; } |
| | 22014 | if test "${ac_cv_prog_cc_g+set}" = set; then |
| | 22015 | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| | 22016 | else |
| | 22017 | ac_save_c_werror_flag=$ac_c_werror_flag |
| | 22018 | ac_c_werror_flag=yes |
| | 22019 | ac_cv_prog_cc_g=no |
| | 22020 | CFLAGS="-g" |
| | 22021 | cat >conftest.$ac_ext <<_ACEOF |
| | 22022 | /* confdefs.h. */ |
| | 22023 | _ACEOF |
| | 22024 | cat confdefs.h >>conftest.$ac_ext |
| | 22025 | cat >>conftest.$ac_ext <<_ACEOF |
| | 22026 | /* end confdefs.h. */ |
| | 22027 | |
| | 22028 | int |
| | 22029 | main () |
| | 22030 | { |
| | 22031 | |
| | 22032 | ; |
| | 22033 | return 0; |
| | 22034 | } |
| | 22035 | _ACEOF |
| | 22036 | rm -f conftest.$ac_objext |
| | 22037 | if { (ac_try="$ac_compile" |
| | 22038 | case "(($ac_try" in |
| | 22039 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 22040 | *) ac_try_echo=$ac_try;; |
| | 22041 | esac |
| | 22042 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 22043 | (eval "$ac_compile") 2>conftest.er1 |
| | 22044 | ac_status=$? |
| | 22045 | grep -v '^ *+' conftest.er1 >conftest.err |
| | 22046 | rm -f conftest.er1 |
| | 22047 | cat conftest.err >&5 |
| | 22048 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 22049 | (exit $ac_status); } && { |
| | 22050 | test -z "$ac_c_werror_flag" || |
| | 22051 | test ! -s conftest.err |
| | 22052 | } && test -s conftest.$ac_objext; then |
| | 22053 | ac_cv_prog_cc_g=yes |
| | 22054 | else |
| | 22055 | echo "$as_me: failed program was:" >&5 |
| | 22056 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 22057 | |
| | 22058 | CFLAGS="" |
| | 22059 | cat >conftest.$ac_ext <<_ACEOF |
| | 22060 | /* confdefs.h. */ |
| | 22061 | _ACEOF |
| | 22062 | cat confdefs.h >>conftest.$ac_ext |
| | 22063 | cat >>conftest.$ac_ext <<_ACEOF |
| | 22064 | /* end confdefs.h. */ |
| | 22065 | |
| | 22066 | int |
| | 22067 | main () |
| | 22068 | { |
| | 22069 | |
| | 22070 | ; |
| | 22071 | return 0; |
| | 22072 | } |
| | 22073 | _ACEOF |
| | 22074 | rm -f conftest.$ac_objext |
| | 22075 | if { (ac_try="$ac_compile" |
| | 22076 | case "(($ac_try" in |
| | 22077 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 22078 | *) ac_try_echo=$ac_try;; |
| | 22079 | esac |
| | 22080 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 22081 | (eval "$ac_compile") 2>conftest.er1 |
| | 22082 | ac_status=$? |
| | 22083 | grep -v '^ *+' conftest.er1 >conftest.err |
| | 22084 | rm -f conftest.er1 |
| | 22085 | cat conftest.err >&5 |
| | 22086 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 22087 | (exit $ac_status); } && { |
| | 22088 | test -z "$ac_c_werror_flag" || |
| | 22089 | test ! -s conftest.err |
| | 22090 | } && test -s conftest.$ac_objext; then |
| | 22091 | : |
| | 22092 | else |
| | 22093 | echo "$as_me: failed program was:" >&5 |
| | 22094 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 22095 | |
| | 22096 | ac_c_werror_flag=$ac_save_c_werror_flag |
| | 22097 | CFLAGS="-g" |
| | 22098 | cat >conftest.$ac_ext <<_ACEOF |
| | 22099 | /* confdefs.h. */ |
| | 22100 | _ACEOF |
| | 22101 | cat confdefs.h >>conftest.$ac_ext |
| | 22102 | cat >>conftest.$ac_ext <<_ACEOF |
| | 22103 | /* end confdefs.h. */ |
| | 22104 | |
| | 22105 | int |
| | 22106 | main () |
| | 22107 | { |
| | 22108 | |
| | 22109 | ; |
| | 22110 | return 0; |
| | 22111 | } |
| | 22112 | _ACEOF |
| | 22113 | rm -f conftest.$ac_objext |
| | 22114 | if { (ac_try="$ac_compile" |
| | 22115 | case "(($ac_try" in |
| | 22116 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 22117 | *) ac_try_echo=$ac_try;; |
| | 22118 | esac |
| | 22119 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 22120 | (eval "$ac_compile") 2>conftest.er1 |
| | 22121 | ac_status=$? |
| | 22122 | grep -v '^ *+' conftest.er1 >conftest.err |
| | 22123 | rm -f conftest.er1 |
| | 22124 | cat conftest.err >&5 |
| | 22125 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 22126 | (exit $ac_status); } && { |
| | 22127 | test -z "$ac_c_werror_flag" || |
| | 22128 | test ! -s conftest.err |
| | 22129 | } && test -s conftest.$ac_objext; then |
| | 22130 | ac_cv_prog_cc_g=yes |
| | 22131 | else |
| | 22132 | echo "$as_me: failed program was:" >&5 |
| | 22133 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 22134 | |
| | 22135 | |
| | 22136 | fi |
| | 22137 | |
| | 22138 | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| | 22139 | fi |
| | 22140 | |
| | 22141 | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| | 22142 | fi |
| | 22143 | |
| | 22144 | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| | 22145 | ac_c_werror_flag=$ac_save_c_werror_flag |
| | 22146 | fi |
| | 22147 | { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5 |
| | 22148 | echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; } |
| | 22149 | if test "$ac_test_CFLAGS" = set; then |
| | 22150 | CFLAGS=$ac_save_CFLAGS |
| | 22151 | elif test $ac_cv_prog_cc_g = yes; then |
| | 22152 | if test "$GCC" = yes; then |
| | 22153 | CFLAGS="-g -O2" |
| | 22154 | else |
| | 22155 | CFLAGS="-g" |
| | 22156 | fi |
| | 22157 | else |
| | 22158 | if test "$GCC" = yes; then |
| | 22159 | CFLAGS="-O2" |
| | 22160 | else |
| | 22161 | CFLAGS= |
| | 22162 | fi |
| | 22163 | fi |
| | 22164 | { echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5 |
| | 22165 | echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; } |
| | 22166 | if test "${ac_cv_prog_cc_c89+set}" = set; then |
| | 22167 | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| | 22168 | else |
| | 22169 | ac_cv_prog_cc_c89=no |
| | 22170 | ac_save_CC=$CC |
| | 22171 | cat >conftest.$ac_ext <<_ACEOF |
| | 22172 | /* confdefs.h. */ |
| | 22173 | _ACEOF |
| | 22174 | cat confdefs.h >>conftest.$ac_ext |
| | 22175 | cat >>conftest.$ac_ext <<_ACEOF |
| | 22176 | /* end confdefs.h. */ |
| | 22177 | #include <stdarg.h> |
| | 22178 | #include <stdio.h> |
| | 22179 | #include <sys/types.h> |
| | 22180 | #include <sys/stat.h> |
| | 22181 | /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ |
| | 22182 | struct buf { int x; }; |
| | 22183 | FILE * (*rcsopen) (struct buf *, struct stat *, int); |
| | 22184 | static char *e (p, i) |
| | 22185 | char **p; |
| | 22186 | int i; |
| | 22187 | { |
| | 22188 | return p[i]; |
| | 22189 | } |
| | 22190 | static char *f (char * (*g) (char **, int), char **p, ...) |
| | 22191 | { |
| | 22192 | char *s; |
| | 22193 | va_list v; |
| | 22194 | va_start (v,p); |
| | 22195 | s = g (p, va_arg (v,int)); |
| | 22196 | va_end (v); |
| | 22197 | return s; |
| | 22198 | } |
| | 22199 | |
| | 22200 | /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has |
| | 22201 | function prototypes and stuff, but not '\xHH' hex character constants. |
| | 22202 | These don't provoke an error unfortunately, instead are silently treated |
| | 22203 | as 'x'. The following induces an error, until -std is added to get |
| | 22204 | proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an |
| | 22205 | array size at least. It's necessary to write '\x00'==0 to get something |
| | 22206 | that's true only with -std. */ |
| | 22207 | int osf4_cc_array ['\x00' == 0 ? 1 : -1]; |
| | 22208 | |
| | 22209 | /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters |
| | 22210 | inside strings and character constants. */ |
| | 22211 | #define FOO(x) 'x' |
| | 22212 | int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; |
| | 22213 | |
| | 22214 | int test (int i, double x); |
| | 22215 | struct s1 {int (*f) (int a);}; |
| | 22216 | struct s2 {int (*f) (double a);}; |
| | 22217 | int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); |
| | 22218 | int argc; |
| | 22219 | char **argv; |
| | 22220 | int |
| | 22221 | main () |
| | 22222 | { |
| | 22223 | return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; |
| | 22224 | ; |
| | 22225 | return 0; |
| | 22226 | } |
| | 22227 | _ACEOF |
| | 22228 | for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ |
| | 22229 | -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" |
| | 22230 | do |
| | 22231 | CC="$ac_save_CC $ac_arg" |
| | 22232 | rm -f conftest.$ac_objext |
| | 22233 | if { (ac_try="$ac_compile" |
| | 22234 | case "(($ac_try" in |
| | 22235 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 22236 | *) ac_try_echo=$ac_try;; |
| | 22237 | esac |
| | 22238 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 22239 | (eval "$ac_compile") 2>conftest.er1 |
| | 22240 | ac_status=$? |
| | 22241 | grep -v '^ *+' conftest.er1 >conftest.err |
| | 22242 | rm -f conftest.er1 |
| | 22243 | cat conftest.err >&5 |
| | 22244 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 22245 | (exit $ac_status); } && { |
| | 22246 | test -z "$ac_c_werror_flag" || |
| | 22247 | test ! -s conftest.err |
| | 22248 | } && test -s conftest.$ac_objext; then |
| | 22249 | ac_cv_prog_cc_c89=$ac_arg |
| | 22250 | else |
| | 22251 | echo "$as_me: failed program was:" >&5 |
| | 22252 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 22253 | |
| | 22254 | |
| | 22255 | fi |
| | 22256 | |
| | 22257 | rm -f core conftest.err conftest.$ac_objext |
| | 22258 | test "x$ac_cv_prog_cc_c89" != "xno" && break |
| | 22259 | done |
| | 22260 | rm -f conftest.$ac_ext |
| | 22261 | CC=$ac_save_CC |
| | 22262 | |
| | 22263 | fi |
| | 22264 | # AC_CACHE_VAL |
| | 22265 | case "x$ac_cv_prog_cc_c89" in |
| | 22266 | x) |
| | 22267 | { echo "$as_me:$LINENO: result: none needed" >&5 |
| | 22268 | echo "${ECHO_T}none needed" >&6; } ;; |
| | 22269 | xno) |
| | 22270 | { echo "$as_me:$LINENO: result: unsupported" >&5 |
| | 22271 | echo "${ECHO_T}unsupported" >&6; } ;; |
| | 22272 | *) |
| | 22273 | CC="$CC $ac_cv_prog_cc_c89" |
| | 22274 | { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5 |
| | 22275 | echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;; |
| | 22276 | esac |
| | 22277 | |
| | 22278 | |
| | 22279 | ac_ext=c |
| | 22280 | ac_cpp='$CPP $CPPFLAGS' |
| | 22281 | ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' |
| | 22282 | ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' |
| | 22283 | ac_compiler_gnu=$ac_cv_c_compiler_gnu |
| | 22284 | |
| | 22285 | depcc="$CC" am_compiler_list= |
| | 22286 | |
| | 22287 | { echo "$as_me:$LINENO: checking dependency style of $depcc" >&5 |
| | 22288 | echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6; } |
| | 22289 | if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then |
| | 22290 | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| | 22291 | else |
| | 22292 | if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then |
| | 22293 | # We make a subdir and do the tests there. Otherwise we can end up |
| | 22294 | # making bogus files that we don't know about and never remove. For |
| | 22295 | # instance it was reported that on HP-UX the gcc test will end up |
| | 22296 | # making a dummy file named `D' -- because `-MD' means `put the output |
| | 22297 | # in D'. |
| | 22298 | mkdir conftest.dir |
| | 22299 | # Copy depcomp to subdir because otherwise we won't find it if we're |
| | 22300 | # using a relative directory. |
| | 22301 | cp "$am_depcomp" conftest.dir |
| | 22302 | cd conftest.dir |
| | 22303 | # We will build objects and dependencies in a subdirectory because |
| | 22304 | # it helps to detect inapplicable dependency modes. For instance |
| | 22305 | # both Tru64's cc and ICC support -MD to output dependencies as a |
| | 22306 | # side effect of compilation, but ICC will put the dependencies in |
| | 22307 | # the current directory while Tru64 will put them in the object |
| | 22308 | # directory. |
| | 22309 | mkdir sub |
| | 22310 | |
| | 22311 | am_cv_CC_dependencies_compiler_type=none |
| | 22312 | if test "$am_compiler_list" = ""; then |
| | 22313 | am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` |
| | 22314 | fi |
| | 22315 | for depmode in $am_compiler_list; do |
| | 22316 | # Setup a source with many dependencies, because some compilers |
| | 22317 | # like to wrap large dependency lists on column 80 (with \), and |
| | 22318 | # we should not choose a depcomp mode which is confused by this. |
| | 22319 | # |
| | 22320 | # We need to recreate these files for each test, as the compiler may |
| | 22321 | # overwrite some of them when testing with obscure command lines. |
| | 22322 | # This happens at least with the AIX C compiler. |
| | 22323 | : > sub/conftest.c |
| | 22324 | for i in 1 2 3 4 5 6; do |
| | 22325 | echo '#include "conftst'$i'.h"' >> sub/conftest.c |
| | 22326 | # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with |
| | 22327 | # Solaris 8's {/usr,}/bin/sh. |
| | 22328 | touch sub/conftst$i.h |
| | 22329 | done |
| | 22330 | echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf |
| | 22331 | |
| | 22332 | case $depmode in |
| | 22333 | nosideeffect) |
| | 22334 | # after this tag, mechanisms are not by side-effect, so they'll |
| | 22335 | # only be used when explicitly requested |
| | 22336 | if test "x$enable_dependency_tracking" = xyes; then |
| | 22337 | continue |
| | 22338 | else |
| | 22339 | break |
| | 22340 | fi |
| | 22341 | ;; |
| | 22342 | none) break ;; |
| | 22343 | esac |
| | 22344 | # We check with `-c' and `-o' for the sake of the "dashmstdout" |
| | 22345 | # mode. It turns out that the SunPro C++ compiler does not properly |
| | 22346 | # handle `-M -o', and we need to detect this. |
| | 22347 | if depmode=$depmode \ |
| | 22348 | source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \ |
| | 22349 | depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ |
| | 22350 | $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \ |
| | 22351 | >/dev/null 2>conftest.err && |
| | 22352 | grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && |
| | 22353 | grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && |
| | 22354 | grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 && |
| | 22355 | ${MAKE-make} -s -f confmf > /dev/null 2>&1; then |
| | 22356 | # icc doesn't choke on unknown options, it will just issue warnings |
| | 22357 | # or remarks (even with -Werror). So we grep stderr for any message |
| | 22358 | # that says an option was ignored or not supported. |
| | 22359 | # When given -MP, icc 7.0 and 7.1 complain thusly: |
| | 22360 | # icc: Command line warning: ignoring option '-M'; no argument required |
| | 22361 | # The diagnosis changed in icc 8.0: |
| | 22362 | # icc: Command line remark: option '-MP' not supported |
| | 22363 | if (grep 'ignoring option' conftest.err || |
| | 22364 | grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else |
| | 22365 | am_cv_CC_dependencies_compiler_type=$depmode |
| | 22366 | break |
| | 22367 | fi |
| | 22368 | fi |
| | 22369 | done |
| | 22370 | |
| | 22371 | cd .. |
| | 22372 | rm -rf conftest.dir |
| | 22373 | else |
| | 22374 | am_cv_CC_dependencies_compiler_type=none |
| | 22375 | fi |
| | 22376 | |
| | 22377 | fi |
| | 22378 | { echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5 |
| | 22379 | echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6; } |
| | 22380 | CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type |
| | 22381 | |
| | 22382 | if |
| | 22383 | test "x$enable_dependency_tracking" != xno \ |
| | 22384 | && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then |
| | 22385 | am__fastdepCC_TRUE= |
| | 22386 | am__fastdepCC_FALSE='#' |
| | 22387 | else |
| | 22388 | am__fastdepCC_TRUE='#' |
| | 22389 | am__fastdepCC_FALSE= |
| | 22390 | fi |
| | 22391 | |
| | 22392 | |
| | 22393 | ac_ext=c |
| | 22394 | ac_cpp='$CPP $CPPFLAGS' |
| | 22395 | ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' |
| | 22396 | ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' |
| | 22397 | ac_compiler_gnu=$ac_cv_c_compiler_gnu |
| | 22398 | { echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5 |
| | 22399 | echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6; } |
| | 22400 | # On Suns, sometimes $CPP names a directory. |
| | 22401 | if test -n "$CPP" && test -d "$CPP"; then |
| | 22402 | CPP= |
| | 22403 | fi |
| | 22404 | if test -z "$CPP"; then |
| | 22405 | if test "${ac_cv_prog_CPP+set}" = set; then |
| | 22406 | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| | 22407 | else |
| | 22408 | # Double quotes because CPP needs to be expanded |
| | 22409 | for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" |
| | 22410 | do |
| | 22411 | ac_preproc_ok=false |
| | 22412 | for ac_c_preproc_warn_flag in '' yes |
| | 22413 | do |
| | 22414 | # Use a header file that comes with gcc, so configuring glibc |
| | 22415 | # with a fresh cross-compiler works. |
| | 22416 | # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since |
| | 22417 | # <limits.h> exists even on freestanding compilers. |
| | 22418 | # On the NeXT, cc -E runs the code through the compiler's parser, |
| | 22419 | # not just through cpp. "Syntax error" is here to catch this case. |
| | 22420 | cat >conftest.$ac_ext <<_ACEOF |
| | 22421 | /* confdefs.h. */ |
| | 22422 | _ACEOF |
| | 22423 | cat confdefs.h >>conftest.$ac_ext |
| | 22424 | cat >>conftest.$ac_ext <<_ACEOF |
| | 22425 | /* end confdefs.h. */ |
| | 22426 | #ifdef __STDC__ |
| | 22427 | # include <limits.h> |
| | 22428 | #else |
| | 22429 | # include <assert.h> |
| | 22430 | #endif |
| | 22431 | Syntax error |
| | 22432 | _ACEOF |
| | 22433 | if { (ac_try="$ac_cpp conftest.$ac_ext" |
| | 22434 | case "(($ac_try" in |
| | 22435 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 22436 | *) ac_try_echo=$ac_try;; |
| | 22437 | esac |
| | 22438 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 22439 | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 |
| | 22440 | ac_status=$? |
| | 22441 | grep -v '^ *+' conftest.er1 >conftest.err |
| | 22442 | rm -f conftest.er1 |
| | 22443 | cat conftest.err >&5 |
| | 22444 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 22445 | (exit $ac_status); } >/dev/null && { |
| | 22446 | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| | 22447 | test ! -s conftest.err |
| | 22448 | }; then |
| | 22449 | : |
| | 22450 | else |
| | 22451 | echo "$as_me: failed program was:" >&5 |
| | 22452 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 22453 | |
| | 22454 | # Broken: fails on valid input. |
| | 22455 | continue |
| | 22456 | fi |
| | 22457 | |
| | 22458 | rm -f conftest.err conftest.$ac_ext |
| | 22459 | |
| | 22460 | # OK, works on sane cases. Now check whether nonexistent headers |
| | 22461 | # can be detected and how. |
| | 22462 | cat >conftest.$ac_ext <<_ACEOF |
| | 22463 | /* confdefs.h. */ |
| | 22464 | _ACEOF |
| | 22465 | cat confdefs.h >>conftest.$ac_ext |
| | 22466 | cat >>conftest.$ac_ext <<_ACEOF |
| | 22467 | /* end confdefs.h. */ |
| | 22468 | #include <ac_nonexistent.h> |
| | 22469 | _ACEOF |
| | 22470 | if { (ac_try="$ac_cpp conftest.$ac_ext" |
| | 22471 | case "(($ac_try" in |
| | 22472 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 22473 | *) ac_try_echo=$ac_try;; |
| | 22474 | esac |
| | 22475 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 22476 | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 |
| | 22477 | ac_status=$? |
| | 22478 | grep -v '^ *+' conftest.er1 >conftest.err |
| | 22479 | rm -f conftest.er1 |
| | 22480 | cat conftest.err >&5 |
| | 22481 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 22482 | (exit $ac_status); } >/dev/null && { |
| | 22483 | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| | 22484 | test ! -s conftest.err |
| | 22485 | }; then |
| | 22486 | # Broken: success on invalid input. |
| | 22487 | continue |
| | 22488 | else |
| | 22489 | echo "$as_me: failed program was:" >&5 |
| | 22490 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 22491 | |
| | 22492 | # Passes both tests. |
| | 22493 | ac_preproc_ok=: |
| | 22494 | break |
| | 22495 | fi |
| | 22496 | |
| | 22497 | rm -f conftest.err conftest.$ac_ext |
| | 22498 | |
| | 22499 | done |
| | 22500 | # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. |
| | 22501 | rm -f conftest.err conftest.$ac_ext |
| | 22502 | if $ac_preproc_ok; then |
| | 22503 | break |
| | 22504 | fi |
| | 22505 | |
| | 22506 | done |
| | 22507 | ac_cv_prog_CPP=$CPP |
| | 22508 | |
| | 22509 | fi |
| | 22510 | CPP=$ac_cv_prog_CPP |
| | 22511 | else |
| | 22512 | ac_cv_prog_CPP=$CPP |
| | 22513 | fi |
| | 22514 | { echo "$as_me:$LINENO: result: $CPP" >&5 |
| | 22515 | echo "${ECHO_T}$CPP" >&6; } |
| | 22516 | ac_preproc_ok=false |
| | 22517 | for ac_c_preproc_warn_flag in '' yes |
| | 22518 | do |
| | 22519 | # Use a header file that comes with gcc, so configuring glibc |
| | 22520 | # with a fresh cross-compiler works. |
| | 22521 | # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since |
| | 22522 | # <limits.h> exists even on freestanding compilers. |
| | 22523 | # On the NeXT, cc -E runs the code through the compiler's parser, |
| | 22524 | # not just through cpp. "Syntax error" is here to catch this case. |
| | 22525 | cat >conftest.$ac_ext <<_ACEOF |
| | 22526 | /* confdefs.h. */ |
| | 22527 | _ACEOF |
| | 22528 | cat confdefs.h >>conftest.$ac_ext |
| | 22529 | cat >>conftest.$ac_ext <<_ACEOF |
| | 22530 | /* end confdefs.h. */ |
| | 22531 | #ifdef __STDC__ |
| | 22532 | # include <limits.h> |
| | 22533 | #else |
| | 22534 | # include <assert.h> |
| | 22535 | #endif |
| | 22536 | Syntax error |
| | 22537 | _ACEOF |
| | 22538 | if { (ac_try="$ac_cpp conftest.$ac_ext" |
| | 22539 | case "(($ac_try" in |
| | 22540 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 22541 | *) ac_try_echo=$ac_try;; |
| | 22542 | esac |
| | 22543 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 22544 | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 |
| | 22545 | ac_status=$? |
| | 22546 | grep -v '^ *+' conftest.er1 >conftest.err |
| | 22547 | rm -f conftest.er1 |
| | 22548 | cat conftest.err >&5 |
| | 22549 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 22550 | (exit $ac_status); } >/dev/null && { |
| | 22551 | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| | 22552 | test ! -s conftest.err |
| | 22553 | }; then |
| | 22554 | : |
| | 22555 | else |
| | 22556 | echo "$as_me: failed program was:" >&5 |
| | 22557 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 22558 | |
| | 22559 | # Broken: fails on valid input. |
| | 22560 | continue |
| | 22561 | fi |
| | 22562 | |
| | 22563 | rm -f conftest.err conftest.$ac_ext |
| | 22564 | |
| | 22565 | # OK, works on sane cases. Now check whether nonexistent headers |
| | 22566 | # can be detected and how. |
| | 22567 | cat >conftest.$ac_ext <<_ACEOF |
| | 22568 | /* confdefs.h. */ |
| | 22569 | _ACEOF |
| | 22570 | cat confdefs.h >>conftest.$ac_ext |
| | 22571 | cat >>conftest.$ac_ext <<_ACEOF |
| | 22572 | /* end confdefs.h. */ |
| | 22573 | #include <ac_nonexistent.h> |
| | 22574 | _ACEOF |
| | 22575 | if { (ac_try="$ac_cpp conftest.$ac_ext" |
| | 22576 | case "(($ac_try" in |
| | 22577 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 22578 | *) ac_try_echo=$ac_try;; |
| | 22579 | esac |
| | 22580 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 22581 | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 |
| | 22582 | ac_status=$? |
| | 22583 | grep -v '^ *+' conftest.er1 >conftest.err |
| | 22584 | rm -f conftest.er1 |
| | 22585 | cat conftest.err >&5 |
| | 22586 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 22587 | (exit $ac_status); } >/dev/null && { |
| | 22588 | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| | 22589 | test ! -s conftest.err |
| | 22590 | }; then |
| | 22591 | # Broken: success on invalid input. |
| | 22592 | continue |
| | 22593 | else |
| | 22594 | echo "$as_me: failed program was:" >&5 |
| | 22595 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 22596 | |
| | 22597 | # Passes both tests. |
| | 22598 | ac_preproc_ok=: |
| | 22599 | break |
| | 22600 | fi |
| | 22601 | |
| | 22602 | rm -f conftest.err conftest.$ac_ext |
| | 22603 | |
| | 22604 | done |
| | 22605 | # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. |
| | 22606 | rm -f conftest.err conftest.$ac_ext |
| | 22607 | if $ac_preproc_ok; then |
| | 22608 | : |
| | 22609 | else |
| | 22610 | { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check |
| | 22611 | See \`config.log' for more details." >&5 |
| | 22612 | echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check |
| | 22613 | See \`config.log' for more details." >&2;} |
| | 22614 | { (exit 1); exit 1; }; } |
| | 22615 | fi |
| | 22616 | |
| | 22617 | ac_ext=c |
| | 22618 | ac_cpp='$CPP $CPPFLAGS' |
| | 22619 | ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' |
| | 22620 | ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' |
| | 22621 | ac_compiler_gnu=$ac_cv_c_compiler_gnu |
| | 22622 | |
| | 22623 | # Find a good install program. We prefer a C program (faster), |
| | 22624 | # so one script is as good as another. But avoid the broken or |
| | 22625 | # incompatible versions: |
| | 22626 | # SysV /etc/install, /usr/sbin/install |
| | 22627 | # SunOS /usr/etc/install |
| | 22628 | # IRIX /sbin/install |
| | 22629 | # AIX /bin/install |
| | 22630 | # AmigaOS /C/install, which installs bootblocks on floppy discs |
| | 22631 | # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag |
| | 22632 | # AFS /usr/afsws/bin/install, which mishandles nonexistent args |
| | 22633 | # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" |
| | 22634 | # OS/2's system install, which has a completely different semantic |
| | 22635 | # ./install, which can be erroneously created by make from ./install.sh. |
| | 22636 | { echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5 |
| | 22637 | echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6; } |
| | 22638 | if test -z "$INSTALL"; then |
| | 22639 | if test "${ac_cv_path_install+set}" = set; then |
| | 22640 | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| | 22641 | else |
| | 22642 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 22643 | for as_dir in $PATH |
| | 22644 | do |
| | 22645 | IFS=$as_save_IFS |
| | 22646 | test -z "$as_dir" && as_dir=. |
| | 22647 | # Account for people who put trailing slashes in PATH elements. |
| | 22648 | case $as_dir/ in |
| | 22649 | ./ | .// | /cC/* | \ |
| | 22650 | /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \ |
| | 22651 | ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \ |
| | 22652 | /usr/ucb/* ) ;; |
| | 22653 | *) |
| | 22654 | # OSF1 and SCO ODT 3.0 have their own names for install. |
| | 22655 | # Don't use installbsd from OSF since it installs stuff as root |
| | 22656 | # by default. |
| | 22657 | for ac_prog in ginstall scoinst install; do |
| | 22658 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 22659 | if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then |
| | 22660 | if test $ac_prog = install && |
| | 22661 | grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then |
| | 22662 | # AIX install. It has an incompatible calling convention. |
| | 22663 | : |
| | 22664 | elif test $ac_prog = install && |
| | 22665 | grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then |
| | 22666 | # program-specific install script used by HP pwplus--don't use. |
| | 22667 | : |
| | 22668 | else |
| | 22669 | ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c" |
| | 22670 | break 3 |
| | 22671 | fi |
| | 22672 | fi |
| | 22673 | done |
| | 22674 | done |
| | 22675 | ;; |
| | 22676 | esac |
| | 22677 | done |
| | 22678 | IFS=$as_save_IFS |
| | 22679 | |
| | 22680 | |
| | 22681 | fi |
| | 22682 | if test "${ac_cv_path_install+set}" = set; then |
| | 22683 | INSTALL=$ac_cv_path_install |
| | 22684 | else |
| | 22685 | # As a last resort, use the slow shell script. Don't cache a |
| | 22686 | # value for INSTALL within a source directory, because that will |
| | 22687 | # break other packages using the cache if that directory is |
| | 22688 | # removed, or if the value is a relative name. |
| | 22689 | INSTALL=$ac_install_sh |
| | 22690 | fi |
| | 22691 | fi |
| | 22692 | { echo "$as_me:$LINENO: result: $INSTALL" >&5 |
| | 22693 | echo "${ECHO_T}$INSTALL" >&6; } |
| | 22694 | |
| | 22695 | # Use test -z because SunOS4 sh mishandles braces in ${var-val}. |
| | 22696 | # It thinks the first close brace ends the variable substitution. |
| | 22697 | test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' |
| | 22698 | |
| | 22699 | test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' |
| | 22700 | |
| | 22701 | test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' |
| | 22702 | |
| | 22703 | { echo "$as_me:$LINENO: checking whether ln -s works" >&5 |
| | 22704 | echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6; } |
| | 22705 | LN_S=$as_ln_s |
| | 22706 | if test "$LN_S" = "ln -s"; then |
| | 22707 | { echo "$as_me:$LINENO: result: yes" >&5 |
| | 22708 | echo "${ECHO_T}yes" >&6; } |
| | 22709 | else |
| | 22710 | { echo "$as_me:$LINENO: result: no, using $LN_S" >&5 |
| | 22711 | echo "${ECHO_T}no, using $LN_S" >&6; } |
| | 22712 | fi |
| | 22713 | |
| | 22714 | { echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5 |
| | 22715 | echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6; } |
| | 22716 | set x ${MAKE-make}; ac_make=`echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` |
| | 22717 | if { as_var=ac_cv_prog_make_${ac_make}_set; eval "test \"\${$as_var+set}\" = set"; }; then |
| | 22718 | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| | 22719 | else |
| | 22720 | cat >conftest.make <<\_ACEOF |
| | 22721 | SHELL = /bin/sh |
| | 22722 | all: |
| | 22723 | @echo '@@@%%%=$(MAKE)=@@@%%%' |
| | 22724 | _ACEOF |
| | 22725 | # GNU make sometimes prints "make[1]: Entering...", which would confuse us. |
| | 22726 | case `${MAKE-make} -f conftest.make 2>/dev/null` in |
| | 22727 | *@@@%%%=?*=@@@%%%*) |
| | 22728 | eval ac_cv_prog_make_${ac_make}_set=yes;; |
| | 22729 | *) |
| | 22730 | eval ac_cv_prog_make_${ac_make}_set=no;; |
| | 22731 | esac |
| | 22732 | rm -f conftest.make |
| | 22733 | fi |
| | 22734 | if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then |
| | 22735 | { echo "$as_me:$LINENO: result: yes" >&5 |
| | 22736 | echo "${ECHO_T}yes" >&6; } |
| | 22737 | SET_MAKE= |
| | 22738 | else |
| | 22739 | { echo "$as_me:$LINENO: result: no" >&5 |
| | 22740 | echo "${ECHO_T}no" >&6; } |
| | 22741 | SET_MAKE="MAKE=${MAKE-make}" |
| | 22742 | fi |
| | 22743 | |
| | 22744 | if test -n "$ac_tool_prefix"; then |
| | 22745 | # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. |
| | 22746 | set dummy ${ac_tool_prefix}ranlib; ac_word=$2 |
| | 22747 | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| | 22748 | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| | 22749 | if test "${ac_cv_prog_RANLIB+set}" = set; then |
| | 22750 | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| | 22751 | else |
| | 22752 | if test -n "$RANLIB"; then |
| | 22753 | ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. |
| | 22754 | else |
| | 22755 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 22756 | for as_dir in $PATH |
| | 22757 | do |
| | 22758 | IFS=$as_save_IFS |
| | 22759 | test -z "$as_dir" && as_dir=. |
| | 22760 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 22761 | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| | 22762 | ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib" |
| | 22763 | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| | 22764 | break 2 |
| | 22765 | fi |
| | 22766 | done |
| | 22767 | done |
| | 22768 | IFS=$as_save_IFS |
| | 22769 | |
| | 22770 | fi |
| | 22771 | fi |
| | 22772 | RANLIB=$ac_cv_prog_RANLIB |
| | 22773 | if test -n "$RANLIB"; then |
| | 22774 | { echo "$as_me:$LINENO: result: $RANLIB" >&5 |
| | 22775 | echo "${ECHO_T}$RANLIB" >&6; } |
| | 22776 | else |
| | 22777 | { echo "$as_me:$LINENO: result: no" >&5 |
| | 22778 | echo "${ECHO_T}no" >&6; } |
| | 22779 | fi |
| | 22780 | |
| | 22781 | |
| | 22782 | fi |
| | 22783 | if test -z "$ac_cv_prog_RANLIB"; then |
| | 22784 | ac_ct_RANLIB=$RANLIB |
| | 22785 | # Extract the first word of "ranlib", so it can be a program name with args. |
| | 22786 | set dummy ranlib; ac_word=$2 |
| | 22787 | { echo "$as_me:$LINENO: checking for $ac_word" >&5 |
| | 22788 | echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } |
| | 22789 | if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then |
| | 22790 | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| | 22791 | else |
| | 22792 | if test -n "$ac_ct_RANLIB"; then |
| | 22793 | ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test. |
| | 22794 | else |
| | 22795 | as_save_IFS=$IFS; IFS=$PATH_SEPARATOR |
| | 22796 | for as_dir in $PATH |
| | 22797 | do |
| | 22798 | IFS=$as_save_IFS |
| | 22799 | test -z "$as_dir" && as_dir=. |
| | 22800 | for ac_exec_ext in '' $ac_executable_extensions; do |
| | 22801 | if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then |
| | 22802 | ac_cv_prog_ac_ct_RANLIB="ranlib" |
| | 22803 | echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 |
| | 22804 | break 2 |
| | 22805 | fi |
| | 22806 | done |
| | 22807 | done |
| | 22808 | IFS=$as_save_IFS |
| | 22809 | |
| | 22810 | fi |
| | 22811 | fi |
| | 22812 | ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB |
| | 22813 | if test -n "$ac_ct_RANLIB"; then |
| | 22814 | { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5 |
| | 22815 | echo "${ECHO_T}$ac_ct_RANLIB" >&6; } |
| | 22816 | else |
| | 22817 | { echo "$as_me:$LINENO: result: no" >&5 |
| | 22818 | echo "${ECHO_T}no" >&6; } |
| | 22819 | fi |
| | 22820 | |
| | 22821 | if test "x$ac_ct_RANLIB" = x; then |
| | 22822 | RANLIB=":" |
| | 22823 | else |
| | 22824 | case $cross_compiling:$ac_tool_warned in |
| | 22825 | yes:) |
| | 22826 | { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools |
| | 22827 | whose name does not start with the host triplet. If you think this |
| | 22828 | configuration is useful to you, please write to autoconf@gnu.org." >&5 |
| | 22829 | echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools |
| | 22830 | whose name does not start with the host triplet. If you think this |
| | 22831 | configuration is useful to you, please write to autoconf@gnu.org." >&2;} |
| | 22832 | ac_tool_warned=yes ;; |
| | 22833 | esac |
| | 22834 | RANLIB=$ac_ct_RANLIB |
| | 22835 | fi |
| | 22836 | else |
| | 22837 | RANLIB="$ac_cv_prog_RANLIB" |
| | 22838 | fi |
| | 22839 | |
| | 22840 | |
| | 22841 | |
| | 22842 | |
| | 22843 | # Checks for header files. |
| | 22844 | { echo "$as_me:$LINENO: checking for ANSI C header files" >&5 |
| | 22845 | echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6; } |
| | 22846 | if test "${ac_cv_header_stdc+set}" = set; then |
| | 22847 | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| | 22848 | else |
| | 22849 | cat >conftest.$ac_ext <<_ACEOF |
| | 22850 | /* confdefs.h. */ |
| | 22851 | _ACEOF |
| | 22852 | cat confdefs.h >>conftest.$ac_ext |
| | 22853 | cat >>conftest.$ac_ext <<_ACEOF |
| | 22854 | /* end confdefs.h. */ |
| | 22855 | #include <stdlib.h> |
| | 22856 | #include <stdarg.h> |
| | 22857 | #include <string.h> |
| | 22858 | #include <float.h> |
| | 22859 | |
| | 22860 | int |
| | 22861 | main () |
| | 22862 | { |
| | 22863 | |
| | 22864 | ; |
| | 22865 | return 0; |
| | 22866 | } |
| | 22867 | _ACEOF |
| | 22868 | rm -f conftest.$ac_objext |
| | 22869 | if { (ac_try="$ac_compile" |
| | 22870 | case "(($ac_try" in |
| | 22871 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 22872 | *) ac_try_echo=$ac_try;; |
| | 22873 | esac |
| | 22874 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 22875 | (eval "$ac_compile") 2>conftest.er1 |
| | 22876 | ac_status=$? |
| | 22877 | grep -v '^ *+' conftest.er1 >conftest.err |
| | 22878 | rm -f conftest.er1 |
| | 22879 | cat conftest.err >&5 |
| | 22880 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 22881 | (exit $ac_status); } && { |
| | 22882 | test -z "$ac_c_werror_flag" || |
| | 22883 | test ! -s conftest.err |
| | 22884 | } && test -s conftest.$ac_objext; then |
| | 22885 | ac_cv_header_stdc=yes |
| | 22886 | else |
| | 22887 | echo "$as_me: failed program was:" >&5 |
| | 22888 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 22889 | |
| | 22890 | ac_cv_header_stdc=no |
| | 22891 | fi |
| | 22892 | |
| | 22893 | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| | 22894 | |
| | 22895 | if test $ac_cv_header_stdc = yes; then |
| | 22896 | # SunOS 4.x string.h does not declare mem*, contrary to ANSI. |
| | 22897 | cat >conftest.$ac_ext <<_ACEOF |
| | 22898 | /* confdefs.h. */ |
| | 22899 | _ACEOF |
| | 22900 | cat confdefs.h >>conftest.$ac_ext |
| | 22901 | cat >>conftest.$ac_ext <<_ACEOF |
| | 22902 | /* end confdefs.h. */ |
| | 22903 | #include <string.h> |
| | 22904 | |
| | 22905 | _ACEOF |
| | 22906 | if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | |
| | 22907 | $EGREP "memchr" >/dev/null 2>&1; then |
| | 22908 | : |
| | 22909 | else |
| | 22910 | ac_cv_header_stdc=no |
| | 22911 | fi |
| | 22912 | rm -f conftest* |
| | 22913 | |
| | 22914 | fi |
| | 22915 | |
| | 22916 | if test $ac_cv_header_stdc = yes; then |
| | 22917 | # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. |
| | 22918 | cat >conftest.$ac_ext <<_ACEOF |
| | 22919 | /* confdefs.h. */ |
| | 22920 | _ACEOF |
| | 22921 | cat confdefs.h >>conftest.$ac_ext |
| | 22922 | cat >>conftest.$ac_ext <<_ACEOF |
| | 22923 | /* end confdefs.h. */ |
| | 22924 | #include <stdlib.h> |
| | 22925 | |
| | 22926 | _ACEOF |
| | 22927 | if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | |
| | 22928 | $EGREP "free" >/dev/null 2>&1; then |
| | 22929 | : |
| | 22930 | else |
| | 22931 | ac_cv_header_stdc=no |
| | 22932 | fi |
| | 22933 | rm -f conftest* |
| | 22934 | |
| | 22935 | fi |
| | 22936 | |
| | 22937 | if test $ac_cv_header_stdc = yes; then |
| | 22938 | # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. |
| | 22939 | if test "$cross_compiling" = yes; then |
| | 22940 | : |
| | 22941 | else |
| | 22942 | cat >conftest.$ac_ext <<_ACEOF |
| | 22943 | /* confdefs.h. */ |
| | 22944 | _ACEOF |
| | 22945 | cat confdefs.h >>conftest.$ac_ext |
| | 22946 | cat >>conftest.$ac_ext <<_ACEOF |
| | 22947 | /* end confdefs.h. */ |
| | 22948 | #include <ctype.h> |
| | 22949 | #include <stdlib.h> |
| | 22950 | #if ((' ' & 0x0FF) == 0x020) |
| | 22951 | # define ISLOWER(c) ('a' <= (c) && (c) <= 'z') |
| | 22952 | # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) |
| | 22953 | #else |
| | 22954 | # define ISLOWER(c) \ |
| | 22955 | (('a' <= (c) && (c) <= 'i') \ |
| | 22956 | || ('j' <= (c) && (c) <= 'r') \ |
| | 22957 | || ('s' <= (c) && (c) <= 'z')) |
| | 22958 | # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) |
| | 22959 | #endif |
| | 22960 | |
| | 22961 | #define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) |
| | 22962 | int |
| | 22963 | main () |
| | 22964 | { |
| | 22965 | int i; |
| | 22966 | for (i = 0; i < 256; i++) |
| | 22967 | if (XOR (islower (i), ISLOWER (i)) |
| | 22968 | || toupper (i) != TOUPPER (i)) |
| | 22969 | return 2; |
| | 22970 | return 0; |
| | 22971 | } |
| | 22972 | _ACEOF |
| | 22973 | rm -f conftest$ac_exeext |
| | 22974 | if { (ac_try="$ac_link" |
| | 22975 | case "(($ac_try" in |
| | 22976 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 22977 | *) ac_try_echo=$ac_try;; |
| | 22978 | esac |
| | 22979 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 22980 | (eval "$ac_link") 2>&5 |
| | 22981 | ac_status=$? |
| | 22982 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 22983 | (exit $ac_status); } && { ac_try='./conftest$ac_exeext' |
| | 22984 | { (case "(($ac_try" in |
| | 22985 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 22986 | *) ac_try_echo=$ac_try;; |
| | 22987 | esac |
| | 22988 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 22989 | (eval "$ac_try") 2>&5 |
| | 22990 | ac_status=$? |
| | 22991 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 22992 | (exit $ac_status); }; }; then |
| | 22993 | : |
| | 22994 | else |
| | 22995 | echo "$as_me: program exited with status $ac_status" >&5 |
| | 22996 | echo "$as_me: failed program was:" >&5 |
| | 22997 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 22998 | |
| | 22999 | ( exit $ac_status ) |
| | 23000 | ac_cv_header_stdc=no |
| | 23001 | fi |
| | 23002 | rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext |
| | 23003 | fi |
| | 23004 | |
| | 23005 | |
| | 23006 | fi |
| | 23007 | fi |
| | 23008 | { echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5 |
| | 23009 | echo "${ECHO_T}$ac_cv_header_stdc" >&6; } |
| | 23010 | if test $ac_cv_header_stdc = yes; then |
| | 23011 | |
| | 23012 | cat >>confdefs.h <<\_ACEOF |
| | 23013 | #define STDC_HEADERS 1 |
| | 23014 | _ACEOF |
| | 23015 | |
| | 23016 | fi |
| | 23017 | |
| | 23018 | |
| | 23019 | |
| | 23020 | |
| | 23021 | |
| | 23022 | for ac_header in fcntl.h stdlib.h string.h unistd.h |
| | 23023 | do |
| | 23024 | as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` |
| | 23025 | if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then |
| | 23026 | { echo "$as_me:$LINENO: checking for $ac_header" >&5 |
| | 23027 | echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } |
| | 23028 | if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then |
| | 23029 | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| | 23030 | fi |
| | 23031 | ac_res=`eval echo '${'$as_ac_Header'}'` |
| | 23032 | { echo "$as_me:$LINENO: result: $ac_res" >&5 |
| | 23033 | echo "${ECHO_T}$ac_res" >&6; } |
| | 23034 | else |
| | 23035 | # Is the header compilable? |
| | 23036 | { echo "$as_me:$LINENO: checking $ac_header usability" >&5 |
| | 23037 | echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; } |
| | 23038 | cat >conftest.$ac_ext <<_ACEOF |
| | 23039 | /* confdefs.h. */ |
| | 23040 | _ACEOF |
| | 23041 | cat confdefs.h >>conftest.$ac_ext |
| | 23042 | cat >>conftest.$ac_ext <<_ACEOF |
| | 23043 | /* end confdefs.h. */ |
| | 23044 | $ac_includes_default |
| | 23045 | #include <$ac_header> |
| | 23046 | _ACEOF |
| | 23047 | rm -f conftest.$ac_objext |
| | 23048 | if { (ac_try="$ac_compile" |
| | 23049 | case "(($ac_try" in |
| | 23050 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 23051 | *) ac_try_echo=$ac_try;; |
| | 23052 | esac |
| | 23053 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 23054 | (eval "$ac_compile") 2>conftest.er1 |
| | 23055 | ac_status=$? |
| | 23056 | grep -v '^ *+' conftest.er1 >conftest.err |
| | 23057 | rm -f conftest.er1 |
| | 23058 | cat conftest.err >&5 |
| | 23059 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 23060 | (exit $ac_status); } && { |
| | 23061 | test -z "$ac_c_werror_flag" || |
| | 23062 | test ! -s conftest.err |
| | 23063 | } && test -s conftest.$ac_objext; then |
| | 23064 | ac_header_compiler=yes |
| | 23065 | else |
| | 23066 | echo "$as_me: failed program was:" >&5 |
| | 23067 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 23068 | |
| | 23069 | ac_header_compiler=no |
| | 23070 | fi |
| | 23071 | |
| | 23072 | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| | 23073 | { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 |
| | 23074 | echo "${ECHO_T}$ac_header_compiler" >&6; } |
| | 23075 | |
| | 23076 | # Is the header present? |
| | 23077 | { echo "$as_me:$LINENO: checking $ac_header presence" >&5 |
| | 23078 | echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; } |
| | 23079 | cat >conftest.$ac_ext <<_ACEOF |
| | 23080 | /* confdefs.h. */ |
| | 23081 | _ACEOF |
| | 23082 | cat confdefs.h >>conftest.$ac_ext |
| | 23083 | cat >>conftest.$ac_ext <<_ACEOF |
| | 23084 | /* end confdefs.h. */ |
| | 23085 | #include <$ac_header> |
| | 23086 | _ACEOF |
| | 23087 | if { (ac_try="$ac_cpp conftest.$ac_ext" |
| | 23088 | case "(($ac_try" in |
| | 23089 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 23090 | *) ac_try_echo=$ac_try;; |
| | 23091 | esac |
| | 23092 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 23093 | (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 |
| | 23094 | ac_status=$? |
| | 23095 | grep -v '^ *+' conftest.er1 >conftest.err |
| | 23096 | rm -f conftest.er1 |
| | 23097 | cat conftest.err >&5 |
| | 23098 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 23099 | (exit $ac_status); } >/dev/null && { |
| | 23100 | test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || |
| | 23101 | test ! -s conftest.err |
| | 23102 | }; then |
| | 23103 | ac_header_preproc=yes |
| | 23104 | else |
| | 23105 | echo "$as_me: failed program was:" >&5 |
| | 23106 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 23107 | |
| | 23108 | ac_header_preproc=no |
| | 23109 | fi |
| | 23110 | |
| | 23111 | rm -f conftest.err conftest.$ac_ext |
| | 23112 | { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 |
| | 23113 | echo "${ECHO_T}$ac_header_preproc" >&6; } |
| | 23114 | |
| | 23115 | # So? What about this header? |
| | 23116 | case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in |
| | 23117 | yes:no: ) |
| | 23118 | { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 |
| | 23119 | echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} |
| | 23120 | { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5 |
| | 23121 | echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;} |
| | 23122 | ac_header_preproc=yes |
| | 23123 | ;; |
| | 23124 | no:yes:* ) |
| | 23125 | { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 |
| | 23126 | echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} |
| | 23127 | { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 |
| | 23128 | echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} |
| | 23129 | { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5 |
| | 23130 | echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;} |
| | 23131 | { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5 |
| | 23132 | echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;} |
| | 23133 | { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 |
| | 23134 | echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} |
| | 23135 | { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5 |
| | 23136 | echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;} |
| | 23137 | ( cat <<\_ASBOX |
| | 23138 | ## ----------------------------------------- ## |
| | 23139 | ## Report this to alberto.botti@yoda2000.net ## |
| | 23140 | ## ----------------------------------------- ## |
| | 23141 | _ASBOX |
| | 23142 | ) | sed "s/^/$as_me: WARNING: /" >&2 |
| | 23143 | ;; |
| | 23144 | esac |
| | 23145 | { echo "$as_me:$LINENO: checking for $ac_header" >&5 |
| | 23146 | echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } |
| | 23147 | if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then |
| | 23148 | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| | 23149 | else |
| | 23150 | eval "$as_ac_Header=\$ac_header_preproc" |
| | 23151 | fi |
| | 23152 | ac_res=`eval echo '${'$as_ac_Header'}'` |
| | 23153 | { echo "$as_me:$LINENO: result: $ac_res" >&5 |
| | 23154 | echo "${ECHO_T}$ac_res" >&6; } |
| | 23155 | |
| | 23156 | fi |
| | 23157 | if test `eval echo '${'$as_ac_Header'}'` = yes; then |
| | 23158 | cat >>confdefs.h <<_ACEOF |
| | 23159 | #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 |
| | 23160 | _ACEOF |
| | 23161 | |
| | 23162 | fi |
| | 23163 | |
| | 23164 | done |
| | 23165 | |
| | 23166 | |
| | 23167 | |
| | 23168 | |
| | 23169 | # Checks for typedefs, structures, and compiler characteristics. |
| | 23170 | { echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5 |
| | 23171 | echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6; } |
| | 23172 | if test "${ac_cv_c_const+set}" = set; then |
| | 23173 | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| | 23174 | else |
| | 23175 | cat >conftest.$ac_ext <<_ACEOF |
| | 23176 | /* confdefs.h. */ |
| | 23177 | _ACEOF |
| | 23178 | cat confdefs.h >>conftest.$ac_ext |
| | 23179 | cat >>conftest.$ac_ext <<_ACEOF |
| | 23180 | /* end confdefs.h. */ |
| | 23181 | |
| | 23182 | int |
| | 23183 | main () |
| | 23184 | { |
| | 23185 | /* FIXME: Include the comments suggested by Paul. */ |
| | 23186 | #ifndef __cplusplus |
| | 23187 | /* Ultrix mips cc rejects this. */ |
| | 23188 | typedef int charset[2]; |
| | 23189 | const charset cs; |
| | 23190 | /* SunOS 4.1.1 cc rejects this. */ |
| | 23191 | char const *const *pcpcc; |
| | 23192 | char **ppc; |
| | 23193 | /* NEC SVR4.0.2 mips cc rejects this. */ |
| | 23194 | struct point {int x, y;}; |
| | 23195 | static struct point const zero = {0,0}; |
| | 23196 | /* AIX XL C 1.02.0.0 rejects this. |
| | 23197 | It does not let you subtract one const X* pointer from another in |
| | 23198 | an arm of an if-expression whose if-part is not a constant |
| | 23199 | expression */ |
| | 23200 | const char *g = "string"; |
| | 23201 | pcpcc = &g + (g ? g-g : 0); |
| | 23202 | /* HPUX 7.0 cc rejects these. */ |
| | 23203 | ++pcpcc; |
| | 23204 | ppc = (char**) pcpcc; |
| | 23205 | pcpcc = (char const *const *) ppc; |
| | 23206 | { /* SCO 3.2v4 cc rejects this. */ |
| | 23207 | char *t; |
| | 23208 | char const *s = 0 ? (char *) 0 : (char const *) 0; |
| | 23209 | |
| | 23210 | *t++ = 0; |
| | 23211 | if (s) return 0; |
| | 23212 | } |
| | 23213 | { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */ |
| | 23214 | int x[] = {25, 17}; |
| | 23215 | const int *foo = &x[0]; |
| | 23216 | ++foo; |
| | 23217 | } |
| | 23218 | { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */ |
| | 23219 | typedef const int *iptr; |
| | 23220 | iptr p = 0; |
| | 23221 | ++p; |
| | 23222 | } |
| | 23223 | { /* AIX XL C 1.02.0.0 rejects this saying |
| | 23224 | "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */ |
| | 23225 | struct s { int j; const int *ap[3]; }; |
| | 23226 | struct s *b; b->j = 5; |
| | 23227 | } |
| | 23228 | { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ |
| | 23229 | const int foo = 10; |
| | 23230 | if (!foo) return 0; |
| | 23231 | } |
| | 23232 | return !cs[0] && !zero.x; |
| | 23233 | #endif |
| | 23234 | |
| | 23235 | ; |
| | 23236 | return 0; |
| | 23237 | } |
| | 23238 | _ACEOF |
| | 23239 | rm -f conftest.$ac_objext |
| | 23240 | if { (ac_try="$ac_compile" |
| | 23241 | case "(($ac_try" in |
| | 23242 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 23243 | *) ac_try_echo=$ac_try;; |
| | 23244 | esac |
| | 23245 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 23246 | (eval "$ac_compile") 2>conftest.er1 |
| | 23247 | ac_status=$? |
| | 23248 | grep -v '^ *+' conftest.er1 >conftest.err |
| | 23249 | rm -f conftest.er1 |
| | 23250 | cat conftest.err >&5 |
| | 23251 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 23252 | (exit $ac_status); } && { |
| | 23253 | test -z "$ac_c_werror_flag" || |
| | 23254 | test ! -s conftest.err |
| | 23255 | } && test -s conftest.$ac_objext; then |
| | 23256 | ac_cv_c_const=yes |
| | 23257 | else |
| | 23258 | echo "$as_me: failed program was:" >&5 |
| | 23259 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 23260 | |
| | 23261 | ac_cv_c_const=no |
| | 23262 | fi |
| | 23263 | |
| | 23264 | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| | 23265 | fi |
| | 23266 | { echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5 |
| | 23267 | echo "${ECHO_T}$ac_cv_c_const" >&6; } |
| | 23268 | if test $ac_cv_c_const = no; then |
| | 23269 | |
| | 23270 | cat >>confdefs.h <<\_ACEOF |
| | 23271 | #define const |
| | 23272 | _ACEOF |
| | 23273 | |
| | 23274 | fi |
| | 23275 | |
| | 23276 | { echo "$as_me:$LINENO: checking for inline" >&5 |
| | 23277 | echo $ECHO_N "checking for inline... $ECHO_C" >&6; } |
| | 23278 | if test "${ac_cv_c_inline+set}" = set; then |
| | 23279 | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| | 23280 | else |
| | 23281 | ac_cv_c_inline=no |
| | 23282 | for ac_kw in inline __inline__ __inline; do |
| | 23283 | cat >conftest.$ac_ext <<_ACEOF |
| | 23284 | /* confdefs.h. */ |
| | 23285 | _ACEOF |
| | 23286 | cat confdefs.h >>conftest.$ac_ext |
| | 23287 | cat >>conftest.$ac_ext <<_ACEOF |
| | 23288 | /* end confdefs.h. */ |
| | 23289 | #ifndef __cplusplus |
| | 23290 | typedef int foo_t; |
| | 23291 | static $ac_kw foo_t static_foo () {return 0; } |
| | 23292 | $ac_kw foo_t foo () {return 0; } |
| | 23293 | #endif |
| | 23294 | |
| | 23295 | _ACEOF |
| | 23296 | rm -f conftest.$ac_objext |
| | 23297 | if { (ac_try="$ac_compile" |
| | 23298 | case "(($ac_try" in |
| | 23299 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 23300 | *) ac_try_echo=$ac_try;; |
| | 23301 | esac |
| | 23302 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 23303 | (eval "$ac_compile") 2>conftest.er1 |
| | 23304 | ac_status=$? |
| | 23305 | grep -v '^ *+' conftest.er1 >conftest.err |
| | 23306 | rm -f conftest.er1 |
| | 23307 | cat conftest.err >&5 |
| | 23308 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 23309 | (exit $ac_status); } && { |
| | 23310 | test -z "$ac_c_werror_flag" || |
| | 23311 | test ! -s conftest.err |
| | 23312 | } && test -s conftest.$ac_objext; then |
| | 23313 | ac_cv_c_inline=$ac_kw |
| | 23314 | else |
| | 23315 | echo "$as_me: failed program was:" >&5 |
| | 23316 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 23317 | |
| | 23318 | |
| | 23319 | fi |
| | 23320 | |
| | 23321 | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| | 23322 | test "$ac_cv_c_inline" != no && break |
| | 23323 | done |
| | 23324 | |
| | 23325 | fi |
| | 23326 | { echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5 |
| | 23327 | echo "${ECHO_T}$ac_cv_c_inline" >&6; } |
| | 23328 | |
| | 23329 | |
| | 23330 | case $ac_cv_c_inline in |
| | 23331 | inline | yes) ;; |
| | 23332 | *) |
| | 23333 | case $ac_cv_c_inline in |
| | 23334 | no) ac_val=;; |
| | 23335 | *) ac_val=$ac_cv_c_inline;; |
| | 23336 | esac |
| | 23337 | cat >>confdefs.h <<_ACEOF |
| | 23338 | #ifndef __cplusplus |
| | 23339 | #define inline $ac_val |
| | 23340 | #endif |
| | 23341 | _ACEOF |
| | 23342 | ;; |
| | 23343 | esac |
| | 23344 | |
| | 23345 | { echo "$as_me:$LINENO: checking for size_t" >&5 |
| | 23346 | echo $ECHO_N "checking for size_t... $ECHO_C" >&6; } |
| | 23347 | if test "${ac_cv_type_size_t+set}" = set; then |
| | 23348 | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| | 23349 | else |
| | 23350 | cat >conftest.$ac_ext <<_ACEOF |
| | 23351 | /* confdefs.h. */ |
| | 23352 | _ACEOF |
| | 23353 | cat confdefs.h >>conftest.$ac_ext |
| | 23354 | cat >>conftest.$ac_ext <<_ACEOF |
| | 23355 | /* end confdefs.h. */ |
| | 23356 | $ac_includes_default |
| | 23357 | typedef size_t ac__type_new_; |
| | 23358 | int |
| | 23359 | main () |
| | 23360 | { |
| | 23361 | if ((ac__type_new_ *) 0) |
| | 23362 | return 0; |
| | 23363 | if (sizeof (ac__type_new_)) |
| | 23364 | return 0; |
| | 23365 | ; |
| | 23366 | return 0; |
| | 23367 | } |
| | 23368 | _ACEOF |
| | 23369 | rm -f conftest.$ac_objext |
| | 23370 | if { (ac_try="$ac_compile" |
| | 23371 | case "(($ac_try" in |
| | 23372 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 23373 | *) ac_try_echo=$ac_try;; |
| | 23374 | esac |
| | 23375 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 23376 | (eval "$ac_compile") 2>conftest.er1 |
| | 23377 | ac_status=$? |
| | 23378 | grep -v '^ *+' conftest.er1 >conftest.err |
| | 23379 | rm -f conftest.er1 |
| | 23380 | cat conftest.err >&5 |
| | 23381 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 23382 | (exit $ac_status); } && { |
| | 23383 | test -z "$ac_c_werror_flag" || |
| | 23384 | test ! -s conftest.err |
| | 23385 | } && test -s conftest.$ac_objext; then |
| | 23386 | ac_cv_type_size_t=yes |
| | 23387 | else |
| | 23388 | echo "$as_me: failed program was:" >&5 |
| | 23389 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 23390 | |
| | 23391 | ac_cv_type_size_t=no |
| | 23392 | fi |
| | 23393 | |
| | 23394 | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| | 23395 | fi |
| | 23396 | { echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5 |
| | 23397 | echo "${ECHO_T}$ac_cv_type_size_t" >&6; } |
| | 23398 | if test $ac_cv_type_size_t = yes; then |
| | 23399 | : |
| | 23400 | else |
| | 23401 | |
| | 23402 | cat >>confdefs.h <<_ACEOF |
| | 23403 | #define size_t unsigned int |
| | 23404 | _ACEOF |
| | 23405 | |
| | 23406 | fi |
| | 23407 | |
| | 23408 | { echo "$as_me:$LINENO: checking for working volatile" >&5 |
| | 23409 | echo $ECHO_N "checking for working volatile... $ECHO_C" >&6; } |
| | 23410 | if test "${ac_cv_c_volatile+set}" = set; then |
| | 23411 | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| | 23412 | else |
| | 23413 | cat >conftest.$ac_ext <<_ACEOF |
| | 23414 | /* confdefs.h. */ |
| | 23415 | _ACEOF |
| | 23416 | cat confdefs.h >>conftest.$ac_ext |
| | 23417 | cat >>conftest.$ac_ext <<_ACEOF |
| | 23418 | /* end confdefs.h. */ |
| | 23419 | |
| | 23420 | int |
| | 23421 | main () |
| | 23422 | { |
| | 23423 | |
| | 23424 | volatile int x; |
| | 23425 | int * volatile y = (int *) 0; |
| | 23426 | return !x && !y; |
| | 23427 | ; |
| | 23428 | return 0; |
| | 23429 | } |
| | 23430 | _ACEOF |
| | 23431 | rm -f conftest.$ac_objext |
| | 23432 | if { (ac_try="$ac_compile" |
| | 23433 | case "(($ac_try" in |
| | 23434 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 23435 | *) ac_try_echo=$ac_try;; |
| | 23436 | esac |
| | 23437 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 23438 | (eval "$ac_compile") 2>conftest.er1 |
| | 23439 | ac_status=$? |
| | 23440 | grep -v '^ *+' conftest.er1 >conftest.err |
| | 23441 | rm -f conftest.er1 |
| | 23442 | cat conftest.err >&5 |
| | 23443 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 23444 | (exit $ac_status); } && { |
| | 23445 | test -z "$ac_c_werror_flag" || |
| | 23446 | test ! -s conftest.err |
| | 23447 | } && test -s conftest.$ac_objext; then |
| | 23448 | ac_cv_c_volatile=yes |
| | 23449 | else |
| | 23450 | echo "$as_me: failed program was:" >&5 |
| | 23451 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 23452 | |
| | 23453 | ac_cv_c_volatile=no |
| | 23454 | fi |
| | 23455 | |
| | 23456 | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| | 23457 | fi |
| | 23458 | { echo "$as_me:$LINENO: result: $ac_cv_c_volatile" >&5 |
| | 23459 | echo "${ECHO_T}$ac_cv_c_volatile" >&6; } |
| | 23460 | if test $ac_cv_c_volatile = no; then |
| | 23461 | |
| | 23462 | cat >>confdefs.h <<\_ACEOF |
| | 23463 | #define volatile |
| | 23464 | _ACEOF |
| | 23465 | |
| | 23466 | fi |
| | 23467 | |
| | 23468 | |
| | 23469 | |
| | 23470 | |
| | 23471 | # Checks for library functions. |
| | 23472 | |
| | 23473 | for ac_header in stdlib.h |
| | 23474 | do |
| | 23475 | as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` |
| | 23476 | if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then |
| | 23477 | { echo "$as_me:$LINENO: checking for $ac_header" >&5 |
| | 23478 | echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } |
| | 23479 | if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then |
| | 23480 | echo $ECHO_N "(cached) $ECHO_C" >&6 |
| | 23481 | fi |
| | 23482 | ac_res=`eval echo '${'$as_ac_Header'}'` |
| | 23483 | { echo "$as_me:$LINENO: result: $ac_res" >&5 |
| | 23484 | echo "${ECHO_T}$ac_res" >&6; } |
| | 23485 | else |
| | 23486 | # Is the header compilable? |
| | 23487 | { echo "$as_me:$LINENO: checking $ac_header usability" >&5 |
| | 23488 | echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; } |
| | 23489 | cat >conftest.$ac_ext <<_ACEOF |
| | 23490 | /* confdefs.h. */ |
| | 23491 | _ACEOF |
| | 23492 | cat confdefs.h >>conftest.$ac_ext |
| | 23493 | cat >>conftest.$ac_ext <<_ACEOF |
| | 23494 | /* end confdefs.h. */ |
| | 23495 | $ac_includes_default |
| | 23496 | #include <$ac_header> |
| | 23497 | _ACEOF |
| | 23498 | rm -f conftest.$ac_objext |
| | 23499 | if { (ac_try="$ac_compile" |
| | 23500 | case "(($ac_try" in |
| | 23501 | *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; |
| | 23502 | *) ac_try_echo=$ac_try;; |
| | 23503 | esac |
| | 23504 | eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 |
| | 23505 | (eval "$ac_compile") 2>conftest.er1 |
| | 23506 | ac_status=$? |
| | 23507 | grep -v '^ *+' conftest.er1 >conftest.err |
| | 23508 | rm -f conftest.er1 |
| | 23509 | cat conftest.err >&5 |
| | 23510 | echo "$as_me:$LINENO: \$? = $ac_status" >&5 |
| | 23511 | (exit $ac_status); } && { |
| | 23512 | test -z "$ac_c_werror_flag" || |
| | 23513 | test ! -s conftest.err |
| | 23514 | } && test -s conftest.$ac_objext; then |
| | 23515 | ac_header_compiler=yes |
| | 23516 | else |
| | 23517 | echo "$as_me: failed program was:" >&5 |
| | 23518 | sed 's/^/| /' conftest.$ac_ext >&5 |
| | 23519 | |
| | 23520 | ac_header_compiler=no |
| | 23521 | fi |
| | 23522 | |
| | 23523 | rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext |
| | 23524 | { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 |
