From: Akim Demaille Date: Wed, 1 Aug 2001 13:50:48 +0000 (+0000) Subject: * lib/autoconf/lang.m4 (AC_LANG(C), AC_LANG_C, _AC_LANG_ABBREV(C)) X-Git-Tag: AUTOCONF-2.52a~9 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=062d0c09dad2adebd184d5ae8532939250069982;p=thirdparty%2Fautoconf.git * lib/autoconf/lang.m4 (AC_LANG(C), AC_LANG_C, _AC_LANG_ABBREV(C)) (AC_LANG(C++), AC_LANG_CPLUSPLUS, _AC_LANG_ABBREV(C++)) (AC_LANG_SOURCE(C), AC_LANG_PROGRAM(C), AC_LANG_CALL(C)) (AC_LANG_FUNC_LINK_TRY(C), AC_LANG_BOOL_COMPILE_TRY(C)) (AC_LANG_INT_SAVE(C), _AC_ARG_VAR_CPPFLAGS, _AC_ARG_VAR_LDFLAGS) (AC_LANG_PREPROC(C), _AC_PROG_PREPROC_WORKS_IFELSE, AC_PROG_CPP) (AC_LANG_COMPILER(C), ac_cv_prog_gcc, AC_PROG_CC, _AC_PROG_CC_G) (AC_PROG_GCC_TRADITIONAL, AC_PROG_CC_C_O, AC_LANG_PREPROC(C++)) (AC_PROG_CXXCPP, AC_LANG_COMPILER(C++), ac_cv_prog_gxx) (AC_PROG_CXX, _AC_PROG_CXX_G, _AC_PROG_CXX_EXIT_DECLARATION) (AC_PROG_CC_STDC, AC_C_CROSS, AC_C_CHAR_UNSIGNED, AC_C_LONG_DOUBLE) (AC_C_BIGENDIAN, AC_C_INLINE, AC_C_CONST, AC_C_VOLATILE) (AC_C_STRINGIZE, AC_C_PROTOTYPES): Move to... * lib/autoconf/c.m4: here, new file. * lib/autoconf/lang.m4 (AC_LANG(Fortran 77), AC_LANG_FORTRAN77) (_AC_LANG_ABBREV(Fortran 77), AC_LANG_SOURCE(Fortran 77)) (AC_LANG_PROGRAM(Fortran 77), AC_LANG_CALL(Fortran 77)) (AC_LANG_PREPROC(Fortran 77), AC_LANG_COMPILER(Fortran 77)) (ac_cv_prog_g77, AC_PROG_F77, _AC_PROG_F77_G, AC_PROG_F77_C_O) (_AC_PROG_F77_V_OUTPUT, _AC_PROG_F77_V, AC_F77_LIBRARY_LDFLAGS) (AC_F77_DUMMY_MAIN, _AC_LANG_PROGRAM_C_F77_HOOKS, AC_F77_MAIN) (_AC_F77_NAME_MANGLING, AC_F77_NAME_MANGLING, AC_F77_WRAPPERS) (AC_F77_FUNC): Move to... * lib/autoconf/fortran.m4: here, new file. --- diff --git a/ChangeLog b/ChangeLog index 12820e805..9992c1fd4 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,31 @@ +2001-08-01 Akim Demaille + + * lib/autoconf/lang.m4 (AC_LANG(C), AC_LANG_C, _AC_LANG_ABBREV(C)) + (AC_LANG(C++), AC_LANG_CPLUSPLUS, _AC_LANG_ABBREV(C++)) + (AC_LANG_SOURCE(C), AC_LANG_PROGRAM(C), AC_LANG_CALL(C)) + (AC_LANG_FUNC_LINK_TRY(C), AC_LANG_BOOL_COMPILE_TRY(C)) + (AC_LANG_INT_SAVE(C), _AC_ARG_VAR_CPPFLAGS, _AC_ARG_VAR_LDFLAGS) + (AC_LANG_PREPROC(C), _AC_PROG_PREPROC_WORKS_IFELSE, AC_PROG_CPP) + (AC_LANG_COMPILER(C), ac_cv_prog_gcc, AC_PROG_CC, _AC_PROG_CC_G) + (AC_PROG_GCC_TRADITIONAL, AC_PROG_CC_C_O, AC_LANG_PREPROC(C++)) + (AC_PROG_CXXCPP, AC_LANG_COMPILER(C++), ac_cv_prog_gxx) + (AC_PROG_CXX, _AC_PROG_CXX_G, _AC_PROG_CXX_EXIT_DECLARATION) + (AC_PROG_CC_STDC, AC_C_CROSS, AC_C_CHAR_UNSIGNED, AC_C_LONG_DOUBLE) + (AC_C_BIGENDIAN, AC_C_INLINE, AC_C_CONST, AC_C_VOLATILE) + (AC_C_STRINGIZE, AC_C_PROTOTYPES): Move to... + * lib/autoconf/c.m4: here, new file. + + * lib/autoconf/lang.m4 (AC_LANG(Fortran 77), AC_LANG_FORTRAN77) + (_AC_LANG_ABBREV(Fortran 77), AC_LANG_SOURCE(Fortran 77)) + (AC_LANG_PROGRAM(Fortran 77), AC_LANG_CALL(Fortran 77)) + (AC_LANG_PREPROC(Fortran 77), AC_LANG_COMPILER(Fortran 77)) + (ac_cv_prog_g77, AC_PROG_F77, _AC_PROG_F77_G, AC_PROG_F77_C_O) + (_AC_PROG_F77_V_OUTPUT, _AC_PROG_F77_V, AC_F77_LIBRARY_LDFLAGS) + (AC_F77_DUMMY_MAIN, _AC_LANG_PROGRAM_C_F77_HOOKS, AC_F77_MAIN) + (_AC_F77_NAME_MANGLING, AC_F77_NAME_MANGLING, AC_F77_WRAPPERS) + (AC_F77_FUNC): Move to... + * lib/autoconf/fortran.m4: here, new file. + 2001-08-01 Akim Demaille * acfunctions.m4: Rename as... diff --git a/lib/autoconf/Makefile.am b/lib/autoconf/Makefile.am index b12079055..ff536ec8d 100644 --- a/lib/autoconf/Makefile.am +++ b/lib/autoconf/Makefile.am @@ -2,7 +2,8 @@ distautoconflibdir = $(pkgdatadir)/autoconf distautoconflib_DATA = autoconf.m4 \ - general.m4 oldnames.m4 specific.m4 lang.m4 \ + general.m4 oldnames.m4 specific.m4 \ + lang.m4 c.m4 fortran.m4 \ functions.m4 headers.m4 types.m4 nodistautoconflibdir = $(pkgdatadir)/autoconf # The order matters: we need version.m4 to build autoconf.m4f. diff --git a/lib/autoconf/Makefile.in b/lib/autoconf/Makefile.in index 4ef728ed3..07f40bdc6 100644 --- a/lib/autoconf/Makefile.in +++ b/lib/autoconf/Makefile.in @@ -67,7 +67,7 @@ PERL = @PERL@ VERSION = @VERSION@ distautoconflibdir = $(pkgdatadir)/autoconf -distautoconflib_DATA = autoconf.m4 general.m4 oldnames.m4 specific.m4 lang.m4 functions.m4 headers.m4 types.m4 +distautoconflib_DATA = autoconf.m4 general.m4 oldnames.m4 specific.m4 lang.m4 c.m4 fortran.m4 functions.m4 headers.m4 types.m4 nodistautoconflibdir = $(pkgdatadir)/autoconf # The order matters: we need version.m4 to build autoconf.m4f. diff --git a/lib/autoconf/autoconf.m4 b/lib/autoconf/autoconf.m4 index f650ac251..7aa399909 100644 --- a/lib/autoconf/autoconf.m4 +++ b/lib/autoconf/autoconf.m4 @@ -27,6 +27,8 @@ changequote()changequote([, ])include(m4sugar/m4sh.m4)# -*- Autoconf -*- m4_include([autoconf/version.m4]) m4_include([autoconf/general.m4]) m4_include([autoconf/lang.m4]) +m4_include([autoconf/c.m4]) +m4_include([autoconf/fortran.m4]) m4_include([autoconf/functions.m4]) m4_include([autoconf/headers.m4]) m4_include([autoconf/types.m4]) diff --git a/lib/autoconf/c.m4 b/lib/autoconf/c.m4 index 5f0d64e8d..ffcc7dae0 100644 --- a/lib/autoconf/c.m4 +++ b/lib/autoconf/c.m4 @@ -1,6 +1,6 @@ # This file is part of Autoconf. -*- Autoconf -*- # Programming languages support. -# Copyright 2000, 2001 +# Copyright 2001 # Free Software Foundation, Inc. # # This program is free software; you can redistribute it and/or modify @@ -50,146 +50,6 @@ # Roland McGrath, Noah Friedman, david d zuhn, and many others. -# Table of Contents: -# -# 1. Language selection -# and routines to produce programs in a given language. -# a. generic routines -# b. C -# c. C++ -# d. Fortran 77 -# -# 2. Producing programs in a given language. -# a. generic routines -# b. C -# c. C++ -# d. Fortran 77 -# -# 3. Looking for a compiler -# And possibly the associated preprocessor. -# a. Generic routines. -# b. C -# c. C++ -# d. Fortran 77 -# -# 4. Compilers' characteristics. -# a. Generic routines. -# b. C -# c. C++ -# d. Fortran 77 - - - -## ----------------------- ## -## 1. Language selection. ## -## ----------------------- ## - - - -# -------------------------------- # -# 1a. Generic language selection. # -# -------------------------------- # - -# AC_LANG_CASE(LANG1, IF-LANG1, LANG2, IF-LANG2, ..., DEFAULT) -# ------------------------------------------------------------ -# Expand into IF-LANG1 if the current language is LANG1 etc. else -# into default. -m4_define([AC_LANG_CASE], -[m4_case(_AC_LANG, $@)]) - - -# _AC_LANG_DISPATCH(MACRO, LANG, ARGS) -# ------------------------------------ -# Call the specialization of MACRO for LANG with ARGS. Complain if -# unavailable. -m4_define([_AC_LANG_DISPATCH], -[m4_ifdef([$1($2)], - [m4_indir([$1($2)], m4_shiftn(2, $@))], - [AC_FATAL([$1: unknown language: $2])])]) - - -# _AC_LANG_SET(OLD, NEW) -# ---------------------- -# Output the shell code needed to switch from OLD language to NEW language. -# Do not try to optimize like this: -# -# m4_defun([_AC_LANG_SET], -# [m4_if([$1], [$2], [], -# [_AC_LANG_DISPATCH([AC_LANG], [$2])])]) -# -# as it can introduce differences between the sh-current language and the -# m4-current-language when m4_require is used. Something more subtle -# might be possible, but at least for the time being, play it safe. -m4_defun([_AC_LANG_SET], -[_AC_LANG_DISPATCH([AC_LANG], [$2])]) - - -# AC_LANG(LANG) -# ------------- -# Set the current language to LANG. -m4_defun([AC_LANG], -[_AC_LANG_SET(m4_ifdef([_AC_LANG], [m4_defn([_AC_LANG])]), - [$1])dnl -m4_define([_AC_LANG], [$1])]) - - -# AC_LANG_PUSH(LANG) -# ------------------ -# Save the current language, and use LANG. -m4_defun([AC_LANG_PUSH], -[_AC_LANG_SET(m4_ifdef([_AC_LANG], [m4_defn([_AC_LANG])]), - [$1])dnl -m4_pushdef([_AC_LANG], [$1])]) - - -# AC_LANG_POP([LANG]) -# ------------------- -# If given, check that the current language is LANG, and restore the -# previous language. -m4_defun([AC_LANG_POP], -[m4_ifval([$1], - [m4_if([$1], m4_defn([_AC_LANG]), [], - [m4_fatal([$0($1): unexpected current language: ]m4_defn([_AC_LANG]))])])dnl -m4_pushdef([$0 OLD], m4_defn([_AC_LANG]))dnl -m4_popdef([_AC_LANG])dnl -_AC_LANG_SET(m4_defn([$0 OLD]), m4_defn([_AC_LANG]))dnl -m4_popdef([$0 OLD])dnl -]) - - -# AC_LANG_SAVE -# ------------ -# Save the current language, but don't change language. -AU_DEFUN([AC_LANG_SAVE], -[AC_DIAGNOSE([obsolete], - [instead of using `AC_LANG', `AC_LANG_SAVE', -and `AC_LANG_RESTORE', you should use `AC_LANG_PUSH' and `AC_LANG_POP'.]) -m4_pushdef([_AC_LANG], _AC_LANG)]) - - -# AC_LANG_RESTORE -# --------------- -# Restore the current language from the stack. -AU_DEFUN([AC_LANG_RESTORE], [AC_LANG_POP($@)]) - - -# _AC_LANG_ABBREV -# --------------- -# Return a short signature of _AC_LANG which can be used in shell -# variable names, or in M4 macro names. -m4_defun([_AC_LANG_ABBREV], -[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) - - -# AC_LANG_ASSERT(LANG) -# -------------------- -# Current language must be LANG. -m4_defun([AC_LANG_ASSERT], -[m4_if(_AC_LANG, $1, [], - [m4_fatal([$0: current language is not $1: ] _AC_LANG)])]) - - - # -------------------- # # 1b. The C language. # # -------------------- # @@ -244,29 +104,6 @@ AU_DEFUN([AC_LANG_CPLUSPLUS], [AC_LANG(C++)]) m4_define([_AC_LANG_ABBREV(C++)], [cxx]) -# ----------------------------- # -# 1d. The Fortran 77 language. # -# ----------------------------- # - - -# AC_LANG(Fortran 77) -# ------------------- -m4_define([AC_LANG(Fortran 77)], -[ac_ext=f -ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD' -ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD' -ac_compiler_gnu=$ac_cv_f77_compiler_gnu -]) - - -# AC_LANG_FORTRAN77 -# ----------------- -AU_DEFUN([AC_LANG_FORTRAN77], [AC_LANG(Fortran 77)]) - - -# _AC_LANG_ABBREV(Fortran 77) -# --------------------------- -m4_define([_AC_LANG_ABBREV(Fortran 77)], [f77]) @@ -275,69 +112,6 @@ m4_define([_AC_LANG_ABBREV(Fortran 77)], [f77]) ## ---------------------- ## -# ---------------------- # -# 2a. Generic routines. # -# ---------------------- # - - -# AC_LANG_CONFTEST(BODY) -# ---------------------- -# Save the BODY in `conftest.$ac_ext'. Add a trailing new line. -m4_define([AC_LANG_CONFTEST], -[cat >conftest.$ac_ext <<_ACEOF -$1 -_ACEOF]) - - -# AC_LANG_SOURCE(BODY) -# -------------------- -# Produce a valid source for the current language, which includes the -# BODY, and as much as possible `confdefs.h' and the `#line' sync -# lines. -AC_DEFUN([AC_LANG_SOURCE], -[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) - - -# AC_LANG_PROGRAM([PROLOGUE], [BODY]) -# ----------------------------------- -# Produce a valid source for the current language. Prepend the -# PROLOGUE (typically CPP directives and/or declarations) to an -# execution the BODY (typically glued inside the `main' function, or -# equivalent). -AC_DEFUN([AC_LANG_PROGRAM], -[AC_LANG_SOURCE([_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])]) - - -# AC_LANG_CALL(PROLOGUE, FUNCTION) -# -------------------------------- -# Call the FUNCTION. -AC_DEFUN([AC_LANG_CALL], -[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) - - -# AC_LANG_FUNC_LINK_TRY(FUNCTION) -# ------------------------------- -# Produce a source which links correctly iff the FUNCTION exists. -AC_DEFUN([AC_LANG_FUNC_LINK_TRY], -[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) - - -# AC_LANG_BOOL_COMPILE_TRY(PROLOGUE, EXPRESSION) -# ---------------------------------------------- -# Produce a program that compiles with success iff the boolean EXPRESSION -# evaluates to true at compile time. -AC_DEFUN([AC_LANG_BOOL_COMPILE_TRY], -[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) - - -# AC_LANG_INT_SAVE(PROLOGUE, EXPRESSION) -# -------------------------------------- -# Produce a program that saves the runtime evaluation of the integer -# EXPRESSION into `conftest.val'. -AC_DEFUN([AC_LANG_INT_SAVE], -[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) - - # --------------- # # 2b. C sources. # # --------------- # @@ -354,11 +128,14 @@ $1]) # AC_LANG_PROGRAM(C)([PROLOGUE], [BODY]) # -------------------------------------- -# If AC_F77_DUMMY_MAIN was run, then any C/C++ program might be linked -# against Fortran code, hence a dummy main might be needed. m4_define([AC_LANG_PROGRAM(C)], [$1 -m4_ifdef([_AC_LANG_PROGRAM_C_F77_HOOKS], [_AC_LANG_PROGRAM_C_F77_HOOKS()])dnl +#ifdef F77_DUMMY_MAIN +# ifdef __cplusplus + extern "C" +# endif + int F77_DUMMY_MAIN() { return 1; } +#endif int main () { @@ -469,342 +246,10 @@ m4_copy([AC_LANG_INT_SAVE(C)], [AC_LANG_INT_SAVE(C++)]) -# ------------------------ # -# 2d. Fortran 77 sources. # -# ------------------------ # - -# AC_LANG_SOURCE(Fortran 77)(BODY) -# -------------------------------- -# FIXME: Apparently, according to former AC_TRY_COMPILER, the CPP -# directives must not be included. But AC_TRY_RUN_NATIVE was not -# avoiding them, so? -m4_define([AC_LANG_SOURCE(Fortran 77)], -[$1]) - - -# AC_LANG_PROGRAM(Fortran 77)([PROLOGUE], [BODY]) -# ----------------------------------------------- -# Yes, we discard the PROLOGUE. -m4_define([AC_LANG_PROGRAM(Fortran 77)], -[m4_ifval([$1], - [m4_warn([syntax], [$0: ignoring PROLOGUE: $1])])dnl - program main -$2 - end]) - - -# AC_LANG_CALL(Fortran 77)(PROLOGUE, FUNCTION) -# -------------------------------------------- -# FIXME: This is a guess, help! -m4_define([AC_LANG_CALL(Fortran 77)], -[AC_LANG_PROGRAM([$1], -[ call $2])]) - - - - ## -------------------------------------------- ## ## 3. Looking for Compilers and Preprocessors. ## ## -------------------------------------------- ## -# ----------------------------------------------------- # -# 3a. Generic routines in compilers and preprocessors. # -# ----------------------------------------------------- # - -# AC_LANG_COMPILER -# ---------------- -# Find a compiler for the current LANG. Be sure to be run before -# AC_LANG_PREPROC. -# -# Note that because we might AC_REQUIRE `AC_LANG_COMPILER(C)' for -# instance, the latter must be AC_DEFUN'd, not just define'd. -m4_define([AC_LANG_COMPILER], -[AC_BEFORE([AC_LANG_COMPILER(]_AC_LANG[)], - [AC_LANG_PREPROC(]_AC_LANG[)])dnl -_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) - - -# AC_LANG_COMPILER_REQUIRE -# ------------------------ -# Ensure we have a compiler for the current LANG. -AC_DEFUN([AC_LANG_COMPILER_REQUIRE], -[m4_require([AC_LANG_COMPILER(]_AC_LANG[)], - [AC_LANG_COMPILER])]) - - - -# _AC_LANG_COMPILER_GNU -# --------------------- -# Check whether the compiler for the current language is GNU. -# -# It doesn't seem necessary right now to have a different source -# according to the current language, since this works fine. Some day -# it might be needed. Nevertheless, pay attention to the fact that -# the position of `choke me' on the seventh column is meant: otherwise -# some Fortran compilers (e.g., SGI) might consider it's a -# continuation line, and warn instead of reporting an error. -m4_define([_AC_LANG_COMPILER_GNU], -[AC_CACHE_CHECK([whether we are using the GNU _AC_LANG compiler], - [ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu], -[_AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[#ifndef __GNUC__ - choke me -#endif -]])], - [ac_compiler_gnu=yes], - [ac_compiler_gnu=no]) -ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu=$ac_compiler_gnu -])])# _AC_LANG_COMPILER_GNU - - -# AC_LANG_PREPROC -# --------------- -# Find a preprocessor for the current language. Note that because we -# might AC_REQUIRE `AC_LANG_PREPROC(C)' for instance, the latter must -# be AC_DEFUN'd, not just define'd. Since the preprocessor depends -# upon the compiler, look for the compiler. -m4_define([AC_LANG_PREPROC], -[AC_LANG_COMPILER_REQUIRE()dnl -_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) - - -# AC_LANG_PREPROC_REQUIRE -# ----------------------- -# Ensure we have a preprocessor for the current language. -AC_DEFUN([AC_LANG_PREPROC_REQUIRE], -[m4_require([AC_LANG_PREPROC(]_AC_LANG[)], - [AC_LANG_PREPROC])]) - - -# AC_REQUIRE_CPP -# -------------- -# Require the preprocessor for the current language. -# FIXME: AU_ALIAS once AC_LANG is officially documented (2.51?). -AC_DEFUN([AC_REQUIRE_CPP], -[AC_LANG_PREPROC_REQUIRE]) - - - -# AC_NO_EXECUTABLES -# ----------------- -# FIXME: The GCC team has specific needs which the current Autoconf -# framework cannot solve elegantly. This macro implements a dirty -# hack until Autoconf is abble to provide the services its users -# needs. -# -# Several of the support libraries that are often built with GCC can't -# assume the tool-chain is already capable of linking a program: the -# compiler often expects to be able to link with some of such -# libraries. -# -# In several of these libraries, work-arounds have been introduced to -# avoid the AC_PROG_CC_WORKS test, that would just abort their -# configuration. The introduction of AC_EXEEXT, enabled either by -# libtool or by CVS autoconf, have just made matters worse. -AC_DEFUN_ONCE([AC_NO_EXECUTABLES], -[m4_divert_push([KILL]) - -AC_BEFORE([$0], [_AC_COMPILER_EXEEXT_WORKS]) -AC_BEFORE([$0], [_AC_COMPILER_EXEEXT]) - -m4_define([_AC_COMPILER_EXEEXT_WORKS], -[cross_compiling=maybe -]) - -m4_define([_AC_COMPILER_EXEEXT], -[EXEEXT= -]) - -m4_define([AC_LINK_IFELSE], -[AC_FATAL([All the tests involving linking were disabled by $0])]) - -m4_divert_pop()dnl -])# AC_NO_EXECUTABLES - - - -# ----------------------------- # -# Computing EXEEXT and OBJEXT. # -# ----------------------------- # - - -# Files to ignore -# --------------- -# Ignore .d files produced by CFLAGS=-MD. -# -# On UWIN (which uses a cc wrapper for MSVC), the compiler also generates -# a .pdb file -# -# When the w32 free Borland C++ command line compiler links a program -# (conftest.exe), it also produces a file named `conftest.tds' in -# addition to `conftest.obj' - - -# We must not AU define them, because autoupdate would then remove -# them, which is right, but Automake 1.4 would remove the support for -# $(EXEEXT) etc. -# FIXME: Remove this once Automake fixed. -AC_DEFUN([AC_EXEEXT], []) -AC_DEFUN([AC_OBJEXT], []) - - -# _AC_COMPILER_EXEEXT_DEFAULT -# --------------------------- -# Check for the extension used for the default name for executables. -# Beware of `expr' that may return `0' or `'. Since this macro is -# the first one in touch with the compiler, it should also check that -# it compiles properly. -m4_define([_AC_COMPILER_EXEEXT_DEFAULT], -[# Try to create an executable without -o first, disregard a.out. -# It will help us diagnose broken compilers, and finding out an intuition -# of exeext. -AC_MSG_CHECKING([for _AC_LANG compiler default output]) -ac_link_default=`echo "$ac_link" | sed ['s/ -o *conftest[^ ]*//']` -AS_IF([AC_TRY_EVAL(ac_link_default)], -[# Find the output, starting from the most likely. This scheme is -# not robust to junk in `.', hence go to wildcards (a.*) only as a last -# resort. -for ac_file in `ls a.exe conftest.exe 2>/dev/null; - ls a.out conftest 2>/dev/null; - ls a.* conftest.* 2>/dev/null`; do - case $ac_file in - *.$ac_ext | *.o | *.obj | *.xcoff | *.tds | *.d | *.pdb ) ;; - a.out ) # We found the default executable, but exeext='' is most - # certainly right. - break;; - *.* ) ac_cv_exeext=`expr "$ac_file" : ['[^.]*\(\..*\)']` - # FIXME: I believe we export ac_cv_exeext for Libtool --akim. - export ac_cv_exeext - break;; - * ) break;; - esac -done], - [echo "$as_me: failed program was:" >&AS_MESSAGE_LOG_FD -cat conftest.$ac_ext >&AS_MESSAGE_LOG_FD -AC_MSG_ERROR([_AC_LANG compiler cannot create executables], 77)]) -ac_exeext=$ac_cv_exeext -AC_MSG_RESULT([$ac_file]) -])# _AC_COMPILER_EXEEXT_DEFAULT - - -# _AC_COMPILER_EXEEXT_WORKS -# ------------------------- -m4_define([_AC_COMPILER_EXEEXT_WORKS], -[# Check the compiler produces executables we can run. If not, either -# the compiler is broken, or we cross compile. -AC_MSG_CHECKING([whether the _AC_LANG compiler works]) -# FIXME: These cross compiler hacks should be removed for Autoconf 3.0 -# If not cross compiling, check that we can run a simple program. -if test "$cross_compiling" != yes; then - if AC_TRY_COMMAND([./$ac_file]); then - cross_compiling=no - else - if test "$cross_compiling" = maybe; then - cross_compiling=yes - else - AC_MSG_ERROR([cannot run _AC_LANG compiled programs. -If you meant to cross compile, use `--host'.]) - fi - fi -fi -AC_MSG_RESULT([yes]) -])# _AC_COMPILER_EXEEXT_WORKS - - -# _AC_COMPILER_EXEEXT_CROSS -# ------------------------- -m4_define([_AC_COMPILER_EXEEXT_CROSS], -[# Check the compiler produces executables we can run. If not, either -# the compiler is broken, or we cross compile. -AC_MSG_CHECKING([whether we are cross compiling]) -AC_MSG_RESULT([$cross_compiling]) -])# _AC_COMPILER_EXEEXT_CROSS - - -# _AC_COMPILER_EXEEXT_O -# --------------------- -# Check for the extension used when `-o foo'. Try to see if ac_cv_exeext, -# as computed by _AC_COMPILER_EXEEXT_DEFAULT is OK. -m4_define([_AC_COMPILER_EXEEXT_O], -[AC_MSG_CHECKING([for executable suffix]) -AS_IF([AC_TRY_EVAL(ac_link)], -[# If both `conftest.exe' and `conftest' are `present' (well, observable) -# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will -# work properly (i.e., refer to `conftest.exe'), while it won't with -# `rm'. -for ac_file in `(ls conftest.exe; ls conftest; ls conftest.*) 2>/dev/null`; do - case $ac_file in - *.$ac_ext | *.o | *.obj | *.xcoff | *.tds | *.d | *.pdb ) ;; - *.* ) ac_cv_exeext=`expr "$ac_file" : ['[^.]*\(\..*\)']` - export ac_cv_exeext - break;; - * ) break;; - esac -done], - [AC_MSG_ERROR([cannot compute EXEEXT: cannot compile and link])]) -rm -f conftest$ac_cv_exeext -AC_MSG_RESULT([$ac_cv_exeext]) -])# _AC_COMPILER_EXEEXT_O - - -# _AC_COMPILER_EXEEXT -# ------------------- -# Check for the extension used for executables. It compiles a test -# executable. If this is called, the executable extensions will be -# automatically used by link commands run by the configure script. -# -# Note that some compilers (cross or not), strictly obey to `-o foo' while -# the host requires `foo.exe', so we should not depend upon `-o' to -# test EXEEXT. But then, be sure no to destroy user files. -# -# Must be run before _AC_COMPILER_OBJEXT because _AC_COMPILER_EXEEXT_DEFAULT -# checks whether the compiler works. -m4_define([_AC_COMPILER_EXEEXT], -[AC_LANG_CONFTEST([AC_LANG_PROGRAM()]) -ac_clean_files_save=$ac_clean_files -ac_clean_files="$ac_clean_files a.out a.exe" -_AC_COMPILER_EXEEXT_DEFAULT -_AC_COMPILER_EXEEXT_WORKS -rm -f a.out a.exe conftest$ac_cv_exeext -ac_clean_files=$ac_clean_files_save -_AC_COMPILER_EXEEXT_CROSS -_AC_COMPILER_EXEEXT_O -rm -f conftest.$ac_ext -AC_SUBST([EXEEXT], [$ac_cv_exeext])dnl -ac_exeext=$EXEEXT -])# _AC_COMPILER_EXEEXT - - -# _AC_COMPILER_OBJEXT -# ------------------- -# Check the object extension used by the compiler: typically `.o' or -# `.obj'. If this is called, some other behaviour will change, -# determined by ac_objext. -# -# This macro is called by AC_LANG_COMPILER, the latter being required -# by the AC_COMPILE_IFELSE macros, so use _AC_COMPILE_IFELSE. And in fact, -# don't, since _AC_COMPILE_IFELSE needs to know ac_objext for the `test -s' -# it includes. So do it by hand. -m4_define([_AC_COMPILER_OBJEXT], -[AC_CACHE_CHECK([for object suffix], ac_cv_objext, -[AC_LANG_CONFTEST([AC_LANG_PROGRAM()]) -rm -f conftest.o conftest.obj -AS_IF([AC_TRY_EVAL(ac_compile)], -[for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do - case $ac_file in - *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb ) ;; - *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` - break;; - esac -done], - [echo "$as_me: failed program was:" >&AS_MESSAGE_LOG_FD -cat conftest.$ac_ext >&AS_MESSAGE_LOG_FD -AC_MSG_ERROR([cannot compute OBJEXT: cannot compile])]) -rm -f conftest.$ac_cv_objext conftest.$ac_ext]) -AC_SUBST([OBJEXT], [$ac_cv_objext])dnl -ac_objext=$OBJEXT -])# _AC_COMPILER_OBJEXT - - # -------------------- # # 3b. The C compiler. # # -------------------- # @@ -1242,152 +687,6 @@ fi ])# _AC_PROG_CXX_EXIT_DECLARATION -# ----------------------------- # -# 3d. The Fortran 77 compiler. # -# ----------------------------- # - - -# AC_LANG_PREPROC(Fortran 77) -# --------------------------- -# Find the Fortran 77 preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. -AC_DEFUN([AC_LANG_PREPROC(Fortran 77)], -[m4_warn([syntax], - [$0: No preprocessor defined for ]_AC_LANG)]) - - -# AC_LANG_COMPILER(Fortran 77) -# ---------------------------- -# Find the Fortran 77 compiler. Must be AC_DEFUN'd to be -# AC_REQUIRE'able. -AC_DEFUN([AC_LANG_COMPILER(Fortran 77)], -[AC_REQUIRE([AC_PROG_F77])]) - - -# ac_cv_prog_g77 -# -------------- -# We used to name the cache variable this way. -AU_DEFUN([ac_cv_prog_g77], -[ac_cv_f77_compiler_gnu]) - - -# AC_PROG_F77([COMPILERS...]) -# --------------------------- -# COMPILERS is a space separated list of Fortran 77 compilers to search -# for. -# Fortran 95 isn't strictly backwards-compatiable with Fortran 77, but -# `f95' is worth trying. -# -# Compilers are ordered by -# 1. F77, F90, F95 -# 2. Good/tested native compilers, bad/untested native compilers -# 3. Wrappers around f2c go last. -# -# `fort77' and `fc' are wrappers around `f2c', `fort77' being better. -# It is believed that under HP-UX `fort77' is the name of the native -# compiler. On some Cray systems, fort77 is a native compiler. -# cf77 and cft77 are (older) Cray F77 compilers. -# frt is the Fujitsu F77 compiler. -# pgf77 and pgf90 are the Portland Group F77 and F90 compilers. -# xlf/xlf90/xlf95 are IBM (AIX) F77/F90/F95 compilers. -# lf95 is the Lahey-Fujitsu compiler. -# fl32 is the Microsoft Fortran "PowerStation" compiler. -# af77 is the Apogee F77 compiler for Intergraph hardware running CLIX. -# epcf90 is the "Edinburgh Portable Compiler" F90. -# fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha. -AC_DEFUN([AC_PROG_F77], -[AC_LANG_PUSH(Fortran 77)dnl -AC_ARG_VAR([F77], [Fortran 77 compiler command])dnl -AC_ARG_VAR([FFLAGS], [Fortran 77 compiler flags])dnl -_AC_ARG_VAR_LDFLAGS()dnl -AC_CHECK_TOOLS(F77, - [m4_default([$1], - [g77 f77 xlf cf77 cft77 frt pgf77 fl32 af77 fort77 f90 xlf90 pgf90 epcf90 f95 fort xlf95 lf95 g95 fc])]) - -# Provide some information about the compiler. -echo "$as_me:__oline__:" \ - "checking for _AC_LANG compiler version" >&AS_MESSAGE_LOG_FD -ac_compiler=`set X $ac_compile; echo $[2]` -_AC_EVAL([$ac_compiler --version &AS_MESSAGE_LOG_FD]) -_AC_EVAL([$ac_compiler -v &AS_MESSAGE_LOG_FD]) -_AC_EVAL([$ac_compiler -V &AS_MESSAGE_LOG_FD]) - -m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl -m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl -# If we don't use `.F' as extension, the preprocessor is not run on the -# input file. -ac_save_ext=$ac_ext -ac_ext=F -_AC_LANG_COMPILER_GNU -ac_ext=$ac_save_ext -G77=`test $ac_compiler_gnu = yes && echo yes` -_AC_PROG_F77_G -AC_LANG_POP(Fortran 77)dnl -])# AC_PROG_F77 - - -# _AC_PROG_F77_G -# -------------- -# Check whether -g works, even if FFLAGS is set, in case the package -# plays around with FFLAGS (such as to build both debugging and normal -# versions of a library), tasteless as that idea is. -m4_define([_AC_PROG_F77_G], -[ac_test_FFLAGS=${FFLAGS+set} -ac_save_FFLAGS=$FFLAGS -FFLAGS= -AC_CACHE_CHECK(whether $F77 accepts -g, ac_cv_prog_f77_g, -[FFLAGS=-g -_AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], -[ac_cv_prog_f77_g=yes], -[ac_cv_prog_f77_g=no]) -]) -if test "$ac_test_FFLAGS" = set; then - FFLAGS=$ac_save_FFLAGS -elif test $ac_cv_prog_f77_g = yes; then - if test "$G77" = yes; then - FFLAGS="-g -O2" - else - FFLAGS="-g" - fi -else - if test "$G77" = yes; then - FFLAGS="-O2" - else - FFLAGS= - fi -fi[]dnl -])# _AC_PROG_F77_G - - -# AC_PROG_F77_C_O -# --------------- -# Test if the Fortran 77 compiler accepts the options `-c' and `-o' -# simultaneously, and define `F77_NO_MINUS_C_MINUS_O' if it does not. -# -# The usefulness of this macro is questionable, as I can't really see -# why anyone would use it. The only reason I include it is for -# completeness, since a similar test exists for the C compiler. -AC_DEFUN([AC_PROG_F77_C_O], -[AC_REQUIRE([AC_PROG_F77])dnl -AC_CACHE_CHECK([whether $F77 understand -c and -o together], - [ac_cv_prog_f77_c_o], -[AC_LANG_CONFTEST([AC_LANG_PROGRAM([])]) -# We test twice because some compilers refuse to overwrite an existing -# `.o' file with `-o', although they will create one. -ac_try='$F77 $FFLAGS -c conftest.$ac_ext -o conftest.$ac_objext >&AS_MESSAGE_LOG_FD' -if AC_TRY_EVAL(ac_try) && - test -f conftest.$ac_objext && - AC_TRY_EVAL(ac_try); then - ac_cv_prog_f77_c_o=yes -else - ac_cv_prog_f77_c_o=no -fi -rm -f conftest*]) -if test $ac_cv_prog_f77_c_o = no; then - AC_DEFINE(F77_NO_MINUS_C_MINUS_O, 1, - [Define if your Fortran 77 compiler doesn't accept -c and -o together.]) -fi -])# AC_PROG_F77_C_O - @@ -1724,462 +1023,3 @@ else AC_MSG_RESULT([no]) fi ])# AC_C_PROTOTYPES - - - - -# ---------------------------------------- # -# 4d. Fortan 77 compiler characteristics. # -# ---------------------------------------- # - - -# _AC_PROG_F77_V_OUTPUT([FLAG = $ac_cv_prog_f77_v]) -# ------------------------------------------------- -# Link a trivial Fortran program, compiling with a verbose output FLAG -# (which default value, $ac_cv_prog_f77_v, is computed by -# _AC_PROG_F77_V), and return the output in $ac_f77_v_output. This -# output is processed in the way expected by AC_F77_LIBRARY_LDFLAGS, -# so that any link flags that are echoed by the compiler appear as -# space-separated items. -AC_DEFUN([_AC_PROG_F77_V_OUTPUT], -[AC_REQUIRE([AC_PROG_F77])dnl -AC_LANG_PUSH(Fortran 77)dnl - -AC_LANG_CONFTEST([AC_LANG_PROGRAM([])]) - -# Compile and link our simple test program by passing a flag (argument -# 1 to this macro) to the Fortran 77 compiler in order to get -# "verbose" output that we can then parse for the Fortran 77 linker -# flags. -ac_save_FFLAGS=$FFLAGS -FFLAGS="$FFLAGS m4_default([$1], [$ac_cv_prog_f77_v])" -(eval echo $as_me:__oline__: \"$ac_link\") >&AS_MESSAGE_LOG_FD -ac_f77_v_output=`eval $ac_link AS_MESSAGE_LOG_FD>&1 2>&1 | grep -v 'Driving:'` -echo "$ac_f77_v_output" >&AS_MESSAGE_LOG_FD -FFLAGS=$ac_save_FFLAGS - -rm -f conftest* -AC_LANG_POP(Fortran 77)dnl - -# If we are using xlf then replace all the commas with spaces. -if echo $ac_f77_v_output | grep xlfentry >/dev/null 2>&1; then - ac_f77_v_output=`echo $ac_f77_v_output | sed 's/,/ /g'` -fi - -# If we are using Cray Fortran then delete quotes. -# Use "\"" instead of '"' for font-lock-mode. -# FIXME: a more general fix for quoted arguments with spaces? -if echo $ac_f77_v_output | grep cft90 >/dev/null 2>&1; then - ac_f77_v_output=`echo $ac_f77_v_output | sed "s/\"//g"` -fi[]dnl -])# _AC_PROG_F77_V_OUTPUT - - -# _AC_PROG_F77_V -# -------------- -# -# Determine the flag that causes the Fortran 77 compiler to print -# information of library and object files (normally -v) -# Needed for AC_F77_LIBRARY_FLAGS -# Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###) -AC_DEFUN([_AC_PROG_F77_V], -[AC_CACHE_CHECK([how to get verbose linking output from $F77], - [ac_cv_prog_f77_v], -[AC_LANG_ASSERT(Fortran 77) -AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], -[ac_cv_prog_f77_v= -# Try some options frequently used verbose output -for ac_verb in -v -verbose --verbose -V -\#\#\#; do - _AC_PROG_F77_V_OUTPUT($ac_verb) - # look for -l* and *.a constructs in the output - for ac_arg in $ac_f77_v_output; do - case $ac_arg in - [[\\/]]*.a | ?:[[\\/]]*.a | -[[lLRu]]*) - ac_cv_prog_f77_v=$ac_verb - break 2 ;; - esac - done -done -if test -z "$ac_cv_prog_f77_v"; then - AC_MSG_WARN([cannot determine how to obtain linking information from $F77]) -fi], - [AC_MSG_WARN([compilation failed])]) -])])# _AC_PROG_F77_V - - -# AC_F77_LIBRARY_LDFLAGS -# ---------------------- -# -# Determine the linker flags (e.g. "-L" and "-l") for the Fortran 77 -# intrinsic and run-time libraries that are required to successfully -# link a Fortran 77 program or shared library. The output variable -# FLIBS is set to these flags. -# -# This macro is intended to be used in those situations when it is -# necessary to mix, e.g. C++ and Fortran 77, source code into a single -# program or shared library. -# -# For example, if object files from a C++ and Fortran 77 compiler must -# be linked together, then the C++ compiler/linker must be used for -# linking (since special C++-ish things need to happen at link time -# like calling global constructors, instantiating templates, enabling -# exception support, etc.). -# -# However, the Fortran 77 intrinsic and run-time libraries must be -# linked in as well, but the C++ compiler/linker doesn't know how to -# add these Fortran 77 libraries. Hence, the macro -# "AC_F77_LIBRARY_LDFLAGS" was created to determine these Fortran 77 -# libraries. -# -# This macro was packaged in its current form by Matthew D. Langston. -# However, nearly all of this macro came from the "OCTAVE_FLIBS" macro -# in "octave-2.0.13/aclocal.m4", and full credit should go to John -# W. Eaton for writing this extremely useful macro. Thank you John. -AC_DEFUN([AC_F77_LIBRARY_LDFLAGS], -[AC_LANG_PUSH(Fortran 77)dnl -_AC_PROG_F77_V -AC_CACHE_CHECK([for Fortran 77 libraries], ac_cv_flibs, -[if test "x$FLIBS" != "x"; then - ac_cv_flibs="$FLIBS" # Let the user override the test. -else - -_AC_PROG_F77_V_OUTPUT - -ac_cv_flibs= - -# Save positional arguments (if any) -ac_save_positional="$[@]" - -set X $ac_f77_v_output -while test $[@%:@] != 1; do - shift - ac_arg=$[1] - case $ac_arg in - [[\\/]]*.a | ?:[[\\/]]*.a) - AC_LIST_MEMBER_OF($ac_arg, $ac_cv_flibs, , - ac_cv_flibs="$ac_cv_flibs $ac_arg") - ;; - -bI:*) - AC_LIST_MEMBER_OF($ac_arg, $ac_cv_flibs, , - [AC_LINKER_OPTION([$ac_arg], ac_cv_flibs)]) - ;; - # Ignore these flags. - -lang* | -lcrt0.o | -lc | -lgcc | -libmil | -LANG:=*) - ;; - -lkernel32) - test x"$CYGWIN" != xyes && ac_cv_flibs="$ac_cv_flibs $ac_arg" - ;; - -[[LRuY]]) - # These flags, when seen by themselves, take an argument. - # We remove the space between option and argument and re-iterate - # unless we find an empty arg or a new option (starting with -) - case $[2] in - "" | -*);; - *) - ac_arg="$ac_arg$[2]" - shift; shift - set X $ac_arg "$[@]" - ;; - esac - ;; - -YP,*) - for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do - AC_LIST_MEMBER_OF($ac_j, $ac_cv_flibs, , - [ac_arg="$ac_arg $ac_j" - ac_cv_flibs="$ac_cv_flibs $ac_j"]) - done - ;; - -[[lLR]]*) - AC_LIST_MEMBER_OF($ac_arg, $ac_cv_flibs, , - ac_cv_flibs="$ac_cv_flibs $ac_arg") - ;; - # Ignore everything else. - esac -done -# restore positional arguments -set X $ac_save_positional; shift - -# We only consider "LD_RUN_PATH" on Solaris systems. If this is seen, -# then we insist that the "run path" must be an absolute path (i.e. it -# must begin with a "/"). -case `(uname -sr) 2>/dev/null` in - "SunOS 5"*) - ac_ld_run_path=`echo $ac_f77_v_output | - sed -n 's,^.*LD_RUN_PATH *= *\(/[[^ ]]*\).*$,-R\1,p'` - test "x$ac_ld_run_path" != x && - AC_LINKER_OPTION([$ac_ld_run_path], ac_cv_flibs) - ;; -esac -fi # test "x$FLIBS" = "x" -]) -FLIBS="$ac_cv_flibs" -AC_SUBST(FLIBS) -AC_LANG_POP(Fortran 77)dnl -])# AC_F77_LIBRARY_LDFLAGS - - -# AC_F77_DUMMY_MAIN([ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) -# ----------------------------------------------------------- -# -# Detect name of dummy main routine required by the Fortran libraries, -# (if any) and define F77_DUMMY_MAIN to this name (which should be -# used for a dummy declaration, if it is defined). On some systems, -# linking a C program to the Fortran library does not work unless you -# supply a dummy function called something like MAIN__. -# -# Execute ACTION-IF-NOT-FOUND if no way of successfully linking a C -# program with the F77 libs is found; default to exiting with an error -# message. Execute ACTION-IF-FOUND if a dummy routine name is needed -# and found or if it is not needed (default to defining F77_DUMMY_MAIN -# when needed). -# -# What is technically happening is that the Fortran libraries provide -# their own main() function, which usually initializes Fortran I/O and -# similar stuff, and then calls MAIN__, which is the entry point of -# your program. Usually, a C program will override this with its own -# main() routine, but the linker sometimes complain if you don't -# provide a dummy (never-called) MAIN__ routine anyway. -# -# Of course, programs that want to allow Fortran subroutines to do -# I/O, etcetera, should call their main routine MAIN__() (or whatever) -# instead of main(). A separate autoconf test (AC_F77_MAIN) checks -# for the routine to use in this case (since the semantics of the test -# are slightly different). To link to e.g. purely numerical -# libraries, this is normally not necessary, however, and most C/C++ -# programs are reluctant to turn over so much control to Fortran. =) -# -# The name variants we check for are (in order): -# MAIN__ (g77, MAIN__ required on some systems; IRIX, MAIN__ optional) -# MAIN_, __main (SunOS) -# MAIN _MAIN __MAIN main_ main__ _main (we follow DDD and try these too) -AC_DEFUN([AC_F77_DUMMY_MAIN], -[AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl -m4_define([_AC_LANG_PROGRAM_C_F77_HOOKS], -[#ifdef F77_DUMMY_MAIN -# ifdef __cplusplus - extern "C" -# endif - int F77_DUMMY_MAIN() { return 1; } -#endif -]) -AC_CACHE_CHECK([for dummy main to link with Fortran 77 libraries], - ac_cv_f77_dummy_main, -[AC_LANG_PUSH(C)dnl - ac_f77_dm_save_LIBS=$LIBS - LIBS="$LIBS $FLIBS" - - # First, try linking without a dummy main: - AC_TRY_LINK([], [], - ac_cv_f77_dummy_main=none, - ac_cv_f77_dummy_main=unknown) - - if test $ac_cv_f77_dummy_main = unknown; then - for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do - AC_TRY_LINK([@%:@define F77_DUMMY_MAIN $ac_func], - [], [ac_cv_f77_dummy_main=$ac_func; break]) - done - fi - rm -f conftest* - LIBS=$ac_f77_dm_save_LIBS - AC_LANG_POP(C)dnl -]) -F77_DUMMY_MAIN=$ac_cv_f77_dummy_main -AS_IF([test "$F77_DUMMY_MAIN" != unknown], - [m4_default([$1], -[if test $F77_DUMMY_MAIN != none; then - AC_DEFINE_UNQUOTED([F77_DUMMY_MAIN], $F77_DUMMY_MAIN, - [Define to dummy `main' function (if any) required to - link to the Fortran 77 libraries.]) -fi])], - [m4_default([$2], - [AC_MSG_ERROR([Linking to Fortran libraries from C fails.])])]) -])# AC_F77_DUMMY_MAIN - - -# AC_F77_MAIN -# ----------- -# Define F77_MAIN to name of alternate main() function for use with -# the Fortran libraries. (Typically, the libraries may define their -# own main() to initialize I/O, etcetera, that then call your own -# routine called MAIN__ or whatever.) See AC_F77_DUMMY_MAIN, above. -# If no such alternate name is found, just define F77_MAIN to main. -# -AC_DEFUN([AC_F77_MAIN], -[AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl -AC_CACHE_CHECK([for alternate main to link with Fortran 77 libraries], - ac_cv_f77_main, -[AC_LANG_PUSH(C)dnl - ac_f77_m_save_LIBS=$LIBS - LIBS="$LIBS $FLIBS" - ac_cv_f77_main="main" # default entry point name - - for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do - AC_TRY_LINK([#undef F77_DUMMY_MAIN -@%:@define main $ac_func], [], [ac_cv_f77_main=$ac_func; break]) - done - rm -f conftest* - LIBS=$ac_f77_m_save_LIBS - AC_LANG_POP(C)dnl -]) -AC_DEFINE_UNQUOTED([F77_MAIN], $ac_cv_f77_main, - [Define to alternate name for `main' routine that is - called from a `main' in the Fortran libraries.]) -])# AC_F77_MAIN - - -# _AC_F77_NAME_MANGLING -# --------------------- -# Test for the name mangling scheme used by the Fortran 77 compiler. -# -# Sets ac_cv_f77_mangling. The value contains three fields, separated -# by commas: -# -# lower case / upper case: -# case translation of the Fortan 77 symbols -# underscore / no underscore: -# whether the compiler appends "_" to symbol names -# extra underscore / no extra underscore: -# whether the compiler appends an extra "_" to symbol names already -# containing at least one underscore -# -AC_DEFUN([_AC_F77_NAME_MANGLING], -[AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl -AC_REQUIRE([AC_F77_DUMMY_MAIN])dnl -AC_CACHE_CHECK([for Fortran 77 name-mangling scheme], - ac_cv_f77_mangling, -[AC_LANG_PUSH(Fortran 77)dnl -AC_COMPILE_IFELSE( -[ subroutine foobar() - return - end - subroutine foo_bar() - return - end], -[mv conftest.$ac_objext cf77_test.$ac_objext - - AC_LANG_PUSH(C)dnl - - ac_save_LIBS=$LIBS - LIBS="cf77_test.$ac_objext $LIBS $FLIBS" - - ac_success=no - for ac_foobar in foobar FOOBAR; do - for ac_underscore in "" "_"; do - ac_func="$ac_foobar$ac_underscore" - AC_TRY_LINK_FUNC($ac_func, - [ac_success=yes; break 2]) - done - done - - if test "$ac_success" = "yes"; then - case $ac_foobar in - foobar) - ac_case=lower - ac_foo_bar=foo_bar - ;; - FOOBAR) - ac_case=upper - ac_foo_bar=FOO_BAR - ;; - esac - - ac_success_extra=no - for ac_extra in "" "_"; do - ac_func="$ac_foo_bar$ac_underscore$ac_extra" - AC_TRY_LINK_FUNC($ac_func, - [ac_success_extra=yes; break]) - done - - if test "$ac_success_extra" = "yes"; then - ac_cv_f77_mangling="$ac_case case" - if test -z "$ac_underscore"; then - ac_cv_f77_mangling="$ac_cv_f77_mangling, no underscore" - else - ac_cv_f77_mangling="$ac_cv_f77_mangling, underscore" - fi - if test -z "$ac_extra"; then - ac_cv_f77_mangling="$ac_cv_f77_mangling, no extra underscore" - else - ac_cv_f77_mangling="$ac_cv_f77_mangling, extra underscore" - fi - else - ac_cv_f77_mangling="unknown" - fi - else - ac_cv_f77_mangling="unknown" - fi - - LIBS=$ac_save_LIBS - AC_LANG_POP(C)dnl - rm -f cf77_test* conftest*]) -AC_LANG_POP(Fortran 77)dnl -]) -])# _AC_F77_NAME_MANGLING - -# The replacement is empty. -AU_DEFUN([AC_F77_NAME_MANGLING], []) - - -# AC_F77_WRAPPERS -# --------------- -# Defines C macros F77_FUNC(name,NAME) and F77_FUNC_(name,NAME) to -# properly mangle the names of C identifiers, and C identifiers with -# underscores, respectively, so that they match the name mangling -# scheme used by the Fortran 77 compiler. -AC_DEFUN([AC_F77_WRAPPERS], -[AC_REQUIRE([_AC_F77_NAME_MANGLING])dnl -AH_TEMPLATE([F77_FUNC], - [Define to a macro mangling the given C identifier (in lower and upper - case), which must not contain underscores, for linking with Fortran.])dnl -AH_TEMPLATE([F77_FUNC_], - [As F77_FUNC, but for C identifiers containing underscores.])dnl -case $ac_cv_f77_mangling in - "lower case, no underscore, no extra underscore") - AC_DEFINE([F77_FUNC(name,NAME)], [name]) - AC_DEFINE([F77_FUNC_(name,NAME)], [name]) ;; - "lower case, no underscore, extra underscore") - AC_DEFINE([F77_FUNC(name,NAME)], [name]) - AC_DEFINE([F77_FUNC_(name,NAME)], [name ## _]) ;; - "lower case, underscore, no extra underscore") - AC_DEFINE([F77_FUNC(name,NAME)], [name ## _]) - AC_DEFINE([F77_FUNC_(name,NAME)], [name ## _]) ;; - "lower case, underscore, extra underscore") - AC_DEFINE([F77_FUNC(name,NAME)], [name ## _]) - AC_DEFINE([F77_FUNC_(name,NAME)], [name ## __]) ;; - "upper case, no underscore, no extra underscore") - AC_DEFINE([F77_FUNC(name,NAME)], [NAME]) - AC_DEFINE([F77_FUNC_(name,NAME)], [NAME]) ;; - "upper case, no underscore, extra underscore") - AC_DEFINE([F77_FUNC(name,NAME)], [NAME]) - AC_DEFINE([F77_FUNC_(name,NAME)], [NAME ## _]) ;; - "upper case, underscore, no extra underscore") - AC_DEFINE([F77_FUNC(name,NAME)], [NAME ## _]) - AC_DEFINE([F77_FUNC_(name,NAME)], [NAME ## _]) ;; - "upper case, underscore, extra underscore") - AC_DEFINE([F77_FUNC(name,NAME)], [NAME ## _]) - AC_DEFINE([F77_FUNC_(name,NAME)], [NAME ## __]) ;; - *) - AC_MSG_WARN([unknown Fortran 77 name-mangling scheme]) - ;; -esac -])# AC_F77_WRAPPERS - - -# AC_F77_FUNC(NAME, [SHELLVAR = NAME]) -# ------------------------------------ -# For a Fortran subroutine of given NAME, define a shell variable -# $SHELLVAR to the Fortran-77 mangled name. If the SHELLVAR -# argument is not supplied, it defaults to NAME. -AC_DEFUN([AC_F77_FUNC], -[AC_REQUIRE([_AC_F77_NAME_MANGLING])dnl -case $ac_cv_f77_mangling in - upper*) ac_val="m4_toupper([$1])" ;; - lower*) ac_val="m4_tolower([$1])" ;; - *) ac_val="unknown" ;; -esac -case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac -m4_if(m4_index([$1],[_]),-1,[], -[case $ac_cv_f77_mangling in *," extra underscore"*) ac_val="$ac_val"_ ;; esac -]) -m4_default([$2],[$1])="$ac_val" -])# AC_F77_FUNC diff --git a/lib/autoconf/fortran.m4 b/lib/autoconf/fortran.m4 index 5f0d64e8d..6564dd939 100644 --- a/lib/autoconf/fortran.m4 +++ b/lib/autoconf/fortran.m4 @@ -1,6 +1,6 @@ # This file is part of Autoconf. -*- Autoconf -*- -# Programming languages support. -# Copyright 2000, 2001 +# Fortran languages support. +# Copyright 2001 # Free Software Foundation, Inc. # # This program is free software; you can redistribute it and/or modify @@ -50,200 +50,12 @@ # Roland McGrath, Noah Friedman, david d zuhn, and many others. -# Table of Contents: -# -# 1. Language selection -# and routines to produce programs in a given language. -# a. generic routines -# b. C -# c. C++ -# d. Fortran 77 -# -# 2. Producing programs in a given language. -# a. generic routines -# b. C -# c. C++ -# d. Fortran 77 -# -# 3. Looking for a compiler -# And possibly the associated preprocessor. -# a. Generic routines. -# b. C -# c. C++ -# d. Fortran 77 -# -# 4. Compilers' characteristics. -# a. Generic routines. -# b. C -# c. C++ -# d. Fortran 77 - - ## ----------------------- ## ## 1. Language selection. ## ## ----------------------- ## - -# -------------------------------- # -# 1a. Generic language selection. # -# -------------------------------- # - -# AC_LANG_CASE(LANG1, IF-LANG1, LANG2, IF-LANG2, ..., DEFAULT) -# ------------------------------------------------------------ -# Expand into IF-LANG1 if the current language is LANG1 etc. else -# into default. -m4_define([AC_LANG_CASE], -[m4_case(_AC_LANG, $@)]) - - -# _AC_LANG_DISPATCH(MACRO, LANG, ARGS) -# ------------------------------------ -# Call the specialization of MACRO for LANG with ARGS. Complain if -# unavailable. -m4_define([_AC_LANG_DISPATCH], -[m4_ifdef([$1($2)], - [m4_indir([$1($2)], m4_shiftn(2, $@))], - [AC_FATAL([$1: unknown language: $2])])]) - - -# _AC_LANG_SET(OLD, NEW) -# ---------------------- -# Output the shell code needed to switch from OLD language to NEW language. -# Do not try to optimize like this: -# -# m4_defun([_AC_LANG_SET], -# [m4_if([$1], [$2], [], -# [_AC_LANG_DISPATCH([AC_LANG], [$2])])]) -# -# as it can introduce differences between the sh-current language and the -# m4-current-language when m4_require is used. Something more subtle -# might be possible, but at least for the time being, play it safe. -m4_defun([_AC_LANG_SET], -[_AC_LANG_DISPATCH([AC_LANG], [$2])]) - - -# AC_LANG(LANG) -# ------------- -# Set the current language to LANG. -m4_defun([AC_LANG], -[_AC_LANG_SET(m4_ifdef([_AC_LANG], [m4_defn([_AC_LANG])]), - [$1])dnl -m4_define([_AC_LANG], [$1])]) - - -# AC_LANG_PUSH(LANG) -# ------------------ -# Save the current language, and use LANG. -m4_defun([AC_LANG_PUSH], -[_AC_LANG_SET(m4_ifdef([_AC_LANG], [m4_defn([_AC_LANG])]), - [$1])dnl -m4_pushdef([_AC_LANG], [$1])]) - - -# AC_LANG_POP([LANG]) -# ------------------- -# If given, check that the current language is LANG, and restore the -# previous language. -m4_defun([AC_LANG_POP], -[m4_ifval([$1], - [m4_if([$1], m4_defn([_AC_LANG]), [], - [m4_fatal([$0($1): unexpected current language: ]m4_defn([_AC_LANG]))])])dnl -m4_pushdef([$0 OLD], m4_defn([_AC_LANG]))dnl -m4_popdef([_AC_LANG])dnl -_AC_LANG_SET(m4_defn([$0 OLD]), m4_defn([_AC_LANG]))dnl -m4_popdef([$0 OLD])dnl -]) - - -# AC_LANG_SAVE -# ------------ -# Save the current language, but don't change language. -AU_DEFUN([AC_LANG_SAVE], -[AC_DIAGNOSE([obsolete], - [instead of using `AC_LANG', `AC_LANG_SAVE', -and `AC_LANG_RESTORE', you should use `AC_LANG_PUSH' and `AC_LANG_POP'.]) -m4_pushdef([_AC_LANG], _AC_LANG)]) - - -# AC_LANG_RESTORE -# --------------- -# Restore the current language from the stack. -AU_DEFUN([AC_LANG_RESTORE], [AC_LANG_POP($@)]) - - -# _AC_LANG_ABBREV -# --------------- -# Return a short signature of _AC_LANG which can be used in shell -# variable names, or in M4 macro names. -m4_defun([_AC_LANG_ABBREV], -[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) - - -# AC_LANG_ASSERT(LANG) -# -------------------- -# Current language must be LANG. -m4_defun([AC_LANG_ASSERT], -[m4_if(_AC_LANG, $1, [], - [m4_fatal([$0: current language is not $1: ] _AC_LANG)])]) - - - -# -------------------- # -# 1b. The C language. # -# -------------------- # - - -# AC_LANG(C) -# ---------- -# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. -m4_define([AC_LANG(C)], -[ac_ext=c -ac_cpp='$CPP $CPPFLAGS' -ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD' -ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD' -ac_compiler_gnu=$ac_cv_c_compiler_gnu -]) - - -# AC_LANG_C -# --------- -AU_DEFUN([AC_LANG_C], [AC_LANG(C)]) - - -# _AC_LANG_ABBREV(C) -# ------------------ -m4_define([_AC_LANG_ABBREV(C)], [c]) - - -# ---------------------- # -# 1c. The C++ language. # -# ---------------------- # - - -# AC_LANG(C++) -# ------------ -# CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. -m4_define([AC_LANG(C++)], -[ac_ext=cc -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu -]) - - -# AC_LANG_CPLUSPLUS -# ----------------- -AU_DEFUN([AC_LANG_CPLUSPLUS], [AC_LANG(C++)]) - - -# _AC_LANG_ABBREV(C++) -# -------------------- -m4_define([_AC_LANG_ABBREV(C++)], [cxx]) - - # ----------------------------- # # 1d. The Fortran 77 language. # # ----------------------------- # @@ -275,200 +87,6 @@ m4_define([_AC_LANG_ABBREV(Fortran 77)], [f77]) ## ---------------------- ## -# ---------------------- # -# 2a. Generic routines. # -# ---------------------- # - - -# AC_LANG_CONFTEST(BODY) -# ---------------------- -# Save the BODY in `conftest.$ac_ext'. Add a trailing new line. -m4_define([AC_LANG_CONFTEST], -[cat >conftest.$ac_ext <<_ACEOF -$1 -_ACEOF]) - - -# AC_LANG_SOURCE(BODY) -# -------------------- -# Produce a valid source for the current language, which includes the -# BODY, and as much as possible `confdefs.h' and the `#line' sync -# lines. -AC_DEFUN([AC_LANG_SOURCE], -[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) - - -# AC_LANG_PROGRAM([PROLOGUE], [BODY]) -# ----------------------------------- -# Produce a valid source for the current language. Prepend the -# PROLOGUE (typically CPP directives and/or declarations) to an -# execution the BODY (typically glued inside the `main' function, or -# equivalent). -AC_DEFUN([AC_LANG_PROGRAM], -[AC_LANG_SOURCE([_AC_LANG_DISPATCH([$0], _AC_LANG, $@)])]) - - -# AC_LANG_CALL(PROLOGUE, FUNCTION) -# -------------------------------- -# Call the FUNCTION. -AC_DEFUN([AC_LANG_CALL], -[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) - - -# AC_LANG_FUNC_LINK_TRY(FUNCTION) -# ------------------------------- -# Produce a source which links correctly iff the FUNCTION exists. -AC_DEFUN([AC_LANG_FUNC_LINK_TRY], -[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) - - -# AC_LANG_BOOL_COMPILE_TRY(PROLOGUE, EXPRESSION) -# ---------------------------------------------- -# Produce a program that compiles with success iff the boolean EXPRESSION -# evaluates to true at compile time. -AC_DEFUN([AC_LANG_BOOL_COMPILE_TRY], -[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) - - -# AC_LANG_INT_SAVE(PROLOGUE, EXPRESSION) -# -------------------------------------- -# Produce a program that saves the runtime evaluation of the integer -# EXPRESSION into `conftest.val'. -AC_DEFUN([AC_LANG_INT_SAVE], -[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) - - -# --------------- # -# 2b. C sources. # -# --------------- # - -# AC_LANG_SOURCE(C)(BODY) -# ----------------------- -# This sometimes fails to find confdefs.h, for some reason. -# #line __oline__ "$[0]" -m4_define([AC_LANG_SOURCE(C)], -[#line __oline__ "configure" -#include "confdefs.h" -$1]) - - -# AC_LANG_PROGRAM(C)([PROLOGUE], [BODY]) -# -------------------------------------- -# If AC_F77_DUMMY_MAIN was run, then any C/C++ program might be linked -# against Fortran code, hence a dummy main might be needed. -m4_define([AC_LANG_PROGRAM(C)], -[$1 -m4_ifdef([_AC_LANG_PROGRAM_C_F77_HOOKS], [_AC_LANG_PROGRAM_C_F77_HOOKS()])dnl -int -main () -{ -dnl Do *not* indent the following line: there may be CPP directives. -dnl Don't move the `;' right after for the same reason. -$2 - ; - return 0; -}]) - - -# AC_LANG_CALL(C)(PROLOGUE, FUNCTION) -# ----------------------------------- -# Avoid conflicting decl of main. -m4_define([AC_LANG_CALL(C)], -[AC_LANG_PROGRAM([$1 -m4_if([$2], [main], , -[/* Override any gcc2 internal prototype to avoid an error. */ -#ifdef __cplusplus -extern "C" -#endif -/* We use char because int might match the return type of a gcc2 - builtin and then its argument prototype would still apply. */ -char $2 ();])], [$2 ();])]) - - -# AC_LANG_FUNC_LINK_TRY(C)(FUNCTION) -# ---------------------------------- -# Don't include because on OSF/1 3.0 it includes -# which includes which contains a -# prototype for select. Similarly for bzero. -m4_define([AC_LANG_FUNC_LINK_TRY(C)], -[AC_LANG_PROGRAM( -[/* System header to define __stub macros and hopefully few prototypes, - which can conflict with char $1 (); below. */ -#include -/* Override any gcc2 internal prototype to avoid an error. */ -#ifdef __cplusplus -extern "C" -#endif -/* We use char because int might match the return type of a gcc2 - builtin and then its argument prototype would still apply. */ -char $1 (); -char (*f) (); -], -[/* The GNU C library defines this for functions which it implements - to always fail with ENOSYS. Some functions are actually named - something starting with __ and the normal name is an alias. */ -#if defined (__stub_$1) || defined (__stub___$1) -choke me -#else -f = $1; -#endif -])]) - - -# AC_LANG_BOOL_COMPILE_TRY(C)(PROLOGUE, EXPRESSION) -# ------------------------------------------------- -m4_define([AC_LANG_BOOL_COMPILE_TRY(C)], -[AC_LANG_PROGRAM([$1], [int _array_ @<:@1 - 2 * !($2)@:>@])]) - - -# AC_LANG_INT_SAVE(C)(PROLOGUE, EXPRESSION) -# ----------------------------------------- -# We need `stdio.h' to open a `FILE', so the prologue defaults to the -# inclusion of `stdio.h'. -m4_define([AC_LANG_INT_SAVE(C)], -[AC_LANG_PROGRAM([m4_default([$1], [@%:@include ])], -[FILE *f = fopen ("conftest.val", "w"); -if (!f) - exit (1); -fprintf (f, "%d", ($2)); -fclose (f);])]) - - -# ----------------- # -# 2c. C++ sources. # -# ----------------- # - -# AC_LANG_SOURCE(C++)(BODY) -# ------------------------- -m4_copy([AC_LANG_SOURCE(C)], [AC_LANG_SOURCE(C++)]) - - -# AC_LANG_PROGRAM(C++)([PROLOGUE], [BODY]) -# ---------------------------------------- -m4_copy([AC_LANG_PROGRAM(C)], [AC_LANG_PROGRAM(C++)]) - - -# AC_LANG_CALL(C++)(PROLOGUE, FUNCTION) -# ------------------------------------- -m4_copy([AC_LANG_CALL(C)], [AC_LANG_CALL(C++)]) - - -# AC_LANG_FUNC_LINK_TRY(C++)(FUNCTION) -# ------------------------------------ -m4_copy([AC_LANG_FUNC_LINK_TRY(C)], [AC_LANG_FUNC_LINK_TRY(C++)]) - - -# AC_LANG_BOOL_COMPILE_TRY(C++)(PROLOGUE, EXPRESSION) -# --------------------------------------------------- -m4_copy([AC_LANG_BOOL_COMPILE_TRY(C)], [AC_LANG_BOOL_COMPILE_TRY(C++)]) - - -# AC_LANG_INT_SAVE(C++)(PROLOGUE, EXPRESSION) -# ------------------------------------------- -m4_copy([AC_LANG_INT_SAVE(C)], [AC_LANG_INT_SAVE(C++)]) - - - # ------------------------ # # 2d. Fortran 77 sources. # # ------------------------ # @@ -507,740 +125,6 @@ m4_define([AC_LANG_CALL(Fortran 77)], ## 3. Looking for Compilers and Preprocessors. ## ## -------------------------------------------- ## -# ----------------------------------------------------- # -# 3a. Generic routines in compilers and preprocessors. # -# ----------------------------------------------------- # - -# AC_LANG_COMPILER -# ---------------- -# Find a compiler for the current LANG. Be sure to be run before -# AC_LANG_PREPROC. -# -# Note that because we might AC_REQUIRE `AC_LANG_COMPILER(C)' for -# instance, the latter must be AC_DEFUN'd, not just define'd. -m4_define([AC_LANG_COMPILER], -[AC_BEFORE([AC_LANG_COMPILER(]_AC_LANG[)], - [AC_LANG_PREPROC(]_AC_LANG[)])dnl -_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) - - -# AC_LANG_COMPILER_REQUIRE -# ------------------------ -# Ensure we have a compiler for the current LANG. -AC_DEFUN([AC_LANG_COMPILER_REQUIRE], -[m4_require([AC_LANG_COMPILER(]_AC_LANG[)], - [AC_LANG_COMPILER])]) - - - -# _AC_LANG_COMPILER_GNU -# --------------------- -# Check whether the compiler for the current language is GNU. -# -# It doesn't seem necessary right now to have a different source -# according to the current language, since this works fine. Some day -# it might be needed. Nevertheless, pay attention to the fact that -# the position of `choke me' on the seventh column is meant: otherwise -# some Fortran compilers (e.g., SGI) might consider it's a -# continuation line, and warn instead of reporting an error. -m4_define([_AC_LANG_COMPILER_GNU], -[AC_CACHE_CHECK([whether we are using the GNU _AC_LANG compiler], - [ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu], -[_AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[#ifndef __GNUC__ - choke me -#endif -]])], - [ac_compiler_gnu=yes], - [ac_compiler_gnu=no]) -ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu=$ac_compiler_gnu -])])# _AC_LANG_COMPILER_GNU - - -# AC_LANG_PREPROC -# --------------- -# Find a preprocessor for the current language. Note that because we -# might AC_REQUIRE `AC_LANG_PREPROC(C)' for instance, the latter must -# be AC_DEFUN'd, not just define'd. Since the preprocessor depends -# upon the compiler, look for the compiler. -m4_define([AC_LANG_PREPROC], -[AC_LANG_COMPILER_REQUIRE()dnl -_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) - - -# AC_LANG_PREPROC_REQUIRE -# ----------------------- -# Ensure we have a preprocessor for the current language. -AC_DEFUN([AC_LANG_PREPROC_REQUIRE], -[m4_require([AC_LANG_PREPROC(]_AC_LANG[)], - [AC_LANG_PREPROC])]) - - -# AC_REQUIRE_CPP -# -------------- -# Require the preprocessor for the current language. -# FIXME: AU_ALIAS once AC_LANG is officially documented (2.51?). -AC_DEFUN([AC_REQUIRE_CPP], -[AC_LANG_PREPROC_REQUIRE]) - - - -# AC_NO_EXECUTABLES -# ----------------- -# FIXME: The GCC team has specific needs which the current Autoconf -# framework cannot solve elegantly. This macro implements a dirty -# hack until Autoconf is abble to provide the services its users -# needs. -# -# Several of the support libraries that are often built with GCC can't -# assume the tool-chain is already capable of linking a program: the -# compiler often expects to be able to link with some of such -# libraries. -# -# In several of these libraries, work-arounds have been introduced to -# avoid the AC_PROG_CC_WORKS test, that would just abort their -# configuration. The introduction of AC_EXEEXT, enabled either by -# libtool or by CVS autoconf, have just made matters worse. -AC_DEFUN_ONCE([AC_NO_EXECUTABLES], -[m4_divert_push([KILL]) - -AC_BEFORE([$0], [_AC_COMPILER_EXEEXT_WORKS]) -AC_BEFORE([$0], [_AC_COMPILER_EXEEXT]) - -m4_define([_AC_COMPILER_EXEEXT_WORKS], -[cross_compiling=maybe -]) - -m4_define([_AC_COMPILER_EXEEXT], -[EXEEXT= -]) - -m4_define([AC_LINK_IFELSE], -[AC_FATAL([All the tests involving linking were disabled by $0])]) - -m4_divert_pop()dnl -])# AC_NO_EXECUTABLES - - - -# ----------------------------- # -# Computing EXEEXT and OBJEXT. # -# ----------------------------- # - - -# Files to ignore -# --------------- -# Ignore .d files produced by CFLAGS=-MD. -# -# On UWIN (which uses a cc wrapper for MSVC), the compiler also generates -# a .pdb file -# -# When the w32 free Borland C++ command line compiler links a program -# (conftest.exe), it also produces a file named `conftest.tds' in -# addition to `conftest.obj' - - -# We must not AU define them, because autoupdate would then remove -# them, which is right, but Automake 1.4 would remove the support for -# $(EXEEXT) etc. -# FIXME: Remove this once Automake fixed. -AC_DEFUN([AC_EXEEXT], []) -AC_DEFUN([AC_OBJEXT], []) - - -# _AC_COMPILER_EXEEXT_DEFAULT -# --------------------------- -# Check for the extension used for the default name for executables. -# Beware of `expr' that may return `0' or `'. Since this macro is -# the first one in touch with the compiler, it should also check that -# it compiles properly. -m4_define([_AC_COMPILER_EXEEXT_DEFAULT], -[# Try to create an executable without -o first, disregard a.out. -# It will help us diagnose broken compilers, and finding out an intuition -# of exeext. -AC_MSG_CHECKING([for _AC_LANG compiler default output]) -ac_link_default=`echo "$ac_link" | sed ['s/ -o *conftest[^ ]*//']` -AS_IF([AC_TRY_EVAL(ac_link_default)], -[# Find the output, starting from the most likely. This scheme is -# not robust to junk in `.', hence go to wildcards (a.*) only as a last -# resort. -for ac_file in `ls a.exe conftest.exe 2>/dev/null; - ls a.out conftest 2>/dev/null; - ls a.* conftest.* 2>/dev/null`; do - case $ac_file in - *.$ac_ext | *.o | *.obj | *.xcoff | *.tds | *.d | *.pdb ) ;; - a.out ) # We found the default executable, but exeext='' is most - # certainly right. - break;; - *.* ) ac_cv_exeext=`expr "$ac_file" : ['[^.]*\(\..*\)']` - # FIXME: I believe we export ac_cv_exeext for Libtool --akim. - export ac_cv_exeext - break;; - * ) break;; - esac -done], - [echo "$as_me: failed program was:" >&AS_MESSAGE_LOG_FD -cat conftest.$ac_ext >&AS_MESSAGE_LOG_FD -AC_MSG_ERROR([_AC_LANG compiler cannot create executables], 77)]) -ac_exeext=$ac_cv_exeext -AC_MSG_RESULT([$ac_file]) -])# _AC_COMPILER_EXEEXT_DEFAULT - - -# _AC_COMPILER_EXEEXT_WORKS -# ------------------------- -m4_define([_AC_COMPILER_EXEEXT_WORKS], -[# Check the compiler produces executables we can run. If not, either -# the compiler is broken, or we cross compile. -AC_MSG_CHECKING([whether the _AC_LANG compiler works]) -# FIXME: These cross compiler hacks should be removed for Autoconf 3.0 -# If not cross compiling, check that we can run a simple program. -if test "$cross_compiling" != yes; then - if AC_TRY_COMMAND([./$ac_file]); then - cross_compiling=no - else - if test "$cross_compiling" = maybe; then - cross_compiling=yes - else - AC_MSG_ERROR([cannot run _AC_LANG compiled programs. -If you meant to cross compile, use `--host'.]) - fi - fi -fi -AC_MSG_RESULT([yes]) -])# _AC_COMPILER_EXEEXT_WORKS - - -# _AC_COMPILER_EXEEXT_CROSS -# ------------------------- -m4_define([_AC_COMPILER_EXEEXT_CROSS], -[# Check the compiler produces executables we can run. If not, either -# the compiler is broken, or we cross compile. -AC_MSG_CHECKING([whether we are cross compiling]) -AC_MSG_RESULT([$cross_compiling]) -])# _AC_COMPILER_EXEEXT_CROSS - - -# _AC_COMPILER_EXEEXT_O -# --------------------- -# Check for the extension used when `-o foo'. Try to see if ac_cv_exeext, -# as computed by _AC_COMPILER_EXEEXT_DEFAULT is OK. -m4_define([_AC_COMPILER_EXEEXT_O], -[AC_MSG_CHECKING([for executable suffix]) -AS_IF([AC_TRY_EVAL(ac_link)], -[# If both `conftest.exe' and `conftest' are `present' (well, observable) -# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will -# work properly (i.e., refer to `conftest.exe'), while it won't with -# `rm'. -for ac_file in `(ls conftest.exe; ls conftest; ls conftest.*) 2>/dev/null`; do - case $ac_file in - *.$ac_ext | *.o | *.obj | *.xcoff | *.tds | *.d | *.pdb ) ;; - *.* ) ac_cv_exeext=`expr "$ac_file" : ['[^.]*\(\..*\)']` - export ac_cv_exeext - break;; - * ) break;; - esac -done], - [AC_MSG_ERROR([cannot compute EXEEXT: cannot compile and link])]) -rm -f conftest$ac_cv_exeext -AC_MSG_RESULT([$ac_cv_exeext]) -])# _AC_COMPILER_EXEEXT_O - - -# _AC_COMPILER_EXEEXT -# ------------------- -# Check for the extension used for executables. It compiles a test -# executable. If this is called, the executable extensions will be -# automatically used by link commands run by the configure script. -# -# Note that some compilers (cross or not), strictly obey to `-o foo' while -# the host requires `foo.exe', so we should not depend upon `-o' to -# test EXEEXT. But then, be sure no to destroy user files. -# -# Must be run before _AC_COMPILER_OBJEXT because _AC_COMPILER_EXEEXT_DEFAULT -# checks whether the compiler works. -m4_define([_AC_COMPILER_EXEEXT], -[AC_LANG_CONFTEST([AC_LANG_PROGRAM()]) -ac_clean_files_save=$ac_clean_files -ac_clean_files="$ac_clean_files a.out a.exe" -_AC_COMPILER_EXEEXT_DEFAULT -_AC_COMPILER_EXEEXT_WORKS -rm -f a.out a.exe conftest$ac_cv_exeext -ac_clean_files=$ac_clean_files_save -_AC_COMPILER_EXEEXT_CROSS -_AC_COMPILER_EXEEXT_O -rm -f conftest.$ac_ext -AC_SUBST([EXEEXT], [$ac_cv_exeext])dnl -ac_exeext=$EXEEXT -])# _AC_COMPILER_EXEEXT - - -# _AC_COMPILER_OBJEXT -# ------------------- -# Check the object extension used by the compiler: typically `.o' or -# `.obj'. If this is called, some other behaviour will change, -# determined by ac_objext. -# -# This macro is called by AC_LANG_COMPILER, the latter being required -# by the AC_COMPILE_IFELSE macros, so use _AC_COMPILE_IFELSE. And in fact, -# don't, since _AC_COMPILE_IFELSE needs to know ac_objext for the `test -s' -# it includes. So do it by hand. -m4_define([_AC_COMPILER_OBJEXT], -[AC_CACHE_CHECK([for object suffix], ac_cv_objext, -[AC_LANG_CONFTEST([AC_LANG_PROGRAM()]) -rm -f conftest.o conftest.obj -AS_IF([AC_TRY_EVAL(ac_compile)], -[for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do - case $ac_file in - *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb ) ;; - *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` - break;; - esac -done], - [echo "$as_me: failed program was:" >&AS_MESSAGE_LOG_FD -cat conftest.$ac_ext >&AS_MESSAGE_LOG_FD -AC_MSG_ERROR([cannot compute OBJEXT: cannot compile])]) -rm -f conftest.$ac_cv_objext conftest.$ac_ext]) -AC_SUBST([OBJEXT], [$ac_cv_objext])dnl -ac_objext=$OBJEXT -])# _AC_COMPILER_OBJEXT - - -# -------------------- # -# 3b. The C compiler. # -# -------------------- # - - -# _AC_ARG_VAR_CPPFLAGS -# -------------------- -# Document and register CPPFLAGS, which is used by -# AC_PROG_{CC, CPP, CXX, CXXCPP}. -AC_DEFUN([_AC_ARG_VAR_CPPFLAGS], -[AC_ARG_VAR([CPPFLAGS], - [C/C++ preprocessor flags, e.g. -I if you have - headers in a nonstandard directory ])]) - - -# _AC_ARG_VAR_LDFLAGS -# ------------------- -# Document and register LDFLAGS, which is used by -# AC_PROG_{CC, CXX, F77}. -AC_DEFUN([_AC_ARG_VAR_LDFLAGS], -[AC_ARG_VAR([LDFLAGS], - [linker flags, e.g. -L if you have libraries in a - nonstandard directory ])]) - - - -# AC_LANG_PREPROC(C) -# ------------------- -# Find the C preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. -AC_DEFUN([AC_LANG_PREPROC(C)], -[AC_REQUIRE([AC_PROG_CPP])]) - - -# _AC_PROG_PREPROC_WORKS_IFELSE(IF-WORKS, IF-NOT) -# ----------------------------------------------- -# Check if $ac_cpp is a working preprocessor that can flag absent -# includes either by the exit status or by warnings. -# Set ac_cpp_err to a non-empty value if the preprocessor failed. -# This macro is for all languages, not only C. -AC_DEFUN([_AC_PROG_PREPROC_WORKS_IFELSE], -[ac_preproc_ok=false -for ac_[]_AC_LANG_ABBREV[]_preproc_warn_flag in '' yes -do - # Use a header file that comes with gcc, so configuring glibc - # with a fresh cross-compiler works. - # On the NeXT, cc -E runs the code through the compiler's parser, - # not just through cpp. "Syntax error" is here to catch this case. - _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@include - Syntax error]])], - [], - [# Broken: fails on valid input. -continue]) - - # OK, works on sane cases. Now check whether non-existent headers - # can be detected and how. - _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@include ]])], - [# Broken: success on invalid input. -continue], - [# Passes both tests. -ac_preproc_ok=: -break]) - -done -# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. -rm -f conftest.err conftest.$ac_ext -AS_IF([$ac_preproc_ok], [$1], [$2])])# _AC_PROG_PREPROC_WORKS_IFELSE - - -# AC_PROG_CPP -# ----------- -# Find a working C preprocessor. -# We shouldn't have to require AC_PROG_CC, but this is due to the concurrency -# between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CC. -AC_DEFUN([AC_PROG_CPP], -[AC_REQUIRE([AC_PROG_CC])dnl -AC_ARG_VAR([CPP], [C preprocessor])dnl -_AC_ARG_VAR_CPPFLAGS()dnl -AC_LANG_PUSH(C)dnl -AC_MSG_CHECKING([how to run the C preprocessor]) -# On Suns, sometimes $CPP names a directory. -if test -n "$CPP" && test -d "$CPP"; then - CPP= -fi -if test -z "$CPP"; then - AC_CACHE_VAL([ac_cv_prog_CPP], - [dnl - # Double quotes because CPP needs to be expanded - for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" - do - _AC_PROG_PREPROC_WORKS_IFELSE([break]) - done - ac_cv_prog_CPP=$CPP - ])dnl - CPP=$ac_cv_prog_CPP -else - ac_cv_prog_CPP=$CPP -fi -AC_MSG_RESULT([$CPP]) -_AC_PROG_PREPROC_WORKS_IFELSE([], - [AC_MSG_ERROR([C preprocessor "$CPP" fails sanity check])]) -AC_SUBST(CPP)dnl -AC_LANG_POP(C)dnl -])# AC_PROG_CPP - - -# AC_LANG_COMPILER(C) -# ------------------- -# Find the C compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able. -AC_DEFUN([AC_LANG_COMPILER(C)], -[AC_REQUIRE([AC_PROG_CC])]) - - -# ac_cv_prog_gcc -# -------------- -# We used to name the cache variable this way. -AU_DEFUN([ac_cv_prog_gcc], -[ac_cv_c_compiler_gnu]) - - -# AC_PROG_CC([COMPILER ...]) -# -------------------------- -# COMPILER ... is a space separated list of C compilers to search for. -# This just gives the user an opportunity to specify an alternative -# search list for the C compiler. -AC_DEFUN([AC_PROG_CC], -[AC_LANG_PUSH(C)dnl -AC_ARG_VAR([CC], [C compiler command])dnl -AC_ARG_VAR([CFLAGS], [C compiler flags])dnl -_AC_ARG_VAR_LDFLAGS()dnl -_AC_ARG_VAR_CPPFLAGS()dnl -m4_ifval([$1], - [AC_CHECK_TOOLS(CC, [$1])], -[AC_CHECK_TOOL(CC, gcc) -if test -z "$CC"; then - AC_CHECK_TOOL(CC, cc) -fi -if test -z "$CC"; then - AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc) -fi -if test -z "$CC"; then - AC_CHECK_TOOLS(CC, cl) -fi -]) - -test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH]) - -# Provide some information about the compiler. -echo "$as_me:__oline__:" \ - "checking for _AC_LANG compiler version" >&AS_MESSAGE_LOG_FD -ac_compiler=`set X $ac_compile; echo $[2]` -_AC_EVAL([$ac_compiler --version &AS_MESSAGE_LOG_FD]) -_AC_EVAL([$ac_compiler -v &AS_MESSAGE_LOG_FD]) -_AC_EVAL([$ac_compiler -V &AS_MESSAGE_LOG_FD]) - -m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl -m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl -_AC_LANG_COMPILER_GNU -GCC=`test $ac_compiler_gnu = yes && echo yes` -_AC_PROG_CC_G -# Some people use a C++ compiler to compile C. Since we use `exit', -# in C++ we need to declare it. In case someone uses the same compiler -# for both compiling C and C++ we need to have the C++ compiler decide -# the declaration of exit, since it's the most demanding environment. -_AC_COMPILE_IFELSE([@%:@ifndef __cplusplus - choke me -@%:@endif], - [_AC_PROG_CXX_EXIT_DECLARATION]) -AC_LANG_POP(C)dnl -])# AC_PROG_CC - - -# _AC_PROG_CC_G -# ------------- -# Check whether -g works, even if CFLAGS is set, in case the package -# plays around with CFLAGS (such as to build both debugging and normal -# versions of a library), tasteless as that idea is. -m4_define([_AC_PROG_CC_G], -[ac_test_CFLAGS=${CFLAGS+set} -ac_save_CFLAGS=$CFLAGS -CFLAGS="-g" -AC_CACHE_CHECK(whether $CC accepts -g, ac_cv_prog_cc_g, - [_AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], [ac_cv_prog_cc_g=yes], - [ac_cv_prog_cc_g=no])]) -if test "$ac_test_CFLAGS" = set; then - CFLAGS=$ac_save_CFLAGS -elif test $ac_cv_prog_cc_g = yes; then - if test "$GCC" = yes; then - CFLAGS="-g -O2" - else - CFLAGS="-g" - fi -else - if test "$GCC" = yes; then - CFLAGS="-O2" - else - CFLAGS= - fi -fi[]dnl -])# _AC_PROG_CC_G - - -# AC_PROG_GCC_TRADITIONAL -# ----------------------- -AC_DEFUN([AC_PROG_GCC_TRADITIONAL], -[if test $ac_cv_c_compiler_gnu = yes; then - AC_CACHE_CHECK(whether $CC needs -traditional, - ac_cv_prog_gcc_traditional, -[ ac_pattern="Autoconf.*'x'" - AC_EGREP_CPP($ac_pattern, [#include -Autoconf TIOCGETP], - ac_cv_prog_gcc_traditional=yes, ac_cv_prog_gcc_traditional=no) - - if test $ac_cv_prog_gcc_traditional = no; then - AC_EGREP_CPP($ac_pattern, [#include -Autoconf TCGETA], - ac_cv_prog_gcc_traditional=yes) - fi]) - if test $ac_cv_prog_gcc_traditional = yes; then - CC="$CC -traditional" - fi -fi -])# AC_PROG_GCC_TRADITIONAL - - -# AC_PROG_CC_C_O -# -------------- -AC_DEFUN([AC_PROG_CC_C_O], -[AC_REQUIRE([AC_PROG_CC])dnl -if test "x$CC" != xcc; then - AC_MSG_CHECKING([whether $CC and cc understand -c and -o together]) -else - AC_MSG_CHECKING([whether cc understands -c and -o together]) -fi -set dummy $CC; ac_cc=`echo $[2] | - sed 's/[[^a-zA-Z0-9_]]/_/g;s/^[[0-9]]/_/'` -AC_CACHE_VAL(ac_cv_prog_cc_${ac_cc}_c_o, -[AC_LANG_CONFTEST([AC_LANG_PROGRAM([])]) -# Make sure it works both with $CC and with simple cc. -# We do the test twice because some compilers refuse to overwrite an -# existing .o file with -o, though they will create one. -ac_try='$CC -c conftest.$ac_ext -o conftest.$ac_objext >&AS_MESSAGE_LOG_FD' -if AC_TRY_EVAL(ac_try) && - test -f conftest.$ac_objext && AC_TRY_EVAL(ac_try); -then - eval ac_cv_prog_cc_${ac_cc}_c_o=yes - if test "x$CC" != xcc; then - # Test first that cc exists at all. - if AC_TRY_COMMAND(cc -c conftest.$ac_ext >&AS_MESSAGE_LOG_FD); then - ac_try='cc -c conftest.$ac_ext -o conftest.$ac_objext >&AS_MESSAGE_LOG_FD' - if AC_TRY_EVAL(ac_try) && - test -f conftest.$ac_objext && AC_TRY_EVAL(ac_try); - then - # cc works too. - : - else - # cc exists but doesn't like -o. - eval ac_cv_prog_cc_${ac_cc}_c_o=no - fi - fi - fi -else - eval ac_cv_prog_cc_${ac_cc}_c_o=no -fi -rm -f conftest* -])dnl -if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = yes"; then - AC_MSG_RESULT([yes]) -else - AC_MSG_RESULT([no]) - AC_DEFINE(NO_MINUS_C_MINUS_O, 1, - [Define if your C compiler doesn't accept -c and -o together.]) -fi -])# AC_PROG_CC_C_O - - -# ---------------------- # -# 3c. The C++ compiler. # -# ---------------------- # - - -# AC_LANG_PREPROC(C++) -# --------------------- -# Find the C++ preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. -AC_DEFUN([AC_LANG_PREPROC(C++)], -[AC_REQUIRE([AC_PROG_CXXCPP])]) - - -# AC_PROG_CXXCPP -# -------------- -# Find a working C++ preprocessor. -# We shouldn't have to require AC_PROG_CC, but this is due to the concurrency -# between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CXX. -AC_DEFUN([AC_PROG_CXXCPP], -[AC_REQUIRE([AC_PROG_CXX])dnl -AC_ARG_VAR([CXXCPP], [C++ preprocessor])dnl -_AC_ARG_VAR_CPPFLAGS()dnl -AC_LANG_PUSH(C++)dnl -AC_MSG_CHECKING([how to run the C++ preprocessor]) -if test -z "$CXXCPP"; then - AC_CACHE_VAL(ac_cv_prog_CXXCPP, - [dnl - # Double quotes because CXXCPP needs to be expanded - for CXXCPP in "$CXX -E" "/lib/cpp" - do - _AC_PROG_PREPROC_WORKS_IFELSE([break]) - done - ac_cv_prog_CXXCPP=$CXXCPP - ])dnl - CXXCPP=$ac_cv_prog_CXXCPP -else - ac_cv_prog_CXXCPP=$CXXCPP -fi -AC_MSG_RESULT([$CXXCPP]) -_AC_PROG_PREPROC_WORKS_IFELSE([], - [AC_MSG_ERROR([C++ preprocessor "$CXXCPP" fails sanity check])]) -AC_SUBST(CXXCPP)dnl -AC_LANG_POP(C++)dnl -])# AC_PROG_CXXCPP - - -# AC_LANG_COMPILER(C++) -# --------------------- -# Find the C++ compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able. -AC_DEFUN([AC_LANG_COMPILER(C++)], -[AC_REQUIRE([AC_PROG_CXX])]) - - -# ac_cv_prog_gxx -# -------------- -# We used to name the cache variable this way. -AU_DEFUN([ac_cv_prog_gxx], -[ac_cv_cxx_compiler_gnu]) - - -# AC_PROG_CXX([LIST-OF-COMPILERS]) -# -------------------------------- -# LIST-OF-COMPILERS is a space separated list of C++ compilers to search -# for (if not specified, a default list is used). This just gives the -# user an opportunity to specify an alternative search list for the C++ -# compiler. -# aCC HP-UX C++ compiler much better than `CC', so test before. -# FCC Fujitsu C++ compiler -# KCC KAI C++ compiler -# RCC Rational C++ -# xlC_r AIX C Set++ (with support for reentrant code) -# xlC AIX C Set++ -AC_DEFUN([AC_PROG_CXX], -[AC_LANG_PUSH(C++)dnl -AC_ARG_VAR([CXX], [C++ compiler command])dnl -AC_ARG_VAR([CXXFLAGS], [C++ compiler flags])dnl -_AC_ARG_VAR_LDFLAGS()dnl -_AC_ARG_VAR_CPPFLAGS()dnl -AC_CHECK_TOOLS(CXX, - [$CCC m4_default([$1], - [g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC])], - g++) - -# Provide some information about the compiler. -echo "$as_me:__oline__:" \ - "checking for _AC_LANG compiler version" >&AS_MESSAGE_LOG_FD -ac_compiler=`set X $ac_compile; echo $[2]` -_AC_EVAL([$ac_compiler --version &AS_MESSAGE_LOG_FD]) -_AC_EVAL([$ac_compiler -v &AS_MESSAGE_LOG_FD]) -_AC_EVAL([$ac_compiler -V &AS_MESSAGE_LOG_FD]) - -m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl -m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl -_AC_LANG_COMPILER_GNU -GXX=`test $ac_compiler_gnu = yes && echo yes` -_AC_PROG_CXX_G -_AC_PROG_CXX_EXIT_DECLARATION -AC_LANG_POP(C++)dnl -])# AC_PROG_CXX - - -# _AC_PROG_CXX_G -# -------------- -# Check whether -g works, even if CXXFLAGS is set, in case the package -# plays around with CXXFLAGS (such as to build both debugging and -# normal versions of a library), tasteless as that idea is. -m4_define([_AC_PROG_CXX_G], -[ac_test_CXXFLAGS=${CXXFLAGS+set} -ac_save_CXXFLAGS=$CXXFLAGS -CXXFLAGS="-g" -AC_CACHE_CHECK(whether $CXX accepts -g, ac_cv_prog_cxx_g, - [_AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], - [ac_cv_prog_cxx_g=yes], - [ac_cv_prog_cxx_g=no])]) -if test "$ac_test_CXXFLAGS" = set; then - CXXFLAGS=$ac_save_CXXFLAGS -elif test $ac_cv_prog_cxx_g = yes; then - if test "$GXX" = yes; then - CXXFLAGS="-g -O2" - else - CXXFLAGS="-g" - fi -else - if test "$GXX" = yes; then - CXXFLAGS="-O2" - else - CXXFLAGS= - fi -fi[]dnl -])# _AC_PROG_CXX_G - - -# _AC_PROG_CXX_EXIT_DECLARATION -# ----------------------------- -# Find a valid prototype for exit and declare it in confdefs.h. -m4_define([_AC_PROG_CXX_EXIT_DECLARATION], -[for ac_declaration in \ - ''\ - '#include ' \ - 'extern "C" void std::exit (int) throw (); using std::exit;' \ - 'extern "C" void std::exit (int); using std::exit;' \ - 'extern "C" void exit (int) throw ();' \ - 'extern "C" void exit (int);' \ - 'void exit (int);' -do - _AC_COMPILE_IFELSE([AC_LANG_PROGRAM([@%:@include -$ac_declaration], - [exit (42);])], - [], - [continue]) - _AC_COMPILE_IFELSE([AC_LANG_PROGRAM([$ac_declaration], - [exit (42);])], - [break]) -done -rm -f conftest* -if test -n "$ac_declaration"; then - echo '#ifdef __cplusplus' >>confdefs.h - echo $ac_declaration >>confdefs.h - echo '#endif' >>confdefs.h -fi -])# _AC_PROG_CXX_EXIT_DECLARATION - # ----------------------------- # # 3d. The Fortran 77 compiler. # @@ -1397,337 +281,6 @@ fi ## ------------------------------- ## -# -------------------------------- # -# 4b. C compiler characteristics. # -# -------------------------------- # - -# AC_PROG_CC_STDC -# --------------- -# If the C compiler in not in ANSI C mode by default, try to add an -# option to output variable @code{CC} to make it so. This macro tries -# various options that select ANSI C on some system or another. It -# considers the compiler to be in ANSI C mode if it handles function -# prototypes correctly. -AC_DEFUN([AC_PROG_CC_STDC], -[AC_REQUIRE([AC_PROG_CC])dnl -AC_BEFORE([$0], [AC_C_INLINE])dnl -AC_BEFORE([$0], [AC_C_CONST])dnl -dnl Force this before AC_PROG_CPP. Some cpp's, eg on HPUX, require -dnl a magic option to avoid problems with ANSI preprocessor commands -dnl like #elif. -dnl FIXME: can't do this because then AC_AIX won't work due to a -dnl circular dependency. -dnl AC_BEFORE([$0], [AC_PROG_CPP]) -AC_MSG_CHECKING([for $CC option to accept ANSI C]) -AC_CACHE_VAL(ac_cv_prog_cc_stdc, -[ac_cv_prog_cc_stdc=no -ac_save_CC=$CC -AC_LANG_CONFTEST([AC_LANG_PROGRAM( -[[#include -#include -#include -#include -/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ -struct buf { int x; }; -FILE * (*rcsopen) (struct buf *, struct stat *, int); -static char *e (p, i) - char **p; - int i; -{ - return p[i]; -} -static char *f (char * (*g) (char **, int), char **p, ...) -{ - char *s; - va_list v; - va_start (v,p); - s = g (p, va_arg (v,int)); - va_end (v); - return s; -} -int test (int i, double x); -struct s1 {int (*f) (int a);}; -struct s2 {int (*f) (double a);}; -int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); -int argc; -char **argv;]], -[[return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];]])]) -# Don't try gcc -ansi; that turns off useful extensions and -# breaks some systems' header files. -# AIX -qlanglvl=ansi -# Ultrix and OSF/1 -std1 -# HP-UX 10.20 and later -Ae -# HP-UX older versions -Aa -D_HPUX_SOURCE -# SVR4 -Xc -D__EXTENSIONS__ -for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" -do - CC="$ac_save_CC $ac_arg" - AC_COMPILE_IFELSE([], - [ac_cv_prog_cc_stdc=$ac_arg -break]) -done -rm -f conftest.$ac_ext conftest.$ac_objext -CC=$ac_save_CC -]) -case "x$ac_cv_prog_cc_stdc" in - x|xno) - AC_MSG_RESULT([none needed]) ;; - *) - AC_MSG_RESULT([$ac_cv_prog_cc_stdc]) - CC="$CC $ac_cv_prog_cc_stdc" ;; -esac -])# AC_PROG_CC_STDC - - -# AC_C_CROSS -# ---------- -# Has been merged into AC_PROG_CC. -AU_DEFUN([AC_C_CROSS], []) - - -# AC_C_CHAR_UNSIGNED -# ------------------ -AC_DEFUN([AC_C_CHAR_UNSIGNED], -[AH_VERBATIM([__CHAR_UNSIGNED__], -[/* Define if type `char' is unsigned and you are not using gcc. */ -#ifndef __CHAR_UNSIGNED__ -# undef __CHAR_UNSIGNED__ -#endif])dnl -AC_CACHE_CHECK(whether char is unsigned, ac_cv_c_char_unsigned, -[AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([AC_INCLUDES_DEFAULT([])], - [((char) -1) < 0])], - ac_cv_c_char_unsigned=no, ac_cv_c_char_unsigned=yes)]) -if test $ac_cv_c_char_unsigned = yes && test "$GCC" != yes; then - AC_DEFINE(__CHAR_UNSIGNED__) -fi -])# AC_C_CHAR_UNSIGNED - - -# AC_C_LONG_DOUBLE -# ---------------- -AC_DEFUN([AC_C_LONG_DOUBLE], -[AC_CACHE_CHECK(for long double, ac_cv_c_long_double, -[if test "$GCC" = yes; then - ac_cv_c_long_double=yes -else -AC_TRY_RUN( -[int -main () -{ - /* The Stardent Vistra knows sizeof(long double), but does not - support it. */ - long double foo = 0.0; - /* On Ultrix 4.3 cc, long double is 4 and double is 8. */ - exit (sizeof (long double) < sizeof (double)); -}], -ac_cv_c_long_double=yes, ac_cv_c_long_double=no) -fi]) -if test $ac_cv_c_long_double = yes; then - AC_DEFINE(HAVE_LONG_DOUBLE, 1, - [Define if the `long double' type works.]) -fi -])# AC_C_LONG_DOUBLE - - -# AC_C_BIGENDIAN -# -------------- -AC_DEFUN([AC_C_BIGENDIAN], -[AC_CACHE_CHECK(whether byte ordering is bigendian, ac_cv_c_bigendian, -[ac_cv_c_bigendian=unknown -# See if sys/param.h defines the BYTE_ORDER macro. -AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include -#include -], -[#if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN - bogus endian macros -#endif -])], -[# It does; now see whether it defined to BIG_ENDIAN or not. -AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include -#include -], [#if BYTE_ORDER != BIG_ENDIAN - not big endian -#endif -])], [ac_cv_c_bigendian=yes], - [ac_cv_c_bigendian=no])]) -if test $ac_cv_c_bigendian = unknown; then -AC_TRY_RUN( -[int -main () -{ - /* Are we little or big endian? From Harbison&Steele. */ - union - { - long l; - char c[sizeof (long)]; - } u; - u.l = 1; - exit (u.c[sizeof (long) - 1] == 1); -}], ac_cv_c_bigendian=no, ac_cv_c_bigendian=yes) -fi]) -if test $ac_cv_c_bigendian = yes; then - AC_DEFINE(WORDS_BIGENDIAN, 1, - [Define if your processor stores words with the most significant - byte first (like Motorola and SPARC, unlike Intel and VAX).]) -fi -])# AC_C_BIGENDIAN - - -# AC_C_INLINE -# ----------- -# Do nothing if the compiler accepts the inline keyword. -# Otherwise define inline to __inline__ or __inline if one of those work, -# otherwise define inline to be empty. -AC_DEFUN([AC_C_INLINE], -[AC_REQUIRE([AC_PROG_CC_STDC])dnl -AC_CACHE_CHECK([for inline], ac_cv_c_inline, -[ac_cv_c_inline=no -for ac_kw in inline __inline__ __inline; do - AC_COMPILE_IFELSE([AC_LANG_SOURCE( -[#ifndef __cplusplus -static $ac_kw int static_foo () {return 0; } -$ac_kw int foo () {return 0; } -#endif -])], - [ac_cv_c_inline=$ac_kw; break]) -done -]) -case $ac_cv_c_inline in - inline | yes) ;; - no) AC_DEFINE(inline,, - [Define as `__inline' if that's what the C compiler calls it, - or to nothing if it is not supported.]) ;; - *) AC_DEFINE_UNQUOTED(inline, $ac_cv_c_inline) ;; -esac -])# AC_C_INLINE - - -# AC_C_CONST -# ---------- -AC_DEFUN([AC_C_CONST], -[AC_REQUIRE([AC_PROG_CC_STDC])dnl -AC_CACHE_CHECK([for an ANSI C-conforming const], ac_cv_c_const, -[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], -[[/* FIXME: Include the comments suggested by Paul. */ -#ifndef __cplusplus - /* Ultrix mips cc rejects this. */ - typedef int charset[2]; - const charset x; - /* SunOS 4.1.1 cc rejects this. */ - char const *const *ccp; - char **p; - /* NEC SVR4.0.2 mips cc rejects this. */ - struct point {int x, y;}; - static struct point const zero = {0,0}; - /* AIX XL C 1.02.0.0 rejects this. - It does not let you subtract one const X* pointer from another in - an arm of an if-expression whose if-part is not a constant - expression */ - const char *g = "string"; - ccp = &g + (g ? g-g : 0); - /* HPUX 7.0 cc rejects these. */ - ++ccp; - p = (char**) ccp; - ccp = (char const *const *) p; - { /* SCO 3.2v4 cc rejects this. */ - char *t; - char const *s = 0 ? (char *) 0 : (char const *) 0; - - *t++ = 0; - } - { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */ - int x[] = {25, 17}; - const int *foo = &x[0]; - ++foo; - } - { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */ - typedef const int *iptr; - iptr p = 0; - ++p; - } - { /* AIX XL C 1.02.0.0 rejects this saying - "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */ - struct s { int j; const int *ap[3]; }; - struct s *b; b->j = 5; - } - { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ - const int foo = 10; - } -#endif -]])], - [ac_cv_c_const=yes], - [ac_cv_c_const=no])]) -if test $ac_cv_c_const = no; then - AC_DEFINE(const,, - [Define to empty if `const' does not conform to ANSI C.]) -fi -])# AC_C_CONST - - -# AC_C_VOLATILE -# ------------- -# Note that, unlike const, #defining volatile to be the empty string can -# actually turn a correct program into an incorrect one, since removing -# uses of volatile actually grants the compiler permission to perform -# optimizations that could break the user's code. So, do not #define -# volatile away unless it is really necessary to allow the user's code -# to compile cleanly. Benign compiler failures should be tolerated. -AC_DEFUN([AC_C_VOLATILE], -[AC_REQUIRE([AC_PROG_CC_STDC])dnl -AC_CACHE_CHECK([for working volatile], ac_cv_c_volatile, -[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [ -volatile int x; -int * volatile y;])], - [ac_cv_c_volatile=yes], - [ac_cv_c_volatile=no])]) -if test $ac_cv_c_volatile = no; then - AC_DEFINE(volatile,, - [Define to empty if the keyword `volatile' does not work. - Warning: valid code using `volatile' can become incorrect - without. Disable with care.]) -fi -])# AC_C_VOLATILE - - -# AC_C_STRINGIZE -# -------------- -# Checks if `#' can be used to glue strings together at the CPP level. -# Defines HAVE_STRINGIZE if positive. -AC_DEFUN([AC_C_STRINGIZE], -[AC_CACHE_CHECK([for preprocessor stringizing operator], - [ac_cv_c_stringize], -[AC_EGREP_CPP([@%:@teststring], - [@%:@define x(y) #y - -char *s = x(teststring);], - [ac_cv_c_stringize=no], - [ac_cv_c_stringize=yes])]) -if test $ac_cv_c_stringize = yes; then - AC_DEFINE(HAVE_STRINGIZE, 1, - [Define if cpp supports the ANSI @%:@ stringizing operator.]) -fi -])# AC_C_STRINGIZE - - -# AC_C_PROTOTYPES -# --------------- -# Check if the C compiler supports prototypes, included if it needs -# options. -AC_DEFUN([AC_C_PROTOTYPES], -[AC_REQUIRE([AC_PROG_CC_STDC])dnl -AC_MSG_CHECKING([for function prototypes]) -if test "$ac_cv_prog_cc_stdc" != no; then - AC_MSG_RESULT([yes]) - AC_DEFINE(PROTOTYPES, 1, - [Define if the C compiler supports function prototypes.]) -else - AC_MSG_RESULT([no]) -fi -])# AC_C_PROTOTYPES - - - - # ---------------------------------------- # # 4d. Fortan 77 compiler characteristics. # # ---------------------------------------- # diff --git a/lib/autoconf/lang.m4 b/lib/autoconf/lang.m4 index 5f0d64e8d..70deaa0a5 100644 --- a/lib/autoconf/lang.m4 +++ b/lib/autoconf/lang.m4 @@ -190,86 +190,6 @@ m4_defun([AC_LANG_ASSERT], -# -------------------- # -# 1b. The C language. # -# -------------------- # - - -# AC_LANG(C) -# ---------- -# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. -m4_define([AC_LANG(C)], -[ac_ext=c -ac_cpp='$CPP $CPPFLAGS' -ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD' -ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD' -ac_compiler_gnu=$ac_cv_c_compiler_gnu -]) - - -# AC_LANG_C -# --------- -AU_DEFUN([AC_LANG_C], [AC_LANG(C)]) - - -# _AC_LANG_ABBREV(C) -# ------------------ -m4_define([_AC_LANG_ABBREV(C)], [c]) - - -# ---------------------- # -# 1c. The C++ language. # -# ---------------------- # - - -# AC_LANG(C++) -# ------------ -# CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options. -m4_define([AC_LANG(C++)], -[ac_ext=cc -ac_cpp='$CXXCPP $CPPFLAGS' -ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD' -ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD' -ac_compiler_gnu=$ac_cv_cxx_compiler_gnu -]) - - -# AC_LANG_CPLUSPLUS -# ----------------- -AU_DEFUN([AC_LANG_CPLUSPLUS], [AC_LANG(C++)]) - - -# _AC_LANG_ABBREV(C++) -# -------------------- -m4_define([_AC_LANG_ABBREV(C++)], [cxx]) - - -# ----------------------------- # -# 1d. The Fortran 77 language. # -# ----------------------------- # - - -# AC_LANG(Fortran 77) -# ------------------- -m4_define([AC_LANG(Fortran 77)], -[ac_ext=f -ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD' -ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD' -ac_compiler_gnu=$ac_cv_f77_compiler_gnu -]) - - -# AC_LANG_FORTRAN77 -# ----------------- -AU_DEFUN([AC_LANG_FORTRAN77], [AC_LANG(Fortran 77)]) - - -# _AC_LANG_ABBREV(Fortran 77) -# --------------------------- -m4_define([_AC_LANG_ABBREV(Fortran 77)], [f77]) - - - ## ---------------------- ## ## 2.Producing programs. ## ## ---------------------- ## @@ -338,171 +258,6 @@ AC_DEFUN([AC_LANG_INT_SAVE], [_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) -# --------------- # -# 2b. C sources. # -# --------------- # - -# AC_LANG_SOURCE(C)(BODY) -# ----------------------- -# This sometimes fails to find confdefs.h, for some reason. -# #line __oline__ "$[0]" -m4_define([AC_LANG_SOURCE(C)], -[#line __oline__ "configure" -#include "confdefs.h" -$1]) - - -# AC_LANG_PROGRAM(C)([PROLOGUE], [BODY]) -# -------------------------------------- -# If AC_F77_DUMMY_MAIN was run, then any C/C++ program might be linked -# against Fortran code, hence a dummy main might be needed. -m4_define([AC_LANG_PROGRAM(C)], -[$1 -m4_ifdef([_AC_LANG_PROGRAM_C_F77_HOOKS], [_AC_LANG_PROGRAM_C_F77_HOOKS()])dnl -int -main () -{ -dnl Do *not* indent the following line: there may be CPP directives. -dnl Don't move the `;' right after for the same reason. -$2 - ; - return 0; -}]) - - -# AC_LANG_CALL(C)(PROLOGUE, FUNCTION) -# ----------------------------------- -# Avoid conflicting decl of main. -m4_define([AC_LANG_CALL(C)], -[AC_LANG_PROGRAM([$1 -m4_if([$2], [main], , -[/* Override any gcc2 internal prototype to avoid an error. */ -#ifdef __cplusplus -extern "C" -#endif -/* We use char because int might match the return type of a gcc2 - builtin and then its argument prototype would still apply. */ -char $2 ();])], [$2 ();])]) - - -# AC_LANG_FUNC_LINK_TRY(C)(FUNCTION) -# ---------------------------------- -# Don't include because on OSF/1 3.0 it includes -# which includes which contains a -# prototype for select. Similarly for bzero. -m4_define([AC_LANG_FUNC_LINK_TRY(C)], -[AC_LANG_PROGRAM( -[/* System header to define __stub macros and hopefully few prototypes, - which can conflict with char $1 (); below. */ -#include -/* Override any gcc2 internal prototype to avoid an error. */ -#ifdef __cplusplus -extern "C" -#endif -/* We use char because int might match the return type of a gcc2 - builtin and then its argument prototype would still apply. */ -char $1 (); -char (*f) (); -], -[/* The GNU C library defines this for functions which it implements - to always fail with ENOSYS. Some functions are actually named - something starting with __ and the normal name is an alias. */ -#if defined (__stub_$1) || defined (__stub___$1) -choke me -#else -f = $1; -#endif -])]) - - -# AC_LANG_BOOL_COMPILE_TRY(C)(PROLOGUE, EXPRESSION) -# ------------------------------------------------- -m4_define([AC_LANG_BOOL_COMPILE_TRY(C)], -[AC_LANG_PROGRAM([$1], [int _array_ @<:@1 - 2 * !($2)@:>@])]) - - -# AC_LANG_INT_SAVE(C)(PROLOGUE, EXPRESSION) -# ----------------------------------------- -# We need `stdio.h' to open a `FILE', so the prologue defaults to the -# inclusion of `stdio.h'. -m4_define([AC_LANG_INT_SAVE(C)], -[AC_LANG_PROGRAM([m4_default([$1], [@%:@include ])], -[FILE *f = fopen ("conftest.val", "w"); -if (!f) - exit (1); -fprintf (f, "%d", ($2)); -fclose (f);])]) - - -# ----------------- # -# 2c. C++ sources. # -# ----------------- # - -# AC_LANG_SOURCE(C++)(BODY) -# ------------------------- -m4_copy([AC_LANG_SOURCE(C)], [AC_LANG_SOURCE(C++)]) - - -# AC_LANG_PROGRAM(C++)([PROLOGUE], [BODY]) -# ---------------------------------------- -m4_copy([AC_LANG_PROGRAM(C)], [AC_LANG_PROGRAM(C++)]) - - -# AC_LANG_CALL(C++)(PROLOGUE, FUNCTION) -# ------------------------------------- -m4_copy([AC_LANG_CALL(C)], [AC_LANG_CALL(C++)]) - - -# AC_LANG_FUNC_LINK_TRY(C++)(FUNCTION) -# ------------------------------------ -m4_copy([AC_LANG_FUNC_LINK_TRY(C)], [AC_LANG_FUNC_LINK_TRY(C++)]) - - -# AC_LANG_BOOL_COMPILE_TRY(C++)(PROLOGUE, EXPRESSION) -# --------------------------------------------------- -m4_copy([AC_LANG_BOOL_COMPILE_TRY(C)], [AC_LANG_BOOL_COMPILE_TRY(C++)]) - - -# AC_LANG_INT_SAVE(C++)(PROLOGUE, EXPRESSION) -# ------------------------------------------- -m4_copy([AC_LANG_INT_SAVE(C)], [AC_LANG_INT_SAVE(C++)]) - - - -# ------------------------ # -# 2d. Fortran 77 sources. # -# ------------------------ # - -# AC_LANG_SOURCE(Fortran 77)(BODY) -# -------------------------------- -# FIXME: Apparently, according to former AC_TRY_COMPILER, the CPP -# directives must not be included. But AC_TRY_RUN_NATIVE was not -# avoiding them, so? -m4_define([AC_LANG_SOURCE(Fortran 77)], -[$1]) - - -# AC_LANG_PROGRAM(Fortran 77)([PROLOGUE], [BODY]) -# ----------------------------------------------- -# Yes, we discard the PROLOGUE. -m4_define([AC_LANG_PROGRAM(Fortran 77)], -[m4_ifval([$1], - [m4_warn([syntax], [$0: ignoring PROLOGUE: $1])])dnl - program main -$2 - end]) - - -# AC_LANG_CALL(Fortran 77)(PROLOGUE, FUNCTION) -# -------------------------------------------- -# FIXME: This is a guess, help! -m4_define([AC_LANG_CALL(Fortran 77)], -[AC_LANG_PROGRAM([$1], -[ call $2])]) - - - - ## -------------------------------------------- ## ## 3. Looking for Compilers and Preprocessors. ## ## -------------------------------------------- ## @@ -805,1381 +560,9 @@ ac_objext=$OBJEXT ])# _AC_COMPILER_OBJEXT -# -------------------- # -# 3b. The C compiler. # -# -------------------- # - - -# _AC_ARG_VAR_CPPFLAGS -# -------------------- -# Document and register CPPFLAGS, which is used by -# AC_PROG_{CC, CPP, CXX, CXXCPP}. -AC_DEFUN([_AC_ARG_VAR_CPPFLAGS], -[AC_ARG_VAR([CPPFLAGS], - [C/C++ preprocessor flags, e.g. -I if you have - headers in a nonstandard directory ])]) - - -# _AC_ARG_VAR_LDFLAGS -# ------------------- -# Document and register LDFLAGS, which is used by -# AC_PROG_{CC, CXX, F77}. -AC_DEFUN([_AC_ARG_VAR_LDFLAGS], -[AC_ARG_VAR([LDFLAGS], - [linker flags, e.g. -L if you have libraries in a - nonstandard directory ])]) - - - -# AC_LANG_PREPROC(C) -# ------------------- -# Find the C preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. -AC_DEFUN([AC_LANG_PREPROC(C)], -[AC_REQUIRE([AC_PROG_CPP])]) - - -# _AC_PROG_PREPROC_WORKS_IFELSE(IF-WORKS, IF-NOT) -# ----------------------------------------------- -# Check if $ac_cpp is a working preprocessor that can flag absent -# includes either by the exit status or by warnings. -# Set ac_cpp_err to a non-empty value if the preprocessor failed. -# This macro is for all languages, not only C. -AC_DEFUN([_AC_PROG_PREPROC_WORKS_IFELSE], -[ac_preproc_ok=false -for ac_[]_AC_LANG_ABBREV[]_preproc_warn_flag in '' yes -do - # Use a header file that comes with gcc, so configuring glibc - # with a fresh cross-compiler works. - # On the NeXT, cc -E runs the code through the compiler's parser, - # not just through cpp. "Syntax error" is here to catch this case. - _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@include - Syntax error]])], - [], - [# Broken: fails on valid input. -continue]) - - # OK, works on sane cases. Now check whether non-existent headers - # can be detected and how. - _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@include ]])], - [# Broken: success on invalid input. -continue], - [# Passes both tests. -ac_preproc_ok=: -break]) - -done -# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. -rm -f conftest.err conftest.$ac_ext -AS_IF([$ac_preproc_ok], [$1], [$2])])# _AC_PROG_PREPROC_WORKS_IFELSE - - -# AC_PROG_CPP -# ----------- -# Find a working C preprocessor. -# We shouldn't have to require AC_PROG_CC, but this is due to the concurrency -# between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CC. -AC_DEFUN([AC_PROG_CPP], -[AC_REQUIRE([AC_PROG_CC])dnl -AC_ARG_VAR([CPP], [C preprocessor])dnl -_AC_ARG_VAR_CPPFLAGS()dnl -AC_LANG_PUSH(C)dnl -AC_MSG_CHECKING([how to run the C preprocessor]) -# On Suns, sometimes $CPP names a directory. -if test -n "$CPP" && test -d "$CPP"; then - CPP= -fi -if test -z "$CPP"; then - AC_CACHE_VAL([ac_cv_prog_CPP], - [dnl - # Double quotes because CPP needs to be expanded - for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" - do - _AC_PROG_PREPROC_WORKS_IFELSE([break]) - done - ac_cv_prog_CPP=$CPP - ])dnl - CPP=$ac_cv_prog_CPP -else - ac_cv_prog_CPP=$CPP -fi -AC_MSG_RESULT([$CPP]) -_AC_PROG_PREPROC_WORKS_IFELSE([], - [AC_MSG_ERROR([C preprocessor "$CPP" fails sanity check])]) -AC_SUBST(CPP)dnl -AC_LANG_POP(C)dnl -])# AC_PROG_CPP - - -# AC_LANG_COMPILER(C) -# ------------------- -# Find the C compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able. -AC_DEFUN([AC_LANG_COMPILER(C)], -[AC_REQUIRE([AC_PROG_CC])]) - - -# ac_cv_prog_gcc -# -------------- -# We used to name the cache variable this way. -AU_DEFUN([ac_cv_prog_gcc], -[ac_cv_c_compiler_gnu]) - - -# AC_PROG_CC([COMPILER ...]) -# -------------------------- -# COMPILER ... is a space separated list of C compilers to search for. -# This just gives the user an opportunity to specify an alternative -# search list for the C compiler. -AC_DEFUN([AC_PROG_CC], -[AC_LANG_PUSH(C)dnl -AC_ARG_VAR([CC], [C compiler command])dnl -AC_ARG_VAR([CFLAGS], [C compiler flags])dnl -_AC_ARG_VAR_LDFLAGS()dnl -_AC_ARG_VAR_CPPFLAGS()dnl -m4_ifval([$1], - [AC_CHECK_TOOLS(CC, [$1])], -[AC_CHECK_TOOL(CC, gcc) -if test -z "$CC"; then - AC_CHECK_TOOL(CC, cc) -fi -if test -z "$CC"; then - AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc) -fi -if test -z "$CC"; then - AC_CHECK_TOOLS(CC, cl) -fi -]) - -test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH]) - -# Provide some information about the compiler. -echo "$as_me:__oline__:" \ - "checking for _AC_LANG compiler version" >&AS_MESSAGE_LOG_FD -ac_compiler=`set X $ac_compile; echo $[2]` -_AC_EVAL([$ac_compiler --version &AS_MESSAGE_LOG_FD]) -_AC_EVAL([$ac_compiler -v &AS_MESSAGE_LOG_FD]) -_AC_EVAL([$ac_compiler -V &AS_MESSAGE_LOG_FD]) - -m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl -m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl -_AC_LANG_COMPILER_GNU -GCC=`test $ac_compiler_gnu = yes && echo yes` -_AC_PROG_CC_G -# Some people use a C++ compiler to compile C. Since we use `exit', -# in C++ we need to declare it. In case someone uses the same compiler -# for both compiling C and C++ we need to have the C++ compiler decide -# the declaration of exit, since it's the most demanding environment. -_AC_COMPILE_IFELSE([@%:@ifndef __cplusplus - choke me -@%:@endif], - [_AC_PROG_CXX_EXIT_DECLARATION]) -AC_LANG_POP(C)dnl -])# AC_PROG_CC - - -# _AC_PROG_CC_G -# ------------- -# Check whether -g works, even if CFLAGS is set, in case the package -# plays around with CFLAGS (such as to build both debugging and normal -# versions of a library), tasteless as that idea is. -m4_define([_AC_PROG_CC_G], -[ac_test_CFLAGS=${CFLAGS+set} -ac_save_CFLAGS=$CFLAGS -CFLAGS="-g" -AC_CACHE_CHECK(whether $CC accepts -g, ac_cv_prog_cc_g, - [_AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], [ac_cv_prog_cc_g=yes], - [ac_cv_prog_cc_g=no])]) -if test "$ac_test_CFLAGS" = set; then - CFLAGS=$ac_save_CFLAGS -elif test $ac_cv_prog_cc_g = yes; then - if test "$GCC" = yes; then - CFLAGS="-g -O2" - else - CFLAGS="-g" - fi -else - if test "$GCC" = yes; then - CFLAGS="-O2" - else - CFLAGS= - fi -fi[]dnl -])# _AC_PROG_CC_G - - -# AC_PROG_GCC_TRADITIONAL -# ----------------------- -AC_DEFUN([AC_PROG_GCC_TRADITIONAL], -[if test $ac_cv_c_compiler_gnu = yes; then - AC_CACHE_CHECK(whether $CC needs -traditional, - ac_cv_prog_gcc_traditional, -[ ac_pattern="Autoconf.*'x'" - AC_EGREP_CPP($ac_pattern, [#include -Autoconf TIOCGETP], - ac_cv_prog_gcc_traditional=yes, ac_cv_prog_gcc_traditional=no) - - if test $ac_cv_prog_gcc_traditional = no; then - AC_EGREP_CPP($ac_pattern, [#include -Autoconf TCGETA], - ac_cv_prog_gcc_traditional=yes) - fi]) - if test $ac_cv_prog_gcc_traditional = yes; then - CC="$CC -traditional" - fi -fi -])# AC_PROG_GCC_TRADITIONAL - - -# AC_PROG_CC_C_O -# -------------- -AC_DEFUN([AC_PROG_CC_C_O], -[AC_REQUIRE([AC_PROG_CC])dnl -if test "x$CC" != xcc; then - AC_MSG_CHECKING([whether $CC and cc understand -c and -o together]) -else - AC_MSG_CHECKING([whether cc understands -c and -o together]) -fi -set dummy $CC; ac_cc=`echo $[2] | - sed 's/[[^a-zA-Z0-9_]]/_/g;s/^[[0-9]]/_/'` -AC_CACHE_VAL(ac_cv_prog_cc_${ac_cc}_c_o, -[AC_LANG_CONFTEST([AC_LANG_PROGRAM([])]) -# Make sure it works both with $CC and with simple cc. -# We do the test twice because some compilers refuse to overwrite an -# existing .o file with -o, though they will create one. -ac_try='$CC -c conftest.$ac_ext -o conftest.$ac_objext >&AS_MESSAGE_LOG_FD' -if AC_TRY_EVAL(ac_try) && - test -f conftest.$ac_objext && AC_TRY_EVAL(ac_try); -then - eval ac_cv_prog_cc_${ac_cc}_c_o=yes - if test "x$CC" != xcc; then - # Test first that cc exists at all. - if AC_TRY_COMMAND(cc -c conftest.$ac_ext >&AS_MESSAGE_LOG_FD); then - ac_try='cc -c conftest.$ac_ext -o conftest.$ac_objext >&AS_MESSAGE_LOG_FD' - if AC_TRY_EVAL(ac_try) && - test -f conftest.$ac_objext && AC_TRY_EVAL(ac_try); - then - # cc works too. - : - else - # cc exists but doesn't like -o. - eval ac_cv_prog_cc_${ac_cc}_c_o=no - fi - fi - fi -else - eval ac_cv_prog_cc_${ac_cc}_c_o=no -fi -rm -f conftest* -])dnl -if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = yes"; then - AC_MSG_RESULT([yes]) -else - AC_MSG_RESULT([no]) - AC_DEFINE(NO_MINUS_C_MINUS_O, 1, - [Define if your C compiler doesn't accept -c and -o together.]) -fi -])# AC_PROG_CC_C_O - - -# ---------------------- # -# 3c. The C++ compiler. # -# ---------------------- # - - -# AC_LANG_PREPROC(C++) -# --------------------- -# Find the C++ preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. -AC_DEFUN([AC_LANG_PREPROC(C++)], -[AC_REQUIRE([AC_PROG_CXXCPP])]) - - -# AC_PROG_CXXCPP -# -------------- -# Find a working C++ preprocessor. -# We shouldn't have to require AC_PROG_CC, but this is due to the concurrency -# between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CXX. -AC_DEFUN([AC_PROG_CXXCPP], -[AC_REQUIRE([AC_PROG_CXX])dnl -AC_ARG_VAR([CXXCPP], [C++ preprocessor])dnl -_AC_ARG_VAR_CPPFLAGS()dnl -AC_LANG_PUSH(C++)dnl -AC_MSG_CHECKING([how to run the C++ preprocessor]) -if test -z "$CXXCPP"; then - AC_CACHE_VAL(ac_cv_prog_CXXCPP, - [dnl - # Double quotes because CXXCPP needs to be expanded - for CXXCPP in "$CXX -E" "/lib/cpp" - do - _AC_PROG_PREPROC_WORKS_IFELSE([break]) - done - ac_cv_prog_CXXCPP=$CXXCPP - ])dnl - CXXCPP=$ac_cv_prog_CXXCPP -else - ac_cv_prog_CXXCPP=$CXXCPP -fi -AC_MSG_RESULT([$CXXCPP]) -_AC_PROG_PREPROC_WORKS_IFELSE([], - [AC_MSG_ERROR([C++ preprocessor "$CXXCPP" fails sanity check])]) -AC_SUBST(CXXCPP)dnl -AC_LANG_POP(C++)dnl -])# AC_PROG_CXXCPP - - -# AC_LANG_COMPILER(C++) -# --------------------- -# Find the C++ compiler. Must be AC_DEFUN'd to be AC_REQUIRE'able. -AC_DEFUN([AC_LANG_COMPILER(C++)], -[AC_REQUIRE([AC_PROG_CXX])]) - - -# ac_cv_prog_gxx -# -------------- -# We used to name the cache variable this way. -AU_DEFUN([ac_cv_prog_gxx], -[ac_cv_cxx_compiler_gnu]) - - -# AC_PROG_CXX([LIST-OF-COMPILERS]) -# -------------------------------- -# LIST-OF-COMPILERS is a space separated list of C++ compilers to search -# for (if not specified, a default list is used). This just gives the -# user an opportunity to specify an alternative search list for the C++ -# compiler. -# aCC HP-UX C++ compiler much better than `CC', so test before. -# FCC Fujitsu C++ compiler -# KCC KAI C++ compiler -# RCC Rational C++ -# xlC_r AIX C Set++ (with support for reentrant code) -# xlC AIX C Set++ -AC_DEFUN([AC_PROG_CXX], -[AC_LANG_PUSH(C++)dnl -AC_ARG_VAR([CXX], [C++ compiler command])dnl -AC_ARG_VAR([CXXFLAGS], [C++ compiler flags])dnl -_AC_ARG_VAR_LDFLAGS()dnl -_AC_ARG_VAR_CPPFLAGS()dnl -AC_CHECK_TOOLS(CXX, - [$CCC m4_default([$1], - [g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC])], - g++) - -# Provide some information about the compiler. -echo "$as_me:__oline__:" \ - "checking for _AC_LANG compiler version" >&AS_MESSAGE_LOG_FD -ac_compiler=`set X $ac_compile; echo $[2]` -_AC_EVAL([$ac_compiler --version &AS_MESSAGE_LOG_FD]) -_AC_EVAL([$ac_compiler -v &AS_MESSAGE_LOG_FD]) -_AC_EVAL([$ac_compiler -V &AS_MESSAGE_LOG_FD]) - -m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl -m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl -_AC_LANG_COMPILER_GNU -GXX=`test $ac_compiler_gnu = yes && echo yes` -_AC_PROG_CXX_G -_AC_PROG_CXX_EXIT_DECLARATION -AC_LANG_POP(C++)dnl -])# AC_PROG_CXX - - -# _AC_PROG_CXX_G -# -------------- -# Check whether -g works, even if CXXFLAGS is set, in case the package -# plays around with CXXFLAGS (such as to build both debugging and -# normal versions of a library), tasteless as that idea is. -m4_define([_AC_PROG_CXX_G], -[ac_test_CXXFLAGS=${CXXFLAGS+set} -ac_save_CXXFLAGS=$CXXFLAGS -CXXFLAGS="-g" -AC_CACHE_CHECK(whether $CXX accepts -g, ac_cv_prog_cxx_g, - [_AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], - [ac_cv_prog_cxx_g=yes], - [ac_cv_prog_cxx_g=no])]) -if test "$ac_test_CXXFLAGS" = set; then - CXXFLAGS=$ac_save_CXXFLAGS -elif test $ac_cv_prog_cxx_g = yes; then - if test "$GXX" = yes; then - CXXFLAGS="-g -O2" - else - CXXFLAGS="-g" - fi -else - if test "$GXX" = yes; then - CXXFLAGS="-O2" - else - CXXFLAGS= - fi -fi[]dnl -])# _AC_PROG_CXX_G - - -# _AC_PROG_CXX_EXIT_DECLARATION -# ----------------------------- -# Find a valid prototype for exit and declare it in confdefs.h. -m4_define([_AC_PROG_CXX_EXIT_DECLARATION], -[for ac_declaration in \ - ''\ - '#include ' \ - 'extern "C" void std::exit (int) throw (); using std::exit;' \ - 'extern "C" void std::exit (int); using std::exit;' \ - 'extern "C" void exit (int) throw ();' \ - 'extern "C" void exit (int);' \ - 'void exit (int);' -do - _AC_COMPILE_IFELSE([AC_LANG_PROGRAM([@%:@include -$ac_declaration], - [exit (42);])], - [], - [continue]) - _AC_COMPILE_IFELSE([AC_LANG_PROGRAM([$ac_declaration], - [exit (42);])], - [break]) -done -rm -f conftest* -if test -n "$ac_declaration"; then - echo '#ifdef __cplusplus' >>confdefs.h - echo $ac_declaration >>confdefs.h - echo '#endif' >>confdefs.h -fi -])# _AC_PROG_CXX_EXIT_DECLARATION - - -# ----------------------------- # -# 3d. The Fortran 77 compiler. # -# ----------------------------- # - - -# AC_LANG_PREPROC(Fortran 77) -# --------------------------- -# Find the Fortran 77 preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able. -AC_DEFUN([AC_LANG_PREPROC(Fortran 77)], -[m4_warn([syntax], - [$0: No preprocessor defined for ]_AC_LANG)]) - - -# AC_LANG_COMPILER(Fortran 77) -# ---------------------------- -# Find the Fortran 77 compiler. Must be AC_DEFUN'd to be -# AC_REQUIRE'able. -AC_DEFUN([AC_LANG_COMPILER(Fortran 77)], -[AC_REQUIRE([AC_PROG_F77])]) - - -# ac_cv_prog_g77 -# -------------- -# We used to name the cache variable this way. -AU_DEFUN([ac_cv_prog_g77], -[ac_cv_f77_compiler_gnu]) - - -# AC_PROG_F77([COMPILERS...]) -# --------------------------- -# COMPILERS is a space separated list of Fortran 77 compilers to search -# for. -# Fortran 95 isn't strictly backwards-compatiable with Fortran 77, but -# `f95' is worth trying. -# -# Compilers are ordered by -# 1. F77, F90, F95 -# 2. Good/tested native compilers, bad/untested native compilers -# 3. Wrappers around f2c go last. -# -# `fort77' and `fc' are wrappers around `f2c', `fort77' being better. -# It is believed that under HP-UX `fort77' is the name of the native -# compiler. On some Cray systems, fort77 is a native compiler. -# cf77 and cft77 are (older) Cray F77 compilers. -# frt is the Fujitsu F77 compiler. -# pgf77 and pgf90 are the Portland Group F77 and F90 compilers. -# xlf/xlf90/xlf95 are IBM (AIX) F77/F90/F95 compilers. -# lf95 is the Lahey-Fujitsu compiler. -# fl32 is the Microsoft Fortran "PowerStation" compiler. -# af77 is the Apogee F77 compiler for Intergraph hardware running CLIX. -# epcf90 is the "Edinburgh Portable Compiler" F90. -# fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha. -AC_DEFUN([AC_PROG_F77], -[AC_LANG_PUSH(Fortran 77)dnl -AC_ARG_VAR([F77], [Fortran 77 compiler command])dnl -AC_ARG_VAR([FFLAGS], [Fortran 77 compiler flags])dnl -_AC_ARG_VAR_LDFLAGS()dnl -AC_CHECK_TOOLS(F77, - [m4_default([$1], - [g77 f77 xlf cf77 cft77 frt pgf77 fl32 af77 fort77 f90 xlf90 pgf90 epcf90 f95 fort xlf95 lf95 g95 fc])]) - -# Provide some information about the compiler. -echo "$as_me:__oline__:" \ - "checking for _AC_LANG compiler version" >&AS_MESSAGE_LOG_FD -ac_compiler=`set X $ac_compile; echo $[2]` -_AC_EVAL([$ac_compiler --version &AS_MESSAGE_LOG_FD]) -_AC_EVAL([$ac_compiler -v &AS_MESSAGE_LOG_FD]) -_AC_EVAL([$ac_compiler -V &AS_MESSAGE_LOG_FD]) - -m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl -m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl -# If we don't use `.F' as extension, the preprocessor is not run on the -# input file. -ac_save_ext=$ac_ext -ac_ext=F -_AC_LANG_COMPILER_GNU -ac_ext=$ac_save_ext -G77=`test $ac_compiler_gnu = yes && echo yes` -_AC_PROG_F77_G -AC_LANG_POP(Fortran 77)dnl -])# AC_PROG_F77 - - -# _AC_PROG_F77_G -# -------------- -# Check whether -g works, even if FFLAGS is set, in case the package -# plays around with FFLAGS (such as to build both debugging and normal -# versions of a library), tasteless as that idea is. -m4_define([_AC_PROG_F77_G], -[ac_test_FFLAGS=${FFLAGS+set} -ac_save_FFLAGS=$FFLAGS -FFLAGS= -AC_CACHE_CHECK(whether $F77 accepts -g, ac_cv_prog_f77_g, -[FFLAGS=-g -_AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], -[ac_cv_prog_f77_g=yes], -[ac_cv_prog_f77_g=no]) -]) -if test "$ac_test_FFLAGS" = set; then - FFLAGS=$ac_save_FFLAGS -elif test $ac_cv_prog_f77_g = yes; then - if test "$G77" = yes; then - FFLAGS="-g -O2" - else - FFLAGS="-g" - fi -else - if test "$G77" = yes; then - FFLAGS="-O2" - else - FFLAGS= - fi -fi[]dnl -])# _AC_PROG_F77_G - - -# AC_PROG_F77_C_O -# --------------- -# Test if the Fortran 77 compiler accepts the options `-c' and `-o' -# simultaneously, and define `F77_NO_MINUS_C_MINUS_O' if it does not. -# -# The usefulness of this macro is questionable, as I can't really see -# why anyone would use it. The only reason I include it is for -# completeness, since a similar test exists for the C compiler. -AC_DEFUN([AC_PROG_F77_C_O], -[AC_REQUIRE([AC_PROG_F77])dnl -AC_CACHE_CHECK([whether $F77 understand -c and -o together], - [ac_cv_prog_f77_c_o], -[AC_LANG_CONFTEST([AC_LANG_PROGRAM([])]) -# We test twice because some compilers refuse to overwrite an existing -# `.o' file with `-o', although they will create one. -ac_try='$F77 $FFLAGS -c conftest.$ac_ext -o conftest.$ac_objext >&AS_MESSAGE_LOG_FD' -if AC_TRY_EVAL(ac_try) && - test -f conftest.$ac_objext && - AC_TRY_EVAL(ac_try); then - ac_cv_prog_f77_c_o=yes -else - ac_cv_prog_f77_c_o=no -fi -rm -f conftest*]) -if test $ac_cv_prog_f77_c_o = no; then - AC_DEFINE(F77_NO_MINUS_C_MINUS_O, 1, - [Define if your Fortran 77 compiler doesn't accept -c and -o together.]) -fi -])# AC_PROG_F77_C_O - - ## ------------------------------- ## ## 4. Compilers' characteristics. ## ## ------------------------------- ## - - -# -------------------------------- # -# 4b. C compiler characteristics. # -# -------------------------------- # - -# AC_PROG_CC_STDC -# --------------- -# If the C compiler in not in ANSI C mode by default, try to add an -# option to output variable @code{CC} to make it so. This macro tries -# various options that select ANSI C on some system or another. It -# considers the compiler to be in ANSI C mode if it handles function -# prototypes correctly. -AC_DEFUN([AC_PROG_CC_STDC], -[AC_REQUIRE([AC_PROG_CC])dnl -AC_BEFORE([$0], [AC_C_INLINE])dnl -AC_BEFORE([$0], [AC_C_CONST])dnl -dnl Force this before AC_PROG_CPP. Some cpp's, eg on HPUX, require -dnl a magic option to avoid problems with ANSI preprocessor commands -dnl like #elif. -dnl FIXME: can't do this because then AC_AIX won't work due to a -dnl circular dependency. -dnl AC_BEFORE([$0], [AC_PROG_CPP]) -AC_MSG_CHECKING([for $CC option to accept ANSI C]) -AC_CACHE_VAL(ac_cv_prog_cc_stdc, -[ac_cv_prog_cc_stdc=no -ac_save_CC=$CC -AC_LANG_CONFTEST([AC_LANG_PROGRAM( -[[#include -#include -#include -#include -/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ -struct buf { int x; }; -FILE * (*rcsopen) (struct buf *, struct stat *, int); -static char *e (p, i) - char **p; - int i; -{ - return p[i]; -} -static char *f (char * (*g) (char **, int), char **p, ...) -{ - char *s; - va_list v; - va_start (v,p); - s = g (p, va_arg (v,int)); - va_end (v); - return s; -} -int test (int i, double x); -struct s1 {int (*f) (int a);}; -struct s2 {int (*f) (double a);}; -int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); -int argc; -char **argv;]], -[[return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];]])]) -# Don't try gcc -ansi; that turns off useful extensions and -# breaks some systems' header files. -# AIX -qlanglvl=ansi -# Ultrix and OSF/1 -std1 -# HP-UX 10.20 and later -Ae -# HP-UX older versions -Aa -D_HPUX_SOURCE -# SVR4 -Xc -D__EXTENSIONS__ -for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" -do - CC="$ac_save_CC $ac_arg" - AC_COMPILE_IFELSE([], - [ac_cv_prog_cc_stdc=$ac_arg -break]) -done -rm -f conftest.$ac_ext conftest.$ac_objext -CC=$ac_save_CC -]) -case "x$ac_cv_prog_cc_stdc" in - x|xno) - AC_MSG_RESULT([none needed]) ;; - *) - AC_MSG_RESULT([$ac_cv_prog_cc_stdc]) - CC="$CC $ac_cv_prog_cc_stdc" ;; -esac -])# AC_PROG_CC_STDC - - -# AC_C_CROSS -# ---------- -# Has been merged into AC_PROG_CC. -AU_DEFUN([AC_C_CROSS], []) - - -# AC_C_CHAR_UNSIGNED -# ------------------ -AC_DEFUN([AC_C_CHAR_UNSIGNED], -[AH_VERBATIM([__CHAR_UNSIGNED__], -[/* Define if type `char' is unsigned and you are not using gcc. */ -#ifndef __CHAR_UNSIGNED__ -# undef __CHAR_UNSIGNED__ -#endif])dnl -AC_CACHE_CHECK(whether char is unsigned, ac_cv_c_char_unsigned, -[AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([AC_INCLUDES_DEFAULT([])], - [((char) -1) < 0])], - ac_cv_c_char_unsigned=no, ac_cv_c_char_unsigned=yes)]) -if test $ac_cv_c_char_unsigned = yes && test "$GCC" != yes; then - AC_DEFINE(__CHAR_UNSIGNED__) -fi -])# AC_C_CHAR_UNSIGNED - - -# AC_C_LONG_DOUBLE -# ---------------- -AC_DEFUN([AC_C_LONG_DOUBLE], -[AC_CACHE_CHECK(for long double, ac_cv_c_long_double, -[if test "$GCC" = yes; then - ac_cv_c_long_double=yes -else -AC_TRY_RUN( -[int -main () -{ - /* The Stardent Vistra knows sizeof(long double), but does not - support it. */ - long double foo = 0.0; - /* On Ultrix 4.3 cc, long double is 4 and double is 8. */ - exit (sizeof (long double) < sizeof (double)); -}], -ac_cv_c_long_double=yes, ac_cv_c_long_double=no) -fi]) -if test $ac_cv_c_long_double = yes; then - AC_DEFINE(HAVE_LONG_DOUBLE, 1, - [Define if the `long double' type works.]) -fi -])# AC_C_LONG_DOUBLE - - -# AC_C_BIGENDIAN -# -------------- -AC_DEFUN([AC_C_BIGENDIAN], -[AC_CACHE_CHECK(whether byte ordering is bigendian, ac_cv_c_bigendian, -[ac_cv_c_bigendian=unknown -# See if sys/param.h defines the BYTE_ORDER macro. -AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include -#include -], -[#if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN - bogus endian macros -#endif -])], -[# It does; now see whether it defined to BIG_ENDIAN or not. -AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include -#include -], [#if BYTE_ORDER != BIG_ENDIAN - not big endian -#endif -])], [ac_cv_c_bigendian=yes], - [ac_cv_c_bigendian=no])]) -if test $ac_cv_c_bigendian = unknown; then -AC_TRY_RUN( -[int -main () -{ - /* Are we little or big endian? From Harbison&Steele. */ - union - { - long l; - char c[sizeof (long)]; - } u; - u.l = 1; - exit (u.c[sizeof (long) - 1] == 1); -}], ac_cv_c_bigendian=no, ac_cv_c_bigendian=yes) -fi]) -if test $ac_cv_c_bigendian = yes; then - AC_DEFINE(WORDS_BIGENDIAN, 1, - [Define if your processor stores words with the most significant - byte first (like Motorola and SPARC, unlike Intel and VAX).]) -fi -])# AC_C_BIGENDIAN - - -# AC_C_INLINE -# ----------- -# Do nothing if the compiler accepts the inline keyword. -# Otherwise define inline to __inline__ or __inline if one of those work, -# otherwise define inline to be empty. -AC_DEFUN([AC_C_INLINE], -[AC_REQUIRE([AC_PROG_CC_STDC])dnl -AC_CACHE_CHECK([for inline], ac_cv_c_inline, -[ac_cv_c_inline=no -for ac_kw in inline __inline__ __inline; do - AC_COMPILE_IFELSE([AC_LANG_SOURCE( -[#ifndef __cplusplus -static $ac_kw int static_foo () {return 0; } -$ac_kw int foo () {return 0; } -#endif -])], - [ac_cv_c_inline=$ac_kw; break]) -done -]) -case $ac_cv_c_inline in - inline | yes) ;; - no) AC_DEFINE(inline,, - [Define as `__inline' if that's what the C compiler calls it, - or to nothing if it is not supported.]) ;; - *) AC_DEFINE_UNQUOTED(inline, $ac_cv_c_inline) ;; -esac -])# AC_C_INLINE - - -# AC_C_CONST -# ---------- -AC_DEFUN([AC_C_CONST], -[AC_REQUIRE([AC_PROG_CC_STDC])dnl -AC_CACHE_CHECK([for an ANSI C-conforming const], ac_cv_c_const, -[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], -[[/* FIXME: Include the comments suggested by Paul. */ -#ifndef __cplusplus - /* Ultrix mips cc rejects this. */ - typedef int charset[2]; - const charset x; - /* SunOS 4.1.1 cc rejects this. */ - char const *const *ccp; - char **p; - /* NEC SVR4.0.2 mips cc rejects this. */ - struct point {int x, y;}; - static struct point const zero = {0,0}; - /* AIX XL C 1.02.0.0 rejects this. - It does not let you subtract one const X* pointer from another in - an arm of an if-expression whose if-part is not a constant - expression */ - const char *g = "string"; - ccp = &g + (g ? g-g : 0); - /* HPUX 7.0 cc rejects these. */ - ++ccp; - p = (char**) ccp; - ccp = (char const *const *) p; - { /* SCO 3.2v4 cc rejects this. */ - char *t; - char const *s = 0 ? (char *) 0 : (char const *) 0; - - *t++ = 0; - } - { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */ - int x[] = {25, 17}; - const int *foo = &x[0]; - ++foo; - } - { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */ - typedef const int *iptr; - iptr p = 0; - ++p; - } - { /* AIX XL C 1.02.0.0 rejects this saying - "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */ - struct s { int j; const int *ap[3]; }; - struct s *b; b->j = 5; - } - { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ - const int foo = 10; - } -#endif -]])], - [ac_cv_c_const=yes], - [ac_cv_c_const=no])]) -if test $ac_cv_c_const = no; then - AC_DEFINE(const,, - [Define to empty if `const' does not conform to ANSI C.]) -fi -])# AC_C_CONST - - -# AC_C_VOLATILE -# ------------- -# Note that, unlike const, #defining volatile to be the empty string can -# actually turn a correct program into an incorrect one, since removing -# uses of volatile actually grants the compiler permission to perform -# optimizations that could break the user's code. So, do not #define -# volatile away unless it is really necessary to allow the user's code -# to compile cleanly. Benign compiler failures should be tolerated. -AC_DEFUN([AC_C_VOLATILE], -[AC_REQUIRE([AC_PROG_CC_STDC])dnl -AC_CACHE_CHECK([for working volatile], ac_cv_c_volatile, -[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [ -volatile int x; -int * volatile y;])], - [ac_cv_c_volatile=yes], - [ac_cv_c_volatile=no])]) -if test $ac_cv_c_volatile = no; then - AC_DEFINE(volatile,, - [Define to empty if the keyword `volatile' does not work. - Warning: valid code using `volatile' can become incorrect - without. Disable with care.]) -fi -])# AC_C_VOLATILE - - -# AC_C_STRINGIZE -# -------------- -# Checks if `#' can be used to glue strings together at the CPP level. -# Defines HAVE_STRINGIZE if positive. -AC_DEFUN([AC_C_STRINGIZE], -[AC_CACHE_CHECK([for preprocessor stringizing operator], - [ac_cv_c_stringize], -[AC_EGREP_CPP([@%:@teststring], - [@%:@define x(y) #y - -char *s = x(teststring);], - [ac_cv_c_stringize=no], - [ac_cv_c_stringize=yes])]) -if test $ac_cv_c_stringize = yes; then - AC_DEFINE(HAVE_STRINGIZE, 1, - [Define if cpp supports the ANSI @%:@ stringizing operator.]) -fi -])# AC_C_STRINGIZE - - -# AC_C_PROTOTYPES -# --------------- -# Check if the C compiler supports prototypes, included if it needs -# options. -AC_DEFUN([AC_C_PROTOTYPES], -[AC_REQUIRE([AC_PROG_CC_STDC])dnl -AC_MSG_CHECKING([for function prototypes]) -if test "$ac_cv_prog_cc_stdc" != no; then - AC_MSG_RESULT([yes]) - AC_DEFINE(PROTOTYPES, 1, - [Define if the C compiler supports function prototypes.]) -else - AC_MSG_RESULT([no]) -fi -])# AC_C_PROTOTYPES - - - - -# ---------------------------------------- # -# 4d. Fortan 77 compiler characteristics. # -# ---------------------------------------- # - - -# _AC_PROG_F77_V_OUTPUT([FLAG = $ac_cv_prog_f77_v]) -# ------------------------------------------------- -# Link a trivial Fortran program, compiling with a verbose output FLAG -# (which default value, $ac_cv_prog_f77_v, is computed by -# _AC_PROG_F77_V), and return the output in $ac_f77_v_output. This -# output is processed in the way expected by AC_F77_LIBRARY_LDFLAGS, -# so that any link flags that are echoed by the compiler appear as -# space-separated items. -AC_DEFUN([_AC_PROG_F77_V_OUTPUT], -[AC_REQUIRE([AC_PROG_F77])dnl -AC_LANG_PUSH(Fortran 77)dnl - -AC_LANG_CONFTEST([AC_LANG_PROGRAM([])]) - -# Compile and link our simple test program by passing a flag (argument -# 1 to this macro) to the Fortran 77 compiler in order to get -# "verbose" output that we can then parse for the Fortran 77 linker -# flags. -ac_save_FFLAGS=$FFLAGS -FFLAGS="$FFLAGS m4_default([$1], [$ac_cv_prog_f77_v])" -(eval echo $as_me:__oline__: \"$ac_link\") >&AS_MESSAGE_LOG_FD -ac_f77_v_output=`eval $ac_link AS_MESSAGE_LOG_FD>&1 2>&1 | grep -v 'Driving:'` -echo "$ac_f77_v_output" >&AS_MESSAGE_LOG_FD -FFLAGS=$ac_save_FFLAGS - -rm -f conftest* -AC_LANG_POP(Fortran 77)dnl - -# If we are using xlf then replace all the commas with spaces. -if echo $ac_f77_v_output | grep xlfentry >/dev/null 2>&1; then - ac_f77_v_output=`echo $ac_f77_v_output | sed 's/,/ /g'` -fi - -# If we are using Cray Fortran then delete quotes. -# Use "\"" instead of '"' for font-lock-mode. -# FIXME: a more general fix for quoted arguments with spaces? -if echo $ac_f77_v_output | grep cft90 >/dev/null 2>&1; then - ac_f77_v_output=`echo $ac_f77_v_output | sed "s/\"//g"` -fi[]dnl -])# _AC_PROG_F77_V_OUTPUT - - -# _AC_PROG_F77_V -# -------------- -# -# Determine the flag that causes the Fortran 77 compiler to print -# information of library and object files (normally -v) -# Needed for AC_F77_LIBRARY_FLAGS -# Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###) -AC_DEFUN([_AC_PROG_F77_V], -[AC_CACHE_CHECK([how to get verbose linking output from $F77], - [ac_cv_prog_f77_v], -[AC_LANG_ASSERT(Fortran 77) -AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], -[ac_cv_prog_f77_v= -# Try some options frequently used verbose output -for ac_verb in -v -verbose --verbose -V -\#\#\#; do - _AC_PROG_F77_V_OUTPUT($ac_verb) - # look for -l* and *.a constructs in the output - for ac_arg in $ac_f77_v_output; do - case $ac_arg in - [[\\/]]*.a | ?:[[\\/]]*.a | -[[lLRu]]*) - ac_cv_prog_f77_v=$ac_verb - break 2 ;; - esac - done -done -if test -z "$ac_cv_prog_f77_v"; then - AC_MSG_WARN([cannot determine how to obtain linking information from $F77]) -fi], - [AC_MSG_WARN([compilation failed])]) -])])# _AC_PROG_F77_V - - -# AC_F77_LIBRARY_LDFLAGS -# ---------------------- -# -# Determine the linker flags (e.g. "-L" and "-l") for the Fortran 77 -# intrinsic and run-time libraries that are required to successfully -# link a Fortran 77 program or shared library. The output variable -# FLIBS is set to these flags. -# -# This macro is intended to be used in those situations when it is -# necessary to mix, e.g. C++ and Fortran 77, source code into a single -# program or shared library. -# -# For example, if object files from a C++ and Fortran 77 compiler must -# be linked together, then the C++ compiler/linker must be used for -# linking (since special C++-ish things need to happen at link time -# like calling global constructors, instantiating templates, enabling -# exception support, etc.). -# -# However, the Fortran 77 intrinsic and run-time libraries must be -# linked in as well, but the C++ compiler/linker doesn't know how to -# add these Fortran 77 libraries. Hence, the macro -# "AC_F77_LIBRARY_LDFLAGS" was created to determine these Fortran 77 -# libraries. -# -# This macro was packaged in its current form by Matthew D. Langston. -# However, nearly all of this macro came from the "OCTAVE_FLIBS" macro -# in "octave-2.0.13/aclocal.m4", and full credit should go to John -# W. Eaton for writing this extremely useful macro. Thank you John. -AC_DEFUN([AC_F77_LIBRARY_LDFLAGS], -[AC_LANG_PUSH(Fortran 77)dnl -_AC_PROG_F77_V -AC_CACHE_CHECK([for Fortran 77 libraries], ac_cv_flibs, -[if test "x$FLIBS" != "x"; then - ac_cv_flibs="$FLIBS" # Let the user override the test. -else - -_AC_PROG_F77_V_OUTPUT - -ac_cv_flibs= - -# Save positional arguments (if any) -ac_save_positional="$[@]" - -set X $ac_f77_v_output -while test $[@%:@] != 1; do - shift - ac_arg=$[1] - case $ac_arg in - [[\\/]]*.a | ?:[[\\/]]*.a) - AC_LIST_MEMBER_OF($ac_arg, $ac_cv_flibs, , - ac_cv_flibs="$ac_cv_flibs $ac_arg") - ;; - -bI:*) - AC_LIST_MEMBER_OF($ac_arg, $ac_cv_flibs, , - [AC_LINKER_OPTION([$ac_arg], ac_cv_flibs)]) - ;; - # Ignore these flags. - -lang* | -lcrt0.o | -lc | -lgcc | -libmil | -LANG:=*) - ;; - -lkernel32) - test x"$CYGWIN" != xyes && ac_cv_flibs="$ac_cv_flibs $ac_arg" - ;; - -[[LRuY]]) - # These flags, when seen by themselves, take an argument. - # We remove the space between option and argument and re-iterate - # unless we find an empty arg or a new option (starting with -) - case $[2] in - "" | -*);; - *) - ac_arg="$ac_arg$[2]" - shift; shift - set X $ac_arg "$[@]" - ;; - esac - ;; - -YP,*) - for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do - AC_LIST_MEMBER_OF($ac_j, $ac_cv_flibs, , - [ac_arg="$ac_arg $ac_j" - ac_cv_flibs="$ac_cv_flibs $ac_j"]) - done - ;; - -[[lLR]]*) - AC_LIST_MEMBER_OF($ac_arg, $ac_cv_flibs, , - ac_cv_flibs="$ac_cv_flibs $ac_arg") - ;; - # Ignore everything else. - esac -done -# restore positional arguments -set X $ac_save_positional; shift - -# We only consider "LD_RUN_PATH" on Solaris systems. If this is seen, -# then we insist that the "run path" must be an absolute path (i.e. it -# must begin with a "/"). -case `(uname -sr) 2>/dev/null` in - "SunOS 5"*) - ac_ld_run_path=`echo $ac_f77_v_output | - sed -n 's,^.*LD_RUN_PATH *= *\(/[[^ ]]*\).*$,-R\1,p'` - test "x$ac_ld_run_path" != x && - AC_LINKER_OPTION([$ac_ld_run_path], ac_cv_flibs) - ;; -esac -fi # test "x$FLIBS" = "x" -]) -FLIBS="$ac_cv_flibs" -AC_SUBST(FLIBS) -AC_LANG_POP(Fortran 77)dnl -])# AC_F77_LIBRARY_LDFLAGS - - -# AC_F77_DUMMY_MAIN([ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) -# ----------------------------------------------------------- -# -# Detect name of dummy main routine required by the Fortran libraries, -# (if any) and define F77_DUMMY_MAIN to this name (which should be -# used for a dummy declaration, if it is defined). On some systems, -# linking a C program to the Fortran library does not work unless you -# supply a dummy function called something like MAIN__. -# -# Execute ACTION-IF-NOT-FOUND if no way of successfully linking a C -# program with the F77 libs is found; default to exiting with an error -# message. Execute ACTION-IF-FOUND if a dummy routine name is needed -# and found or if it is not needed (default to defining F77_DUMMY_MAIN -# when needed). -# -# What is technically happening is that the Fortran libraries provide -# their own main() function, which usually initializes Fortran I/O and -# similar stuff, and then calls MAIN__, which is the entry point of -# your program. Usually, a C program will override this with its own -# main() routine, but the linker sometimes complain if you don't -# provide a dummy (never-called) MAIN__ routine anyway. -# -# Of course, programs that want to allow Fortran subroutines to do -# I/O, etcetera, should call their main routine MAIN__() (or whatever) -# instead of main(). A separate autoconf test (AC_F77_MAIN) checks -# for the routine to use in this case (since the semantics of the test -# are slightly different). To link to e.g. purely numerical -# libraries, this is normally not necessary, however, and most C/C++ -# programs are reluctant to turn over so much control to Fortran. =) -# -# The name variants we check for are (in order): -# MAIN__ (g77, MAIN__ required on some systems; IRIX, MAIN__ optional) -# MAIN_, __main (SunOS) -# MAIN _MAIN __MAIN main_ main__ _main (we follow DDD and try these too) -AC_DEFUN([AC_F77_DUMMY_MAIN], -[AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl -m4_define([_AC_LANG_PROGRAM_C_F77_HOOKS], -[#ifdef F77_DUMMY_MAIN -# ifdef __cplusplus - extern "C" -# endif - int F77_DUMMY_MAIN() { return 1; } -#endif -]) -AC_CACHE_CHECK([for dummy main to link with Fortran 77 libraries], - ac_cv_f77_dummy_main, -[AC_LANG_PUSH(C)dnl - ac_f77_dm_save_LIBS=$LIBS - LIBS="$LIBS $FLIBS" - - # First, try linking without a dummy main: - AC_TRY_LINK([], [], - ac_cv_f77_dummy_main=none, - ac_cv_f77_dummy_main=unknown) - - if test $ac_cv_f77_dummy_main = unknown; then - for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do - AC_TRY_LINK([@%:@define F77_DUMMY_MAIN $ac_func], - [], [ac_cv_f77_dummy_main=$ac_func; break]) - done - fi - rm -f conftest* - LIBS=$ac_f77_dm_save_LIBS - AC_LANG_POP(C)dnl -]) -F77_DUMMY_MAIN=$ac_cv_f77_dummy_main -AS_IF([test "$F77_DUMMY_MAIN" != unknown], - [m4_default([$1], -[if test $F77_DUMMY_MAIN != none; then - AC_DEFINE_UNQUOTED([F77_DUMMY_MAIN], $F77_DUMMY_MAIN, - [Define to dummy `main' function (if any) required to - link to the Fortran 77 libraries.]) -fi])], - [m4_default([$2], - [AC_MSG_ERROR([Linking to Fortran libraries from C fails.])])]) -])# AC_F77_DUMMY_MAIN - - -# AC_F77_MAIN -# ----------- -# Define F77_MAIN to name of alternate main() function for use with -# the Fortran libraries. (Typically, the libraries may define their -# own main() to initialize I/O, etcetera, that then call your own -# routine called MAIN__ or whatever.) See AC_F77_DUMMY_MAIN, above. -# If no such alternate name is found, just define F77_MAIN to main. -# -AC_DEFUN([AC_F77_MAIN], -[AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl -AC_CACHE_CHECK([for alternate main to link with Fortran 77 libraries], - ac_cv_f77_main, -[AC_LANG_PUSH(C)dnl - ac_f77_m_save_LIBS=$LIBS - LIBS="$LIBS $FLIBS" - ac_cv_f77_main="main" # default entry point name - - for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do - AC_TRY_LINK([#undef F77_DUMMY_MAIN -@%:@define main $ac_func], [], [ac_cv_f77_main=$ac_func; break]) - done - rm -f conftest* - LIBS=$ac_f77_m_save_LIBS - AC_LANG_POP(C)dnl -]) -AC_DEFINE_UNQUOTED([F77_MAIN], $ac_cv_f77_main, - [Define to alternate name for `main' routine that is - called from a `main' in the Fortran libraries.]) -])# AC_F77_MAIN - - -# _AC_F77_NAME_MANGLING -# --------------------- -# Test for the name mangling scheme used by the Fortran 77 compiler. -# -# Sets ac_cv_f77_mangling. The value contains three fields, separated -# by commas: -# -# lower case / upper case: -# case translation of the Fortan 77 symbols -# underscore / no underscore: -# whether the compiler appends "_" to symbol names -# extra underscore / no extra underscore: -# whether the compiler appends an extra "_" to symbol names already -# containing at least one underscore -# -AC_DEFUN([_AC_F77_NAME_MANGLING], -[AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl -AC_REQUIRE([AC_F77_DUMMY_MAIN])dnl -AC_CACHE_CHECK([for Fortran 77 name-mangling scheme], - ac_cv_f77_mangling, -[AC_LANG_PUSH(Fortran 77)dnl -AC_COMPILE_IFELSE( -[ subroutine foobar() - return - end - subroutine foo_bar() - return - end], -[mv conftest.$ac_objext cf77_test.$ac_objext - - AC_LANG_PUSH(C)dnl - - ac_save_LIBS=$LIBS - LIBS="cf77_test.$ac_objext $LIBS $FLIBS" - - ac_success=no - for ac_foobar in foobar FOOBAR; do - for ac_underscore in "" "_"; do - ac_func="$ac_foobar$ac_underscore" - AC_TRY_LINK_FUNC($ac_func, - [ac_success=yes; break 2]) - done - done - - if test "$ac_success" = "yes"; then - case $ac_foobar in - foobar) - ac_case=lower - ac_foo_bar=foo_bar - ;; - FOOBAR) - ac_case=upper - ac_foo_bar=FOO_BAR - ;; - esac - - ac_success_extra=no - for ac_extra in "" "_"; do - ac_func="$ac_foo_bar$ac_underscore$ac_extra" - AC_TRY_LINK_FUNC($ac_func, - [ac_success_extra=yes; break]) - done - - if test "$ac_success_extra" = "yes"; then - ac_cv_f77_mangling="$ac_case case" - if test -z "$ac_underscore"; then - ac_cv_f77_mangling="$ac_cv_f77_mangling, no underscore" - else - ac_cv_f77_mangling="$ac_cv_f77_mangling, underscore" - fi - if test -z "$ac_extra"; then - ac_cv_f77_mangling="$ac_cv_f77_mangling, no extra underscore" - else - ac_cv_f77_mangling="$ac_cv_f77_mangling, extra underscore" - fi - else - ac_cv_f77_mangling="unknown" - fi - else - ac_cv_f77_mangling="unknown" - fi - - LIBS=$ac_save_LIBS - AC_LANG_POP(C)dnl - rm -f cf77_test* conftest*]) -AC_LANG_POP(Fortran 77)dnl -]) -])# _AC_F77_NAME_MANGLING - -# The replacement is empty. -AU_DEFUN([AC_F77_NAME_MANGLING], []) - - -# AC_F77_WRAPPERS -# --------------- -# Defines C macros F77_FUNC(name,NAME) and F77_FUNC_(name,NAME) to -# properly mangle the names of C identifiers, and C identifiers with -# underscores, respectively, so that they match the name mangling -# scheme used by the Fortran 77 compiler. -AC_DEFUN([AC_F77_WRAPPERS], -[AC_REQUIRE([_AC_F77_NAME_MANGLING])dnl -AH_TEMPLATE([F77_FUNC], - [Define to a macro mangling the given C identifier (in lower and upper - case), which must not contain underscores, for linking with Fortran.])dnl -AH_TEMPLATE([F77_FUNC_], - [As F77_FUNC, but for C identifiers containing underscores.])dnl -case $ac_cv_f77_mangling in - "lower case, no underscore, no extra underscore") - AC_DEFINE([F77_FUNC(name,NAME)], [name]) - AC_DEFINE([F77_FUNC_(name,NAME)], [name]) ;; - "lower case, no underscore, extra underscore") - AC_DEFINE([F77_FUNC(name,NAME)], [name]) - AC_DEFINE([F77_FUNC_(name,NAME)], [name ## _]) ;; - "lower case, underscore, no extra underscore") - AC_DEFINE([F77_FUNC(name,NAME)], [name ## _]) - AC_DEFINE([F77_FUNC_(name,NAME)], [name ## _]) ;; - "lower case, underscore, extra underscore") - AC_DEFINE([F77_FUNC(name,NAME)], [name ## _]) - AC_DEFINE([F77_FUNC_(name,NAME)], [name ## __]) ;; - "upper case, no underscore, no extra underscore") - AC_DEFINE([F77_FUNC(name,NAME)], [NAME]) - AC_DEFINE([F77_FUNC_(name,NAME)], [NAME]) ;; - "upper case, no underscore, extra underscore") - AC_DEFINE([F77_FUNC(name,NAME)], [NAME]) - AC_DEFINE([F77_FUNC_(name,NAME)], [NAME ## _]) ;; - "upper case, underscore, no extra underscore") - AC_DEFINE([F77_FUNC(name,NAME)], [NAME ## _]) - AC_DEFINE([F77_FUNC_(name,NAME)], [NAME ## _]) ;; - "upper case, underscore, extra underscore") - AC_DEFINE([F77_FUNC(name,NAME)], [NAME ## _]) - AC_DEFINE([F77_FUNC_(name,NAME)], [NAME ## __]) ;; - *) - AC_MSG_WARN([unknown Fortran 77 name-mangling scheme]) - ;; -esac -])# AC_F77_WRAPPERS - - -# AC_F77_FUNC(NAME, [SHELLVAR = NAME]) -# ------------------------------------ -# For a Fortran subroutine of given NAME, define a shell variable -# $SHELLVAR to the Fortran-77 mangled name. If the SHELLVAR -# argument is not supplied, it defaults to NAME. -AC_DEFUN([AC_F77_FUNC], -[AC_REQUIRE([_AC_F77_NAME_MANGLING])dnl -case $ac_cv_f77_mangling in - upper*) ac_val="m4_toupper([$1])" ;; - lower*) ac_val="m4_tolower([$1])" ;; - *) ac_val="unknown" ;; -esac -case $ac_cv_f77_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac -m4_if(m4_index([$1],[_]),-1,[], -[case $ac_cv_f77_mangling in *," extra underscore"*) ac_val="$ac_val"_ ;; esac -]) -m4_default([$2],[$1])="$ac_val" -])# AC_F77_FUNC diff --git a/tests/Makefile.am b/tests/Makefile.am index aee773621..91fa0fb9c 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -22,9 +22,11 @@ AUTOMAKE_OPTIONS = gnits SUITE = suite.at \ m4sugar.at m4sh.at \ - base.at tools.at torture.at compile.at semantics.at \ - acgeneral.at acspecific.at acfunctions.at aclang.at acheaders.at \ - actypes.at \ + base.at tools.at torture.at \ + compile.at \ + aclang.at acc.at acfortran.at \ + semantics.at \ + acgeneral.at acspecific.at acfunctions.at acheaders.at actypes.at \ foreign.at # We don't actually distribute the testsuite, since one only @@ -56,6 +58,8 @@ MACRO_FILES = $(top_srcdir)/lib/autoconf/general.m4 \ $(top_srcdir)/lib/autoconf/specific.m4 \ $(top_srcdir)/lib/autoconf/functions.m4 \ $(top_srcdir)/lib/autoconf/lang.m4 \ + $(top_srcdir)/lib/autoconf/c.m4 \ + $(top_srcdir)/lib/autoconf/fortran.m4 \ $(top_srcdir)/lib/autoconf/headers.m4 \ $(top_srcdir)/lib/autoconf/types.m4 @@ -71,6 +75,12 @@ acfunctions.at: mktests.sh $(MACRO_FILES) aclang.at: mktests.sh $(MACRO_FILES) cd $(srcdir) && ./mktests.sh $(MACRO_FILES) +acc.at: mktests.sh $(MACRO_FILES) + cd $(srcdir) && ./mktests.sh $(MACRO_FILES) + +acfortran.at: mktests.sh $(MACRO_FILES) + cd $(srcdir) && ./mktests.sh $(MACRO_FILES) + acheaders.at: mktests.sh $(MACRO_FILES) cd $(srcdir) && ./mktests.sh $(MACRO_FILES) diff --git a/tests/Makefile.in b/tests/Makefile.in index 2a9fd0702..50481d137 100644 --- a/tests/Makefile.in +++ b/tests/Makefile.in @@ -68,7 +68,7 @@ VERSION = @VERSION@ AUTOMAKE_OPTIONS = gnits -SUITE = suite.at m4sugar.at m4sh.at base.at tools.at torture.at compile.at semantics.at acgeneral.at acspecific.at acfunctions.at aclang.at acheaders.at actypes.at foreign.at +SUITE = suite.at m4sugar.at m4sh.at base.at tools.at torture.at compile.at aclang.at acc.at acfortran.at semantics.at acgeneral.at acspecific.at acfunctions.at acheaders.at actypes.at foreign.at # We don't actually distribute the testsuite, since one only @@ -81,7 +81,7 @@ AUTOM4TE = autom4te_perllibdir='$(top_srcdir)/lib' ../autom4te # The files which contains macro we check for syntax. Don't use $(top_srcdir) # here since below we explicitly `cd' to $srcdir. As for the dependencies, # thanks God for VPATH. Hm... -MACRO_FILES = $(top_srcdir)/lib/autoconf/general.m4 $(top_srcdir)/lib/autoconf/specific.m4 $(top_srcdir)/lib/autoconf/functions.m4 $(top_srcdir)/lib/autoconf/lang.m4 $(top_srcdir)/lib/autoconf/headers.m4 $(top_srcdir)/lib/autoconf/types.m4 +MACRO_FILES = $(top_srcdir)/lib/autoconf/general.m4 $(top_srcdir)/lib/autoconf/specific.m4 $(top_srcdir)/lib/autoconf/functions.m4 $(top_srcdir)/lib/autoconf/lang.m4 $(top_srcdir)/lib/autoconf/c.m4 $(top_srcdir)/lib/autoconf/fortran.m4 $(top_srcdir)/lib/autoconf/headers.m4 $(top_srcdir)/lib/autoconf/types.m4 CLEANFILES = debug-*.sh macro configure configure.in configure.ac config.status config.cache config.log config.h.in config.h config.hin state-* at-* stderr stdout empty config.guess config.sub expr libtool ltconfig ltmain.sh install-sh @@ -89,7 +89,8 @@ CLEANFILES = debug-*.sh macro configure configure.in configure.ac c DISTCLEANFILES = atconfig testsuite mkinstalldirs = $(SHELL) $(top_srcdir)/config/mkinstalldirs CONFIG_CLEAN_FILES = atconfig -DIST_COMMON = README Makefile.am Makefile.in atconfig.in +DIST_COMMON = README Makefile.am Makefile.in atconfig.in configure \ +configure.ac DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST) @@ -220,6 +221,12 @@ acfunctions.at: mktests.sh $(MACRO_FILES) aclang.at: mktests.sh $(MACRO_FILES) cd $(srcdir) && ./mktests.sh $(MACRO_FILES) +acc.at: mktests.sh $(MACRO_FILES) + cd $(srcdir) && ./mktests.sh $(MACRO_FILES) + +acfortran.at: mktests.sh $(MACRO_FILES) + cd $(srcdir) && ./mktests.sh $(MACRO_FILES) + acheaders.at: mktests.sh $(MACRO_FILES) cd $(srcdir) && ./mktests.sh $(MACRO_FILES) diff --git a/tests/acc.at b/tests/acc.at new file mode 100644 index 000000000..0a1a67fc9 --- /dev/null +++ b/tests/acc.at @@ -0,0 +1,17 @@ +# Generated by mktests.sh, do not edit by hand. -*- Autoconf -*- + +AT_BANNER([Testing autoconf/c macros.]) + +# Modern macros. +AT_CHECK_MACRO([AC_C_BIGENDIAN]) +AT_CHECK_MACRO([AC_C_CHAR_UNSIGNED]) +AT_CHECK_MACRO([AC_C_LONG_DOUBLE]) +AT_CHECK_MACRO([AC_C_PROTOTYPES]) +AT_CHECK_MACRO([AC_C_STRINGIZE]) +AT_CHECK_MACRO([AC_PROG_CC_C_O]) +AT_CHECK_MACRO([AC_PROG_GCC_TRADITIONAL]) + +# Obsolete macros. +AT_CHECK_AU_MACRO([AC_C_CROSS]) +AT_CHECK_AU_MACRO([AC_LANG_C]) +AT_CHECK_AU_MACRO([AC_LANG_CPLUSPLUS]) diff --git a/tests/acfortran.at b/tests/acfortran.at new file mode 100644 index 000000000..a05605202 --- /dev/null +++ b/tests/acfortran.at @@ -0,0 +1,11 @@ +# Generated by mktests.sh, do not edit by hand. -*- Autoconf -*- + +AT_BANNER([Testing autoconf/fortran macros.]) + +# Modern macros. +AT_CHECK_MACRO([AC_F77_MAIN]) +AT_CHECK_MACRO([AC_F77_WRAPPERS]) +AT_CHECK_MACRO([AC_PROG_F77_C_O]) + +# Obsolete macros. +AT_CHECK_AU_MACRO([AC_LANG_FORTRAN77]) diff --git a/tests/aclang.at b/tests/aclang.at index d0a7dc0dc..a9612d530 100644 --- a/tests/aclang.at +++ b/tests/aclang.at @@ -3,22 +3,8 @@ AT_BANNER([Testing autoconf/lang macros.]) # Modern macros. -AT_CHECK_MACRO([AC_C_BIGENDIAN]) -AT_CHECK_MACRO([AC_C_CHAR_UNSIGNED]) -AT_CHECK_MACRO([AC_C_LONG_DOUBLE]) -AT_CHECK_MACRO([AC_C_PROTOTYPES]) -AT_CHECK_MACRO([AC_C_STRINGIZE]) -AT_CHECK_MACRO([AC_F77_MAIN]) -AT_CHECK_MACRO([AC_F77_WRAPPERS]) AT_CHECK_MACRO([AC_NO_EXECUTABLES]) -AT_CHECK_MACRO([AC_PROG_CC_C_O]) -AT_CHECK_MACRO([AC_PROG_F77_C_O]) -AT_CHECK_MACRO([AC_PROG_GCC_TRADITIONAL]) AT_CHECK_MACRO([AC_REQUIRE_CPP]) # Obsolete macros. -AT_CHECK_AU_MACRO([AC_C_CROSS]) -AT_CHECK_AU_MACRO([AC_LANG_C]) -AT_CHECK_AU_MACRO([AC_LANG_CPLUSPLUS]) -AT_CHECK_AU_MACRO([AC_LANG_FORTRAN77]) AT_CHECK_AU_MACRO([AC_LANG_SAVE]) diff --git a/tests/suite.at b/tests/suite.at index 495c91398..0d1c58750 100644 --- a/tests/suite.at +++ b/tests/suite.at @@ -38,6 +38,11 @@ m4_include([torture.at]) # Checking AC_PROG_CC, AC_COMPILE_IFELSE etc. m4_include([compile.at]) +# Language support. +m4_include([aclang.at]) +m4_include([acc.at]) +m4_include([acfortran.at]) + # Checking that AC_CHECK_FOO macros work properly. m4_include([semantics.at]) @@ -46,7 +51,6 @@ m4_include([semantics.at]) # for types requires looking for headers etc. m4_include([acgeneral.at]) m4_include([acspecific.at]) -m4_include([aclang.at]) m4_include([acheaders.at]) m4_include([actypes.at]) m4_include([acfunctions.at])