| blob | 296c55a0396f560f619d7852d8b69e529ac25bb8 |
1 # This file is part of Autoconf. -*- Autoconf -*-
2 # Fortran languages support.
3 # Copyright (C) 2001, 2003-2017, 2020-2024 Free Software Foundation,
4 # Inc.
6 # This file is part of Autoconf. This program is free
7 # software; you can redistribute it and/or modify it under the
8 # terms of the GNU General Public License as published by the
9 # Free Software Foundation, either version 3 of the License, or
10 # (at your option) any later version.
11 #
12 # This program is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 # GNU General Public License for more details.
16 #
17 # Under Section 7 of GPL version 3, you are granted additional
18 # permissions described in the Autoconf Configure Script Exception,
19 # version 3.0, as published by the Free Software Foundation.
20 #
21 # You should have received a copy of the GNU General Public License
22 # and a copy of the Autoconf Configure Script Exception along with
23 # this program; see the files COPYINGv3 and COPYING.EXCEPTION
24 # respectively. If not, see <https://www.gnu.org/licenses/> and
25 # <https://git.savannah.gnu.org/gitweb/?p=autoconf.git;a=blob_plain;f=COPYING.EXCEPTION>.
27 # Written by David MacKenzie, with help from
28 # François Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor,
29 # Roland McGrath, Noah Friedman, david d zuhn, and many others.
32 # Table of Contents:
33 #
34 # Preamble
35 #
36 # 0. Utility macros
37 #
38 # 1. Language selection
39 # and routines to produce programs in a given language.
40 #
41 # 2. Producing programs in a given language.
42 #
43 # 3. Looking for a compiler
44 # And possibly the associated preprocessor.
45 #
46 # 4. Compilers' characteristics.
50 ## ---------- ##
51 ## Preamble. ##
52 ## ---------- ##
54 # Fortran vs. Fortran 77:
55 # This file contains macros for both "Fortran 77" and "Fortran", where
56 # the former is the "classic" autoconf Fortran interface and is intended
57 # for legacy F77 codes, while the latter is intended to support newer Fortran
58 # dialects. Fortran 77 uses environment variables F77, FFLAGS, and FLIBS,
59 # while Fortran uses FC, FCFLAGS, and FCLIBS. For each user-callable AC_*
60 # macro, there is generally both an F77 and an FC version, where both versions
61 # share the same _AC_*_FC_* backend. This backend macro requires that
62 # the appropriate language be AC_LANG_PUSH'ed, and uses _AC_LANG_ABBREV and
63 # _AC_LANG_PREFIX in order to name cache and environment variables, etc.
67 ## ------------------- ##
68 ## 0. Utility macros. ##
69 ## ------------------- ##
72 # _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
73 # ---------------------------------------------------------------------------
74 #
75 # Processing the elements of a list is tedious in shell programming,
76 # as lists tend to be implemented as space delimited strings.
77 #
78 # This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
79 # if ELEMENT is a member of LIST, otherwise it executes
80 # ACTION-IF-NOT-FOUND.
81 AC_DEFUN([_AC_LIST_MEMBER_IF],
82 dnl Do some sanity checking of the arguments.
83 [m4_if([$1], , [m4_fatal([$0: missing argument 1])],
84 [$2], , [m4_fatal([$0: missing argument 2])])]dnl
85 [ ac_exists=false
86 for ac_i in $2; do
87 if test x"$1" = x"$ac_i"; then
88 ac_exists=true
89 break
90 fi
91 done
93 AS_IF([test x"$ac_exists" = xtrue], [$3], [$4])[]dnl
94 ])# _AC_LIST_MEMBER_IF
97 # _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
98 # -------------------------------------------------
99 #
100 # Specifying options to the compiler (whether it be the C, C++ or
101 # Fortran 77 compiler) that are meant for the linker is compiler
102 # dependent. This macro lets you give options to the compiler that
103 # are meant for the linker in a portable, compiler-independent way.
104 #
105 # This macro take two arguments, a list of linker options that the
106 # compiler should pass to the linker (LINKER-OPTIONS) and the name of
107 # a shell variable (SHELL-VARIABLE). The list of linker options are
108 # appended to the shell variable in a compiler-dependent way.
109 #
110 # For example, if the selected language is C, then this:
111 #
112 # _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
113 #
114 # will expand into this if the selected C compiler is gcc:
115 #
116 # foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
117 #
118 # otherwise, it will expand into this:
119 #
120 # foo_LDFLAGS"-R /usr/local/lib/foo"
121 #
122 # You are encouraged to add support for compilers that this macro
123 # doesn't currently support.
124 # FIXME: Get rid of this macro.
125 AC_DEFUN([_AC_LINKER_OPTION],
126 [if test "$ac_compiler_gnu" = yes; then
127 for ac_link_opt in $1; do
128 $2="[$]$2 -Xlinker $ac_link_opt"
129 done
130 else
131 $2="[$]$2 $1"
132 fi[]dnl
133 ])# _AC_LINKER_OPTION
137 ## ------------------------ ##
138 ## 1a. Language selection. ##
139 ## ------------------------ ##
142 # AC_LANG(Fortran 77)
143 # -------------------
144 AC_LANG_DEFINE([Fortran 77], [f77], [F], [F77], [],
145 [ac_ext=f
146 ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD'
147 ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD'
148 ac_compiler_gnu=$ac_cv_f77_compiler_gnu
149 ])
152 # AC_LANG_FORTRAN77
153 # -----------------
154 AU_DEFUN([AC_LANG_FORTRAN77], [AC_LANG(Fortran 77)])
157 # _AC_FORTRAN_ASSERT
158 # ------------------
159 # Current language must be Fortran or Fortran 77.
160 m4_defun([_AC_FORTRAN_ASSERT],
161 [m4_if(_AC_LANG, [Fortran], [],
162 [m4_if(_AC_LANG, [Fortran 77], [],
163 [m4_fatal([$0: current language is not Fortran: ] _AC_LANG)])])])
166 # _AC_FC
167 # ------
168 # Return F77 or FC, depending upon the language.
169 AC_DEFUN([_AC_FC],
170 [_AC_FORTRAN_ASSERT()dnl
171 AC_LANG_CASE([Fortran 77], [F77],
172 [Fortran], [FC])])
176 ## ----------------------- ##
177 ## 2. Producing programs. ##
178 ## ----------------------- ##
181 # AC_LANG_PROGRAM(Fortran 77)([PROLOGUE], [BODY])
182 # -----------------------------------------------
183 # Yes, we discard the PROLOGUE.
184 m4_define([AC_LANG_PROGRAM(Fortran 77)],
185 [m4_ifval([$1],
186 [m4_warn([syntax], [$0: ignoring PROLOGUE: $1])])dnl
187 program main
188 $2
189 end])
192 # _AC_LANG_IO_PROGRAM(Fortran 77)
193 # -------------------------------
194 # Produce source that performs I/O.
195 m4_define([_AC_LANG_IO_PROGRAM(Fortran 77)],
196 [AC_LANG_PROGRAM([],
197 [dnl
198 open(unit=9,file='conftest.out')
199 close(unit=9)
200 ])])
203 # AC_LANG_CALL(Fortran 77)(PROLOGUE, FUNCTION)
204 # --------------------------------------------
205 # FIXME: This is a guess, help!
206 m4_define([AC_LANG_CALL(Fortran 77)],
207 [AC_LANG_PROGRAM([$1],
208 [ call $2])])
211 # AC_LANG_FUNC_LINK_TRY(Fortran 77)(FUNCTION)
212 # -------------------------------------------
213 m4_define([AC_LANG_FUNC_LINK_TRY(Fortran 77)],
214 [AC_LANG_PROGRAM([],
215 [ call $1])])
217 ## ------------------------ ##
218 ## 1b. Language selection. ##
219 ## ------------------------ ##
222 # AC_LANG(Fortran)
223 # ----------------
224 AC_LANG_DEFINE([Fortran], [fc], [FC], [FC], [Fortran 77],
225 [ac_ext=${ac_fc_srcext-f}
226 ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&AS_MESSAGE_LOG_FD'
227 ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD'
228 ac_compiler_gnu=$ac_cv_fc_compiler_gnu
229 ])
232 ## -------------------------------------------- ##
233 ## 3. Looking for Compilers and Preprocessors. ##
234 ## -------------------------------------------- ##
237 # AC_LANG_PREPROC(Fortran 77)
238 # ---------------------------
239 # Find the Fortran 77 preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able.
240 AC_DEFUN([AC_LANG_PREPROC(Fortran 77)],
241 [m4_warn([syntax],
242 [$0: No preprocessor defined for ]_AC_LANG)])
244 # AC_LANG_PREPROC(Fortran)
245 # ------------------------
246 # Find the Fortran preprocessor. Must be AC_DEFUN'd to be AC_REQUIRE'able.
247 AC_DEFUN([AC_LANG_PREPROC(Fortran)],
248 [m4_warn([syntax],
249 [$0: No preprocessor defined for ]_AC_LANG)])
252 # AC_LANG_COMPILER(Fortran 77)
253 # ----------------------------
254 # Find the Fortran 77 compiler. Must be AC_DEFUN'd to be
255 # AC_REQUIRE'able.
256 AC_DEFUN([AC_LANG_COMPILER(Fortran 77)],
257 [AC_REQUIRE([AC_PROG_F77])])
259 # AC_LANG_COMPILER(Fortran)
260 # -------------------------
261 # Find the Fortran compiler. Must be AC_DEFUN'd to be
262 # AC_REQUIRE'able.
263 AC_DEFUN([AC_LANG_COMPILER(Fortran)],
264 [AC_REQUIRE([AC_PROG_FC])])
267 # ac_cv_prog_g77
268 # --------------
269 # We used to name the cache variable this way.
270 AU_DEFUN([ac_cv_prog_g77],
271 [ac_cv_f77_compiler_gnu])
274 # _AC_FC_DIALECT_YEAR([DIALECT])
275 # ------------------------------
276 # Given a Fortran DIALECT, which is Fortran [YY]YY or simply [YY]YY,
277 # convert to a 4-digit year. The dialect must be one of Fortran 77,
278 # 90, 95, or 2000, currently. If DIALECT is simply Fortran or the
279 # empty string, returns the empty string.
280 AC_DEFUN([_AC_FC_DIALECT_YEAR],
281 [m4_case(m4_bpatsubsts(m4_tolower([$1]), [fortran],[], [ *],[]),
282 [77],[1977], [1977],[1977],
283 [90],[1990], [1990],[1990],
284 [95],[1995], [1995],[1995],
285 [2000],[2000],
286 [],[],
287 [m4_fatal([unknown Fortran dialect])])])
290 # _AC_PROG_FC([DIALECT], [COMPILERS...])
291 # --------------------------------------
292 # DIALECT is a Fortran dialect, given by Fortran [YY]YY or simply [YY]YY,
293 # and must be one of those supported by _AC_FC_DIALECT_YEAR
294 #
295 # If DIALECT is supplied, then we search for compilers of that dialect
296 # first, and then later dialects. Otherwise, we search for compilers
297 # of the newest dialect first, and then earlier dialects in increasing age.
298 # This search order is necessarily imperfect because the dialect cannot
299 # always be inferred from the compiler name.
300 #
301 # Known compilers:
302 # f77/f90/f95: generic compiler names
303 # g77: GNU Fortran 77 compiler
304 # gfortran: GNU Fortran 95+ compiler (released in gcc 4.0)
305 # g95: original gcc-based f95 compiler (gfortran is a fork)
306 # ftn: native Fortran 95 compiler on Cray X1
307 # cf77: native F77 compiler under older Crays (prefer over fort77)
308 # fort77: native F77 compiler under HP-UX (and some older Crays)
309 # frt: Fujitsu F77 compiler
310 # pgf77/pgf90/pghpf/pgf95/pgfortran: Portland Group F77/F90/F95 compilers
311 # xlf/xlf90/xlf95: IBM (AIX) F77/F90/F95 compilers
312 # Prefer xlf9x to the generic names because they do not reject files
313 # with extension '.f'.
314 # lf95: Lahey-Fujitsu F95 compiler
315 # fl32: Microsoft Fortran 77 "PowerStation" compiler
316 # af77: Apogee F77 compiler for Intergraph hardware running CLIX
317 # epcf90: "Edinburgh Portable Compiler" F90
318 # fort: Compaq (now HP) Fortran 90/95 compiler for Tru64 and Linux/Alpha
319 # ifort, previously ifc: Intel Fortran 95 compiler for Linux/x86
320 # efc: Intel Fortran 95 compiler for IA64
321 # nagfor: NAGWare Fortran 77/90/95 compiler
322 m4_define([_AC_F95_FC], [gfortran g95 xlf95 f95 fort ifort ifc efc pgfortran pgf95 lf95 ftn nagfor])
323 m4_define([_AC_F90_FC], [xlf90 f90 pgf90 pghpf epcf90])
324 m4_define([_AC_F77_FC], [g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77])
325 AC_DEFUN([_AC_PROG_FC],
326 [_AC_FORTRAN_ASSERT()dnl
327 AC_CHECK_TOOLS([]_AC_FC[],
328 m4_default([$2],
329 m4_case(_AC_FC_DIALECT_YEAR([$1]),
330 [1995], [_AC_F95_FC],
331 [1990], [_AC_F90_FC _AC_F95_FC],
332 [1977], [_AC_F77_FC _AC_F90_FC _AC_F95_FC],
333 [_AC_F95_FC _AC_F90_FC _AC_F77_FC])))
335 # Provide some information about the compiler.
336 _AS_ECHO_LOG([checking for _AC_LANG compiler version])
337 set X $ac_compile
338 ac_compiler=$[2]
339 for ac_option in --version -v -V -qversion; do
340 _AC_DO_LIMIT([$ac_compiler $ac_option >&AS_MESSAGE_LOG_FD])
341 done
342 rm -f a.out
344 m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
345 m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
346 # If we don't use '.F' as extension, the preprocessor is not run on the
347 # input file. (Note that this only needs to work for GNU compilers.)
348 ac_save_ext=$ac_ext
349 ac_ext=F
350 _AC_LANG_COMPILER_GNU
351 ac_ext=$ac_save_ext
352 _AC_PROG_FC_G
353 ])# _AC_PROG_FC
356 # AC_PROG_F77([COMPILERS...])
357 # ---------------------------
358 # COMPILERS is a space separated list of Fortran 77 compilers to search
359 # for. See also _AC_PROG_FC.
360 AC_DEFUN([AC_PROG_F77],
361 [AC_LANG_PUSH(Fortran 77)dnl
362 AC_ARG_VAR([F77], [Fortran 77 compiler command])dnl
363 AC_ARG_VAR([FFLAGS], [Fortran 77 compiler flags])dnl
364 _AC_ARG_VAR_LDFLAGS()dnl
365 _AC_ARG_VAR_LIBS()dnl
366 _AC_PROG_FC([Fortran 77], [$1])
367 if test $ac_compiler_gnu = yes; then
368 G77=yes
369 else
370 G77=
371 fi
372 AC_LANG_POP(Fortran 77)dnl
373 ])# AC_PROG_F77
376 # AC_PROG_FC([COMPILERS...], [DIALECT])
377 # -------------------------------------
378 # COMPILERS is a space separated list of Fortran 77 compilers to search
379 # for, and [DIALECT] is an optional dialect. See also _AC_PROG_FC.
380 AC_DEFUN([AC_PROG_FC],
381 [AC_LANG_PUSH(Fortran)dnl
382 AC_ARG_VAR([FC], [Fortran compiler command])dnl
383 AC_ARG_VAR([FCFLAGS], [Fortran compiler flags])dnl
384 _AC_ARG_VAR_LDFLAGS()dnl
385 _AC_ARG_VAR_LIBS()dnl
386 _AC_PROG_FC([$2], [$1])
387 if test $ac_compiler_gnu = yes; then
388 GFC=yes
389 else
390 GFC=
391 fi
392 AC_LANG_POP(Fortran)dnl
393 ])# AC_PROG_FC
396 # _AC_PROG_FC_G
397 # -------------
398 # Check whether -g works, even if F[C]FLAGS is set, in case the package
399 # plays around with F[C]FLAGS (such as to build both debugging and normal
400 # versions of a library), tasteless as that idea is.
401 m4_define([_AC_PROG_FC_G],
402 [_AC_FORTRAN_ASSERT()dnl
403 ac_test_[]_AC_LANG_PREFIX[]FLAGS=${[]_AC_LANG_PREFIX[]FLAGS+y}
404 ac_save_[]_AC_LANG_PREFIX[]FLAGS=$[]_AC_LANG_PREFIX[]FLAGS
405 _AC_LANG_PREFIX[]FLAGS=
406 AC_CACHE_CHECK(whether $[]_AC_FC[] accepts -g, ac_cv_prog_[]_AC_LANG_ABBREV[]_g,
407 [_AC_LANG_PREFIX[]FLAGS=-g
408 _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
409 [ac_cv_prog_[]_AC_LANG_ABBREV[]_g=yes],
410 [ac_cv_prog_[]_AC_LANG_ABBREV[]_g=no])
411 ])
412 if test $ac_test_[]_AC_LANG_PREFIX[]FLAGS; then
413 _AC_LANG_PREFIX[]FLAGS=$ac_save_[]_AC_LANG_PREFIX[]FLAGS
414 elif test $ac_cv_prog_[]_AC_LANG_ABBREV[]_g = yes; then
415 if test "x$ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu" = xyes; then
416 _AC_LANG_PREFIX[]FLAGS="-g -O2"
417 else
418 _AC_LANG_PREFIX[]FLAGS="-g"
419 fi
420 else
421 if test "x$ac_cv_[]_AC_LANG_ABBREV[]_compiler_gnu" = xyes; then
422 _AC_LANG_PREFIX[]FLAGS="-O2"
423 else
424 _AC_LANG_PREFIX[]FLAGS=
425 fi
426 fi[]dnl
427 ])# _AC_PROG_FC_G
430 # _AC_PROG_FC_C_O
431 # ---------------
432 # Test if the Fortran compiler accepts the options '-c' and '-o'
433 # simultaneously, and define '[F77/FC]_NO_MINUS_C_MINUS_O' if it does not.
434 #
435 # The usefulness of this macro is questionable, as I can't really see
436 # why anyone would use it. The only reason I include it is for
437 # completeness, since a similar test exists for the C compiler.
438 #
439 # FIXME: it seems like we could merge the C/C++/Fortran versions of this.
440 AC_DEFUN([_AC_PROG_FC_C_O],
441 [_AC_FORTRAN_ASSERT()dnl
442 AC_CACHE_CHECK([whether $[]_AC_FC[] understands -c and -o together],
443 [ac_cv_prog_[]_AC_LANG_ABBREV[]_c_o],
444 [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
445 # We test twice because some compilers refuse to overwrite an existing
446 # '.o' file with '-o', although they will create one.
447 ac_try='$[]_AC_FC[] $[]_AC_LANG_PREFIX[]FLAGS -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD'
448 rm -f conftest2.*
449 if _AC_DO_VAR(ac_try) &&
450 test -f conftest2.$ac_objext &&
451 _AC_DO_VAR(ac_try); then
452 ac_cv_prog_[]_AC_LANG_ABBREV[]_c_o=yes
453 else
454 ac_cv_prog_[]_AC_LANG_ABBREV[]_c_o=no
455 fi
456 rm -rf conftest*])
457 if test $ac_cv_prog_[]_AC_LANG_ABBREV[]_c_o = no; then
458 AC_DEFINE([]_AC_FC[]_NO_MINUS_C_MINUS_O, 1,
459 [Define to 1 if your Fortran compiler doesn't accept
460 -c and -o together.])
461 fi
462 ])# _AC_PROG_FC_C_O
465 # AC_PROG_F77_C_O
466 # ---------------
467 AC_DEFUN([AC_PROG_F77_C_O],
468 [AC_REQUIRE([AC_PROG_F77])dnl
469 AC_LANG_PUSH(Fortran 77)dnl
470 _AC_PROG_FC_C_O
471 AC_LANG_POP(Fortran 77)dnl
472 ])# AC_PROG_F77_C_O
475 # AC_PROG_FC_C_O
476 # --------------
477 AC_DEFUN([AC_PROG_FC_C_O],
478 [AC_REQUIRE([AC_PROG_FC])dnl
479 AC_LANG_PUSH(Fortran)dnl
480 _AC_PROG_FC_C_O
481 AC_LANG_POP(Fortran)dnl
482 ])# AC_PROG_FC_C_O
486 ## ------------------------------- ##
487 ## 4. Compilers' characteristics. ##
488 ## ------------------------------- ##
491 # _AC_PROG_FC_V_OUTPUT([FLAG = $ac_cv_prog_{f77/fc}_v])
492 # -----------------------------------------------------
493 # Link a trivial Fortran program, compiling with a verbose output FLAG
494 # (whose default value, $ac_cv_prog_{f77/fc}_v, is computed by
495 # _AC_PROG_FC_V), and return the output in $ac_{f77/fc}_v_output. This
496 # output is processed in the way expected by _AC_FC_LIBRARY_LDFLAGS,
497 # so that any link flags that are echoed by the compiler appear as
498 # space-separated items.
499 AC_DEFUN([_AC_PROG_FC_V_OUTPUT],
500 [_AC_FORTRAN_ASSERT()dnl
501 AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
503 # Compile and link our simple test program by passing a flag (argument
504 # 1 to this macro) to the Fortran compiler in order to get
505 # "verbose" output that we can then parse for the Fortran linker
506 # flags.
507 ac_save_[]_AC_LANG_PREFIX[]FLAGS=$[]_AC_LANG_PREFIX[]FLAGS
508 _AC_LANG_PREFIX[]FLAGS="$[]_AC_LANG_PREFIX[]FLAGS m4_default([$1], [$ac_cv_prog_[]_AC_LANG_ABBREV[]_v])"
509 eval "set x $ac_link"
510 shift
511 _AS_ECHO_LOG([$[*]])
512 # gfortran 4.3 outputs lines setting COLLECT_GCC_OPTIONS, COMPILER_PATH,
513 # LIBRARY_PATH; skip all such settings.
514 ac_[]_AC_LANG_ABBREV[]_v_output=`eval $ac_link AS_MESSAGE_LOG_FD>&1 2>&1 |
515 sed '/^Driving:/d; /^Configured with:/d;
516 '"/^[[_$as_cr_Letters]][[_$as_cr_alnum]]*=/d"`
517 AS_ECHO(["$ac_[]_AC_LANG_ABBREV[]_v_output"]) >&AS_MESSAGE_LOG_FD
518 _AC_LANG_PREFIX[]FLAGS=$ac_save_[]_AC_LANG_PREFIX[]FLAGS
520 rm -rf conftest*
522 # On HP-UX there is a line like: "LPATH is: /foo:/bar:/baz" where
523 # /foo, /bar, and /baz are search directories for the Fortran linker.
524 # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
525 ac_[]_AC_LANG_ABBREV[]_v_output=`AS_ECHO(["$ac_[]_AC_LANG_ABBREV[]_v_output"])|
526 grep 'LPATH is:' |
527 sed 's|.*LPATH is\(: *[[^ ]]*\).*|\1|;s|: */| -L/|g'`" $ac_[]_AC_LANG_ABBREV[]_v_output"
529 # FIXME: we keep getting bitten by quoted arguments; a more general fix
530 # that detects unbalanced quotes in FLIBS should be implemented
531 # and (ugh) tested at some point.
532 case $ac_[]_AC_LANG_ABBREV[]_v_output in
533 # With xlf replace commas with spaces,
534 # and remove "-link" and closing parenthesis.
535 *xlfentry*)
536 ac_[]_AC_LANG_ABBREV[]_v_output=`AS_ECHO(["$ac_[]_AC_LANG_ABBREV[]_v_output"]) |
537 sed '
538 s/,/ /g
539 s/ -link / /g
540 s/) *$//
541 '
542 ` ;;
544 # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
545 # $LIBS confuse us, and the libraries appear later in the output anyway).
546 *mGLOB_options_string*)
547 ac_[]_AC_LANG_ABBREV[]_v_output=`AS_ECHO(["$ac_[]_AC_LANG_ABBREV[]_v_output"]) | sed 's/"-mGLOB[[^"]]*"/ /g'` ;;
549 # Portland Group compiler has singly- or doubly-quoted -cmdline argument
550 # Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4.
551 # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
552 *-cmdline\ * | *-ignore\ * | *-def\ *)
553 ac_[]_AC_LANG_ABBREV[]_v_output=`AS_ECHO([$ac_[]_AC_LANG_ABBREV[]_v_output]) | sed "\
554 s/-cmdline *'[[^']]*'/ /g; s/-cmdline *\"[[^\"]]*\"/ /g
555 s/-ignore *'[[^']]*'/ /g; s/-ignore *\"[[^\"]]*\"/ /g
556 s/-def *'[[^']]*'/ /g; s/-def *\"[[^\"]]*\"/ /g"` ;;
558 # If we are using fort77 (the f2c wrapper) then filter output and delete quotes.
559 *fort77*f2c*gcc*)
560 ac_[]_AC_LANG_ABBREV[]_v_output=`AS_ECHO(["$ac_[]_AC_LANG_ABBREV[]_v_output"]) | sed -n '
561 /:[[ ]]\+Running[[ ]]\{1,\}"gcc"/{
562 /"-c"/d
563 /[[.]]c"*/d
564 s/^.*"gcc"/"gcc"/
565 s/"//gp
566 }'` ;;
568 # If we are using Cray Fortran then delete quotes.
569 *cft90*)
570 ac_[]_AC_LANG_ABBREV[]_v_output=`AS_ECHO("$ac_[]_AC_LANG_ABBREV[]_v_output") | sed 's/"//g'` ;;
571 esac
573 ])# _AC_PROG_FC_V_OUTPUT
576 # _AC_PROG_FC_V
577 # -------------
578 #
579 # Determine the flag that causes the Fortran compiler to print
580 # information of library and object files (normally -v)
581 # Needed for _AC_FC_LIBRARY_FLAGS
582 # Some compilers don't accept -v (Lahey: (-)-verbose, xlf: -V, Fujitsu: -###)
583 AC_DEFUN([_AC_PROG_FC_V],
584 [_AC_FORTRAN_ASSERT()dnl
585 AC_CACHE_CHECK([how to get verbose linking output from $[]_AC_FC[]],
586 [ac_cv_prog_[]_AC_LANG_ABBREV[]_v],
587 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
588 [ac_cv_prog_[]_AC_LANG_ABBREV[]_v=
589 # Try some options frequently used verbose output
590 for ac_verb in -v -verbose --verbose -V -\#\#\#; do
591 _AC_PROG_FC_V_OUTPUT($ac_verb)
592 # look for -l* and *.a constructs in the output
593 for ac_arg in $ac_[]_AC_LANG_ABBREV[]_v_output; do
594 case $ac_arg in
595 [[\\/]]*.a | ?:[[\\/]]*.a | -[[lLRu]]*)
596 ac_cv_prog_[]_AC_LANG_ABBREV[]_v=$ac_verb
597 break 2 ;;
598 esac
599 done
600 done
601 if test -z "$ac_cv_prog_[]_AC_LANG_ABBREV[]_v"; then
602 AC_MSG_WARN([cannot determine how to obtain linking information from $[]_AC_FC[]])
603 fi],
604 [AC_MSG_WARN([compilation failed])])
605 ])])# _AC_PROG_FC_V
608 # _AC_FC_LIBRARY_LDFLAGS
609 # ----------------------
610 #
611 # Determine the linker flags (e.g. "-L" and "-l") for the Fortran
612 # intrinsic and runtime libraries that are required to successfully
613 # link a Fortran program or shared library. The output variable
614 # FLIBS/FCLIBS is set to these flags.
615 #
616 # This macro is intended to be used in those situations when it is
617 # necessary to mix, e.g. C++ and Fortran, source code into a single
618 # program or shared library.
619 #
620 # For example, if object files from a C++ and Fortran compiler must
621 # be linked together, then the C++ compiler/linker must be used for
622 # linking (since special C++-ish things need to happen at link time
623 # like calling global constructors, instantiating templates, enabling
624 # exception support, etc.).
625 #
626 # However, the Fortran intrinsic and runtime libraries must be
627 # linked in as well, but the C++ compiler/linker doesn't know how to
628 # add these Fortran libraries. Hence, the macro
629 # "AC_F77_LIBRARY_LDFLAGS" was created to determine these Fortran
630 # libraries.
631 #
632 # This macro was packaged in its current form by Matthew D. Langston.
633 # However, nearly all of this macro came from the "OCTAVE_FLIBS" macro
634 # in "octave-2.0.13/aclocal.m4", and full credit should go to John
635 # W. Eaton for writing this extremely useful macro. Thank you John.
636 AC_DEFUN([_AC_FC_LIBRARY_LDFLAGS],
637 [AC_REQUIRE([AC_CANONICAL_HOST])dnl
638 _AC_FORTRAN_ASSERT()dnl
639 _AC_PROG_FC_V
640 AC_CACHE_CHECK([for _AC_LANG libraries of $[]_AC_FC[]], ac_cv_[]_AC_LANG_ABBREV[]_libs,
641 [if test "x$[]_AC_LANG_PREFIX[]LIBS" != "x"; then
642 ac_cv_[]_AC_LANG_ABBREV[]_libs="$[]_AC_LANG_PREFIX[]LIBS" # Let the user override the test.
643 else
645 _AC_PROG_FC_V_OUTPUT
647 ac_cv_[]_AC_LANG_ABBREV[]_libs=
649 # Save positional arguments (if any)
650 ac_save_positional="$[@]"
652 set X $ac_[]_AC_LANG_ABBREV[]_v_output
653 while test $[@%:@] != 1; do
654 shift
655 ac_arg=$[1]
656 case $ac_arg in
657 [[\\/]]*.a | ?:[[\\/]]*.a)
658 _AC_LIST_MEMBER_IF($ac_arg, $ac_cv_[]_AC_LANG_ABBREV[]_libs, ,
659 ac_cv_[]_AC_LANG_ABBREV[]_libs="$ac_cv_[]_AC_LANG_ABBREV[]_libs $ac_arg")
660 ;;
661 -bI:*)
662 _AC_LIST_MEMBER_IF($ac_arg, $ac_cv_[]_AC_LANG_ABBREV[]_libs, ,
663 [_AC_LINKER_OPTION([$ac_arg], ac_cv_[]_AC_LANG_ABBREV[]_libs)])
664 ;;
665 # Ignore these flags.
666 -lang* | -lcrt*.o | -lc | -lgcc* | -lSystem | -libmil | -little \
667 |-LANG:=* | -LIST:* | -LNO:* | -link)
668 ;;
669 -lkernel32 | -lmingw* | -lmoldname)
670 # Ignore this library only on Windows-like systems.
671 case $host_os in
672 cygwin* | msys* | mingw* | windows*) ;;
673 *)
674 _AC_LIST_MEMBER_IF($ac_arg, $ac_cv_[]_AC_LANG_ABBREV[]_libs, ,
675 ac_cv_[]_AC_LANG_ABBREV[]_libs="$ac_cv_[]_AC_LANG_ABBREV[]_libs $ac_arg")
676 ;;
677 esac
678 ;;
679 -[[LRuYz]])
680 # These flags, when seen by themselves, take an argument.
681 # We remove the space between option and argument and re-iterate
682 # unless we find an empty arg or a new option (starting with -)
683 case $[2] in
684 "" | -*);;
685 *)
686 ac_arg="$ac_arg$[2]"
687 shift; shift
688 set X $ac_arg "$[@]"
689 ;;
690 esac
691 ;;
692 -YP,*)
693 for ac_j in `AS_ECHO(["$ac_arg"]) | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
694 _AC_LIST_MEMBER_IF($ac_j, $ac_cv_[]_AC_LANG_ABBREV[]_libs, ,
695 [ac_arg="$ac_arg $ac_j"
696 ac_cv_[]_AC_LANG_ABBREV[]_libs="$ac_cv_[]_AC_LANG_ABBREV[]_libs $ac_j"])
697 done
698 ;;
699 -[[lLR]]*)
700 _AC_LIST_MEMBER_IF($ac_arg, $ac_cv_[]_AC_LANG_ABBREV[]_libs, ,
701 ac_cv_[]_AC_LANG_ABBREV[]_libs="$ac_cv_[]_AC_LANG_ABBREV[]_libs $ac_arg")
702 ;;
703 -zallextract*| -zdefaultextract)
704 ac_cv_[]_AC_LANG_ABBREV[]_libs="$ac_cv_[]_AC_LANG_ABBREV[]_libs $ac_arg"
705 ;;
706 -mllvm) ${2+shift};; # Defend against 'clang -mllvm -loopopt=0'.
707 # Ignore everything else.
708 esac
709 done
710 # restore positional arguments
711 set X $ac_save_positional; shift
713 # We only consider "LD_RUN_PATH" on Solaris systems. If this is seen,
714 # then we insist that the "run path" must be an absolute path (i.e. it
715 # must begin with a "/").
716 case `(uname -sr) 2>/dev/null` in
717 "SunOS 5"*)
718 ac_ld_run_path=`AS_ECHO(["$ac_[]_AC_LANG_ABBREV[]_v_output"]) |
719 sed -n 's,^.*LD_RUN_PATH *= *\(/[[^ ]]*\).*$,-R\1,p'`
720 test "x$ac_ld_run_path" != x &&
721 _AC_LINKER_OPTION([$ac_ld_run_path], ac_cv_[]_AC_LANG_ABBREV[]_libs)
722 ;;
723 esac
724 fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
725 ])
726 []_AC_LANG_PREFIX[]LIBS="$ac_cv_[]_AC_LANG_ABBREV[]_libs"
727 AC_SUBST([]_AC_LANG_PREFIX[]LIBS)
728 ])# _AC_FC_LIBRARY_LDFLAGS
731 # AC_F77_LIBRARY_LDFLAGS
732 # ----------------------
733 AC_DEFUN([AC_F77_LIBRARY_LDFLAGS],
734 [AC_REQUIRE([AC_PROG_F77])dnl
735 AC_LANG_PUSH(Fortran 77)dnl
736 _AC_FC_LIBRARY_LDFLAGS
737 AC_LANG_POP(Fortran 77)dnl
738 ])# AC_F77_LIBRARY_LDFLAGS
741 # AC_FC_LIBRARY_LDFLAGS
742 # ---------------------
743 AC_DEFUN([AC_FC_LIBRARY_LDFLAGS],
744 [AC_REQUIRE([AC_PROG_FC])dnl
745 AC_LANG_PUSH(Fortran)dnl
746 _AC_FC_LIBRARY_LDFLAGS
747 AC_LANG_POP(Fortran)dnl
748 ])# AC_FC_LIBRARY_LDFLAGS
751 # _AC_FC_DUMMY_MAIN([ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
752 # -----------------------------------------------------------
753 #
754 # Detect name of dummy main routine required by the Fortran libraries,
755 # (if any) and define {F77,FC}_DUMMY_MAIN to this name (which should be
756 # used for a dummy declaration, if it is defined). On some systems,
757 # linking a C program to the Fortran library does not work unless you
758 # supply a dummy function called something like MAIN__.
759 #
760 # Execute ACTION-IF-NOT-FOUND if no way of successfully linking a C
761 # program with the {F77,FC} libs is found; default to exiting with an error
762 # message. Execute ACTION-IF-FOUND if a dummy routine name is needed
763 # and found or if it is not needed (default to defining {F77,FC}_DUMMY_MAIN
764 # when needed).
765 #
766 # What is technically happening is that the Fortran libraries provide
767 # their own main() function, which usually initializes Fortran I/O and
768 # similar stuff, and then calls MAIN__, which is the entry point of
769 # your program. Usually, a C program will override this with its own
770 # main() routine, but the linker sometimes complain if you don't
771 # provide a dummy (never-called) MAIN__ routine anyway.
772 #
773 # Of course, programs that want to allow Fortran subroutines to do
774 # I/O, etcetera, should call their main routine MAIN__() (or whatever)
775 # instead of main(). A separate autoconf test (_AC_FC_MAIN) checks
776 # for the routine to use in this case (since the semantics of the test
777 # are slightly different). To link to e.g. purely numerical
778 # libraries, this is normally not necessary, however, and most C/C++
779 # programs are reluctant to turn over so much control to Fortran. =)
780 #
781 # The name variants we check for are (in order):
782 # MAIN__ (g77, MAIN__ required on some systems; IRIX, MAIN__ optional)
783 # MAIN_, __main (SunOS)
784 # MAIN _MAIN __MAIN main_ main__ _main (we follow DDD and try these too)
785 AC_DEFUN([_AC_FC_DUMMY_MAIN],
786 [_AC_FORTRAN_ASSERT()dnl
787 m4_define(_AC_LANG_PROGRAM_C_[]_AC_FC[]_HOOKS,
788 [#ifdef ]_AC_FC[_DUMMY_MAIN
789 ]AC_LANG_CASE([Fortran], [#ifndef FC_DUMMY_MAIN_EQ_F77])
790 [# ifdef __cplusplus
791 extern "C"
792 # endif
793 int ]_AC_FC[_DUMMY_MAIN() { return 1; }
794 ]AC_LANG_CASE([Fortran], [#endif])
795 [#endif
796 ])
797 AC_CACHE_CHECK([for dummy main to link with _AC_LANG libraries],
798 ac_cv_[]_AC_LANG_ABBREV[]_dummy_main,
799 [ac_[]_AC_LANG_ABBREV[]_dm_save_LIBS=$LIBS
800 LIBS="$LIBS $[]_AC_LANG_PREFIX[]LIBS"
801 ac_fortran_dm_var=[]_AC_FC[]_DUMMY_MAIN
802 AC_LANG_PUSH(C)dnl
804 # First, try linking without a dummy main:
805 AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])],
806 [ac_cv_fortran_dummy_main=none],
807 [ac_cv_fortran_dummy_main=unknown])
809 if test $ac_cv_fortran_dummy_main = unknown; then
810 for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
811 AC_LINK_IFELSE([AC_LANG_PROGRAM([[@%:@define $ac_fortran_dm_var $ac_func]])],
812 [ac_cv_fortran_dummy_main=$ac_func; break])
813 done
814 fi
815 AC_LANG_POP(C)dnl
816 ac_cv_[]_AC_LANG_ABBREV[]_dummy_main=$ac_cv_fortran_dummy_main
817 rm -rf conftest*
818 LIBS=$ac_[]_AC_LANG_ABBREV[]_dm_save_LIBS
819 ])
820 []_AC_FC[]_DUMMY_MAIN=$ac_cv_[]_AC_LANG_ABBREV[]_dummy_main
821 AS_IF([test "$[]_AC_FC[]_DUMMY_MAIN" != unknown],
822 [m4_default([$1],
823 [if test $[]_AC_FC[]_DUMMY_MAIN != none; then
824 AC_DEFINE_UNQUOTED([]_AC_FC[]_DUMMY_MAIN, $[]_AC_FC[]_DUMMY_MAIN,
825 [Define to dummy 'main' function (if any) required to
826 link to the Fortran libraries.])
827 if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
828 AC_DEFINE([FC_DUMMY_MAIN_EQ_F77], 1,
829 [Define if F77 and FC dummy 'main' functions are identical.])
830 fi
831 fi])],
832 [m4_default([$2],
833 [AC_MSG_FAILURE([linking to Fortran libraries from C fails])])])
834 ])# _AC_FC_DUMMY_MAIN
837 # AC_F77_DUMMY_MAIN
838 # -----------------
839 AC_DEFUN([AC_F77_DUMMY_MAIN],
840 [AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl
841 AC_LANG_PUSH(Fortran 77)dnl
842 _AC_FC_DUMMY_MAIN($@)
843 AC_LANG_POP(Fortran 77)dnl
844 ])# AC_F77_DUMMY_MAIN
847 # AC_FC_DUMMY_MAIN
848 # ----------------
849 AC_DEFUN([AC_FC_DUMMY_MAIN],
850 [AC_REQUIRE([AC_FC_LIBRARY_LDFLAGS])dnl
851 AC_LANG_PUSH(Fortran)dnl
852 _AC_FC_DUMMY_MAIN($@)
853 AC_LANG_POP(Fortran)dnl
854 ])# AC_FC_DUMMY_MAIN
857 # _AC_FC_MAIN
858 # -----------
859 # Define {F77,FC}_MAIN to name of alternate main() function for use with
860 # the Fortran libraries. (Typically, the libraries may define their
861 # own main() to initialize I/O, etcetera, that then call your own
862 # routine called MAIN__ or whatever.) See _AC_FC_DUMMY_MAIN, above.
863 # If no such alternate name is found, just define {F77,FC}_MAIN to main.
864 #
865 AC_DEFUN([_AC_FC_MAIN],
866 [_AC_FORTRAN_ASSERT()dnl
867 AC_CACHE_CHECK([for alternate main to link with _AC_LANG libraries],
868 ac_cv_[]_AC_LANG_ABBREV[]_main,
869 [ac_[]_AC_LANG_ABBREV[]_m_save_LIBS=$LIBS
870 LIBS="$LIBS $[]_AC_LANG_PREFIX[]LIBS"
871 ac_fortran_dm_var=[]_AC_FC[]_DUMMY_MAIN
872 AC_LANG_PUSH(C)dnl
873 ac_cv_fortran_main="main" # default entry point name
874 for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
875 AC_LINK_IFELSE([AC_LANG_PROGRAM([@%:@ifdef FC_DUMMY_MAIN_EQ_F77
876 @%:@ undef F77_DUMMY_MAIN
877 @%:@ undef FC_DUMMY_MAIN
878 @%:@else
879 @%:@ undef $ac_fortran_dm_var
880 @%:@endif
881 @%:@define main $ac_func])],
882 [ac_cv_fortran_main=$ac_func; break])
883 done
884 AC_LANG_POP(C)dnl
885 ac_cv_[]_AC_LANG_ABBREV[]_main=$ac_cv_fortran_main
886 rm -rf conftest*
887 LIBS=$ac_[]_AC_LANG_ABBREV[]_m_save_LIBS
888 ])
889 AC_DEFINE_UNQUOTED([]_AC_FC[]_MAIN, $ac_cv_[]_AC_LANG_ABBREV[]_main,
890 [Define to alternate name for 'main' routine that is
891 called from a 'main' in the Fortran libraries.])
892 ])# _AC_FC_MAIN
895 # AC_F77_MAIN
896 # -----------
897 AC_DEFUN([AC_F77_MAIN],
898 [AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl
899 AC_LANG_PUSH(Fortran 77)dnl
900 _AC_FC_MAIN
901 AC_LANG_POP(Fortran 77)dnl
902 ])# AC_F77_MAIN
905 # AC_FC_MAIN
906 # ----------
907 AC_DEFUN([AC_FC_MAIN],
908 [AC_REQUIRE([AC_FC_LIBRARY_LDFLAGS])dnl
909 AC_LANG_PUSH(Fortran)dnl
910 _AC_FC_MAIN
911 AC_LANG_POP(Fortran)dnl
912 ])# AC_FC_MAIN
915 # __AC_FC_NAME_MANGLING
916 # ---------------------
917 # Test for the name mangling scheme used by the Fortran compiler.
918 #
919 # Sets ac_cv_{f77,fc}_mangling. The value contains three fields, separated
920 # by commas:
921 #
922 # lower case / upper case:
923 # case translation of the Fortran symbols
924 # underscore / no underscore:
925 # whether the compiler appends "_" to symbol names
926 # extra underscore / no extra underscore:
927 # whether the compiler appends an extra "_" to symbol names already
928 # containing at least one underscore
929 #
930 AC_DEFUN([__AC_FC_NAME_MANGLING],
931 [_AC_FORTRAN_ASSERT()dnl
932 AC_CACHE_CHECK([for _AC_LANG name-mangling scheme],
933 ac_cv_[]_AC_LANG_ABBREV[]_mangling,
934 [AC_COMPILE_IFELSE(
935 [[ subroutine foobar()
936 return
937 end
938 subroutine foo_bar()
939 return
940 end]],
941 [mv conftest.$ac_objext cfortran_test.$ac_objext
943 ac_save_LIBS=$LIBS
944 LIBS="cfortran_test.$ac_objext $LIBS $[]_AC_LANG_PREFIX[]LIBS"
946 AC_LANG_PUSH(C)dnl
947 ac_success=no
948 for ac_foobar in foobar FOOBAR; do
949 for ac_underscore in "" "_"; do
950 ac_func="$ac_foobar$ac_underscore"
951 AC_LINK_IFELSE([AC_LANG_CALL([], [$ac_func])],
952 [ac_success=yes; break 2])
953 done
954 done
955 AC_LANG_POP(C)dnl
957 if test "$ac_success" = "yes"; then
958 case $ac_foobar in
959 foobar)
960 ac_case=lower
961 ac_foo_bar=foo_bar
962 ;;
963 FOOBAR)
964 ac_case=upper
965 ac_foo_bar=FOO_BAR
966 ;;
967 esac
969 AC_LANG_PUSH(C)dnl
970 ac_success_extra=no
971 for ac_extra in "" "_"; do
972 ac_func="$ac_foo_bar$ac_underscore$ac_extra"
973 AC_LINK_IFELSE([AC_LANG_CALL([], [$ac_func])],
974 [ac_success_extra=yes; break])
975 done
976 AC_LANG_POP(C)dnl
978 if test "$ac_success_extra" = "yes"; then
979 ac_cv_[]_AC_LANG_ABBREV[]_mangling="$ac_case case"
980 if test -z "$ac_underscore"; then
981 ac_cv_[]_AC_LANG_ABBREV[]_mangling="$ac_cv_[]_AC_LANG_ABBREV[]_mangling, no underscore"
982 else
983 ac_cv_[]_AC_LANG_ABBREV[]_mangling="$ac_cv_[]_AC_LANG_ABBREV[]_mangling, underscore"
984 fi
985 if test -z "$ac_extra"; then
986 ac_cv_[]_AC_LANG_ABBREV[]_mangling="$ac_cv_[]_AC_LANG_ABBREV[]_mangling, no extra underscore"
987 else
988 ac_cv_[]_AC_LANG_ABBREV[]_mangling="$ac_cv_[]_AC_LANG_ABBREV[]_mangling, extra underscore"
989 fi
990 else
991 ac_cv_[]_AC_LANG_ABBREV[]_mangling="unknown"
992 fi
993 else
994 ac_cv_[]_AC_LANG_ABBREV[]_mangling="unknown"
995 fi
997 LIBS=$ac_save_LIBS
998 rm -rf conftest*
999 rm -f cfortran_test*],
1000 [AC_MSG_FAILURE([cannot compile a simple Fortran program])])
1001 ])
1002 ])# __AC_FC_NAME_MANGLING
1004 # The replacement is empty.
1005 AU_DEFUN([AC_F77_NAME_MANGLING], [])
1008 # _AC_F77_NAME_MANGLING
1009 # ---------------------
1010 AC_DEFUN([_AC_F77_NAME_MANGLING],
1011 [AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])dnl
1012 AC_REQUIRE([AC_F77_DUMMY_MAIN])dnl
1013 AC_LANG_PUSH(Fortran 77)dnl
1014 __AC_FC_NAME_MANGLING
1015 AC_LANG_POP(Fortran 77)dnl
1016 ])# _AC_F77_NAME_MANGLING
1019 # _AC_FC_NAME_MANGLING
1020 # --------------------
1021 AC_DEFUN([_AC_FC_NAME_MANGLING],
1022 [AC_REQUIRE([AC_FC_LIBRARY_LDFLAGS])dnl
1023 AC_REQUIRE([AC_FC_DUMMY_MAIN])dnl
1024 AC_LANG_PUSH(Fortran)dnl
1025 __AC_FC_NAME_MANGLING
1026 AC_LANG_POP(Fortran)dnl
1027 ])# _AC_FC_NAME_MANGLING
1030 # _AC_FC_WRAPPERS
1031 # ---------------
1032 # Defines C macros {F77,FC}_FUNC(name,NAME) and {F77,FC}_FUNC_(name,NAME) to
1033 # properly mangle the names of C identifiers, and C identifiers with
1034 # underscores, respectively, so that they match the name mangling
1035 # scheme used by the Fortran compiler.
1036 AC_DEFUN([_AC_FC_WRAPPERS],
1037 [_AC_FORTRAN_ASSERT()dnl
1038 AH_TEMPLATE(_AC_FC[_FUNC],
1039 [Define to a macro mangling the given C identifier (in lower and upper
1040 case), which must not contain underscores, for linking with Fortran.])dnl
1041 AH_TEMPLATE(_AC_FC[_FUNC_],
1042 [As ]_AC_FC[_FUNC, but for C identifiers containing underscores.])dnl
1043 case $ac_cv_[]_AC_LANG_ABBREV[]_mangling in
1044 "lower case, no underscore, no extra underscore")
1045 AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [name])
1046 AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [name]) ;;
1047 "lower case, no underscore, extra underscore")
1048 AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [name])
1049 AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [name [##] _]) ;;
1050 "lower case, underscore, no extra underscore")
1051 AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [name [##] _])
1052 AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [name [##] _]) ;;
1053 "lower case, underscore, extra underscore")
1054 AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [name [##] _])
1055 AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [name [##] __]) ;;
1056 "upper case, no underscore, no extra underscore")
1057 AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [NAME])
1058 AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [NAME]) ;;
1059 "upper case, no underscore, extra underscore")
1060 AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [NAME])
1061 AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [NAME [##] _]) ;;
1062 "upper case, underscore, no extra underscore")
1063 AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [NAME [##] _])
1064 AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [NAME [##] _]) ;;
1065 "upper case, underscore, extra underscore")
1066 AC_DEFINE(_AC_FC[_FUNC(name,NAME)], [NAME [##] _])
1067 AC_DEFINE(_AC_FC[_FUNC_(name,NAME)], [NAME [##] __]) ;;
1068 *)
1069 AC_MSG_WARN([unknown Fortran name-mangling scheme])
1070 ;;
1071 esac
1072 ])# _AC_FC_WRAPPERS
1075 # AC_F77_WRAPPERS
1076 # ---------------
1077 AC_DEFUN([AC_F77_WRAPPERS],
1078 [AC_REQUIRE([_AC_F77_NAME_MANGLING])dnl
1079 AC_LANG_PUSH(Fortran 77)dnl
1080 _AC_FC_WRAPPERS
1081 AC_LANG_POP(Fortran 77)dnl
1082 ])# AC_F77_WRAPPERS
1085 # AC_FC_WRAPPERS
1086 # --------------
1087 AC_DEFUN([AC_FC_WRAPPERS],
1088 [AC_REQUIRE([_AC_FC_NAME_MANGLING])dnl
1089 AC_LANG_PUSH(Fortran)dnl
1090 _AC_FC_WRAPPERS
1091 AC_LANG_POP(Fortran)dnl
1092 ])# AC_FC_WRAPPERS
1095 # _AC_FC_FUNC(NAME, [SHELLVAR = NAME])
1096 # ------------------------------------
1097 # For a Fortran subroutine of given NAME, define a shell variable
1098 # $SHELLVAR to the Fortran-mangled name. If the SHELLVAR
1099 # argument is not supplied, it defaults to NAME.
1100 AC_DEFUN([_AC_FC_FUNC],
1101 [_AC_FORTRAN_ASSERT()dnl
1102 case $ac_cv_[]_AC_LANG_ABBREV[]_mangling in
1103 upper*) ac_val="m4_toupper([$1])" ;;
1104 lower*) ac_val="m4_tolower([$1])" ;;
1105 *) ac_val="unknown" ;;
1106 esac
1107 case $ac_cv_[]_AC_LANG_ABBREV[]_mangling in *," underscore"*) ac_val="$ac_val"_ ;; esac
1108 m4_if(m4_index([$1],[_]),-1,[],
1109 [case $ac_cv_[]_AC_LANG_ABBREV[]_mangling in *," extra underscore"*) ac_val="$ac_val"_ ;; esac
1110 ])
1111 m4_default([$2],[$1])="$ac_val"
1112 ])# _AC_FC_FUNC
1115 # AC_F77_FUNC(NAME, [SHELLVAR = NAME])
1116 # ------------------------------------
1117 AC_DEFUN([AC_F77_FUNC],
1118 [AC_REQUIRE([_AC_F77_NAME_MANGLING])dnl
1119 AC_LANG_PUSH(Fortran 77)dnl
1120 _AC_FC_FUNC([$1],[$2])
1121 AC_LANG_POP(Fortran 77)dnl
1122 ])# AC_F77_FUNC
1125 # AC_FC_FUNC(NAME, [SHELLVAR = NAME])
1126 # -----------------------------------
1127 AC_DEFUN([AC_FC_FUNC],
1128 [AC_REQUIRE([_AC_FC_NAME_MANGLING])dnl
1129 AC_LANG_PUSH(Fortran)dnl
1130 _AC_FC_FUNC([$1],[$2])
1131 AC_LANG_POP(Fortran)dnl
1132 ])# AC_FC_FUNC
1135 # AC_FC_SRCEXT(EXT, [ACTION-IF-SUCCESS], [ACTION-IF-FAILURE])
1136 # -----------------------------------------------------------
1137 # Set the source-code extension used in Fortran (FC) tests to EXT (which
1138 # defaults to f). Also, look for any necessary additional FCFLAGS needed
1139 # to allow this extension, and store them in the output variable
1140 # FCFLAGS_<EXT> (e.g. FCFLAGS_f90 for EXT=f90). If successful,
1141 # call ACTION-IF-SUCCESS. If unable to compile source code with EXT,
1142 # call ACTION-IF-FAILURE, which defaults to failing with an error
1143 # message.
1144 #
1145 # (The flags for the current source-code extension, if any, are stored in
1146 # $ac_fcflags_srcext and used automatically in subsequent autoconf tests.)
1147 #
1148 # For ordinary extensions like f90, etcetera, the modified FCFLAGS
1149 # are currently needed for IBM's xlf* and Intel's ifc (grrr). Unfortunately,
1150 # xlf* will only take flags to recognize one extension at a time, so if the
1151 # user wants to compile multiple extensions (.f90 and .f95, say), she
1152 # will need to use the FCFLAGS_F90 and FCFLAGS_F95 individually rather
1153 # than just adding them all to FCFLAGS, for example.
1154 #
1155 # Also, for Intel's ifc compiler (which does not accept .f95 by default in
1156 # some versions), the $FCFLAGS_<EXT> variable *must* go immediately before
1157 # the source file on the command line, unlike other $FCFLAGS. Ugh.
1158 #
1159 # gfortran requires '-x f77' in order to recognize .f77 files.
1160 AC_DEFUN([AC_FC_SRCEXT],
1161 [AC_LANG_PUSH(Fortran)dnl
1162 AC_CACHE_CHECK([for Fortran flag to compile .$1 files],
1163 ac_cv_fc_srcext_$1,
1164 [ac_ext=$1
1165 ac_fcflags_srcext_save=$ac_fcflags_srcext
1166 ac_fcflags_srcext=
1167 ac_cv_fc_srcext_$1=unknown
1168 case $ac_ext in #(
1169 [[fF]]77) ac_try=f77;; #(
1170 *) ac_try=f95;;
1171 esac
1172 for ac_flag in none -qsuffix=f=$1 -Tf "-x $ac_try"; do
1173 test "x$ac_flag" != xnone && ac_fcflags_srcext="$ac_flag"
1174 AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], [ac_cv_fc_srcext_$1=$ac_flag; break])
1175 done
1176 rm -f conftest.$ac_objext conftest.$1
1177 ac_fcflags_srcext=$ac_fcflags_srcext_save
1178 ])
1179 if test "x$ac_cv_fc_srcext_$1" = xunknown; then
1180 m4_default([$3],[AC_MSG_ERROR([Fortran could not compile .$1 files])])
1181 else
1182 ac_fc_srcext=$1
1183 if test "x$ac_cv_fc_srcext_$1" = xnone; then
1184 ac_fcflags_srcext=""
1185 FCFLAGS_[]$1[]=""
1186 else
1187 ac_fcflags_srcext=$ac_cv_fc_srcext_$1
1188 FCFLAGS_[]$1[]=$ac_cv_fc_srcext_$1
1189 fi
1190 AC_SUBST(FCFLAGS_[]$1)
1191 $2
1192 fi
1193 AC_LANG_POP(Fortran)dnl
1194 ])# AC_FC_SRCEXT
1197 # AC_FC_PP_SRCEXT(EXT, [ACTION-IF-SUCCESS], [ACTION-IF-FAILURE])
1198 # --------------------------------------------------------------
1199 # Like AC_FC_SRCEXT, set the source-code extension used in Fortran (FC) tests
1200 # to EXT (which defaults to f). Also, look for any necessary additional
1201 # FCFLAGS needed to allow this extension for preprocessed Fortran, and store
1202 # them in the output variable FCFLAGS_<EXT> (e.g. FCFLAGS_f90 for EXT=f90).
1203 # If successful, call ACTION-IF-SUCCESS. If unable to compile preprocessed
1204 # source code with EXT, call ACTION-IF-FAILURE, which defaults to failing with
1205 # an error message.
1206 #
1207 # Some compilers allow preprocessing with either a Fortran preprocessor or
1208 # with the C preprocessor (cpp). Prefer the Fortran preprocessor, to deal
1209 # correctly with continuation lines, '//' (not a comment), and preserve white
1210 # space (for fixed form).
1211 #
1212 # (The flags for the current source-code extension, if any, are stored in
1213 # $ac_fcflags_srcext and used automatically in subsequent autoconf tests.)
1214 #
1215 # For ordinary extensions like f90, etcetera, the modified FCFLAGS
1216 # are needed for IBM's xlf*. Also, for Intel's ifort compiler, the
1217 # $FCFLAGS_<EXT> variable *must* go immediately before the source file on the
1218 # command line, unlike other $FCFLAGS. Ugh.
1219 #
1220 # Known extensions that enable preprocessing by default, and flags to force it:
1221 # GNU: .F .F90 .F95 .F03 .F08, -cpp for most others,
1222 # -x f77-cpp-input for .f77 .F77; -x f95-cpp-input for gfortran < 4.4
1223 # SGI: .F .F90, -ftpp or -cpp for .f .f90, -E write preproc to stdout
1224 # -macro_expand enable macro expansion everywhere (with -ftpp)
1225 # -P preproc only, save in .i, no #line's
1226 # SUN: .F .F95, -fpp for others; -xpp={fpp,cpp} for preprocessor selection
1227 # -F preprocess only (save in lowercase extension)
1228 # IBM: .F .F77 .F90 .F95 .F03, -qsuffix=cpp=EXT for extension .EXT to invoke cpp
1229 # -WF,-qnofpp -WF,-qfpp=comment:linecont:nocomment:nolinecont
1230 # -WF,-qlanglvl=classic or not -qnoescape (trigraph problems)
1231 # -d no #line in output, -qnoobject for preprocessing only (output in .f)
1232 # -q{no,}ppsuborigarg substitute original macro args before expansion
1233 # HP: .F, +cpp={yes|no|default} use cpp, -cpp, +cpp_keep save in .i/.i90
1234 # PGI: -Mpreprocess
1235 # Absoft: .F .FOR .F90 .F95, -cpp for others
1236 # Cray: .F .F90 .FTN, -e Z for others; -F enable macro expansion everywhere
1237 # Intel: .F .F90, -fpp for others, but except for .f and .f90, -Tf may also be
1238 # needed right before the source file name
1239 # PathScale: .F .F90 .F95, -ftpp or -cpp for .f .f90 .f95
1240 # -macro_expand for expansion everywhere, -P for no #line in output
1241 # Lahey: .F .FOR .F90 .F95, -Cpp
1242 # NAGWare: .F .F90 .F95, .ff .ff90 .ff95 (new), -fpp for others
1243 # Compaq/Tru64: .F .F90, -cpp, -P keep .i file, -P keep .i file
1244 # f2c: .F, -cpp
1245 # g95: .F .FOR .F90 .F95 .F03, -cpp -no-cpp, -E for stdout
1246 AC_DEFUN([AC_FC_PP_SRCEXT],
1247 [AC_LANG_PUSH(Fortran)dnl
1248 AC_CACHE_CHECK([for Fortran flag to compile preprocessed .$1 files],
1249 ac_cv_fc_pp_srcext_$1,
1250 [ac_ext=$1
1251 ac_fcflags_pp_srcext_save=$ac_fcflags_srcext
1252 ac_fcflags_srcext=
1253 ac_cv_fc_pp_srcext_$1=unknown
1254 case $ac_ext in #(
1255 [[fF]]77) ac_try=f77-cpp-input;; #(
1256 *) ac_try=f95-cpp-input;;
1257 esac
1258 for ac_flag in none -ftpp -fpp -Tf "-fpp -Tf" -xpp=fpp -Mpreprocess "-e Z" \
1259 -cpp -xpp=cpp -qsuffix=cpp=$1 "-x $ac_try" +cpp -Cpp; do
1260 test "x$ac_flag" != xnone && ac_fcflags_srcext="$ac_flag"
1261 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[
1262 #if 0
1263 #include <ac_nonexistent.h>
1264 choke me
1265 #endif]])],
1266 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[
1267 #if 1
1268 #include <ac_nonexistent.h>
1269 choke me
1270 #endif]])],
1271 [],
1272 [ac_cv_fc_pp_srcext_$1=$ac_flag; break])])
1273 done
1274 rm -f conftest.$ac_objext conftest.$1
1275 ac_fcflags_srcext=$ac_fcflags_pp_srcext_save
1276 ])
1277 if test "x$ac_cv_fc_pp_srcext_$1" = xunknown; then
1278 m4_default([$3],
1279 [AC_MSG_ERROR([Fortran could not compile preprocessed .$1 files])])
1280 else
1281 ac_fc_srcext=$1
1282 if test "x$ac_cv_fc_pp_srcext_$1" = xnone; then
1283 ac_fcflags_srcext=""
1284 FCFLAGS_[]$1[]=""
1285 else
1286 ac_fcflags_srcext=$ac_cv_fc_pp_srcext_$1
1287 FCFLAGS_[]$1[]=$ac_cv_fc_pp_srcext_$1
1288 fi
1289 AC_SUBST(FCFLAGS_[]$1)
1290 $2
1291 fi
1292 AC_LANG_POP(Fortran)dnl
1293 ])# AC_FC_PP_SRCEXT
1296 # AC_FC_PP_DEFINE([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE])
1297 # -------------------------------------------------------------------
1298 # Find a flag to specify defines for preprocessed Fortran. Not all
1299 # Fortran compilers use -D. Substitute FC_DEFINE with the result and
1300 # call ACTION-IF-SUCCESS (defaults to nothing) if successful, and
1301 # ACTION-IF-FAILURE (defaults to failing with an error message) if not.
1302 #
1303 # Known flags:
1304 # IBM: -WF,-D
1305 # Lahey/Fujitsu: -Wp,-D older versions???
1306 # f2c: -D or -Wc,-D
1307 # others: -D
1308 AC_DEFUN([AC_FC_PP_DEFINE],
1309 [AC_LANG_PUSH([Fortran])dnl
1310 ac_fc_pp_define_srcext_save=$ac_fc_srcext
1311 AC_FC_PP_SRCEXT([F])
1312 AC_CACHE_CHECK([how to define symbols for preprocessed Fortran],
1313 [ac_cv_fc_pp_define],
1314 [ac_fc_pp_define_srcext_save=$ac_fc_srcext
1315 ac_cv_fc_pp_define=unknown
1316 ac_fc_pp_define_FCFLAGS_save=$FCFLAGS
1317 for ac_flag in -D -WF,-D -Wp,-D -Wc,-D
1318 do
1319 FCFLAGS="$ac_fc_pp_define_FCFLAGS_save ${ac_flag}FOOBAR ${ac_flag}ZORK=42"
1320 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[
1321 #ifndef FOOBAR
1322 choke me
1323 #endif
1324 #if ZORK != 42
1325 choke me
1326 #endif]])],
1327 [ac_cv_fc_pp_define=$ac_flag])
1328 test x"$ac_cv_fc_pp_define" != xunknown && break
1329 done
1330 FCFLAGS=$ac_fc_pp_define_FCFLAGS_save
1331 ])
1332 ac_fc_srcext=$ac_fc_pp_define_srcext_save
1333 if test "x$ac_cv_fc_pp_define" = xunknown; then
1334 FC_DEFINE=
1335 m4_default([$2],
1336 [AC_MSG_ERROR([Fortran does not allow to define preprocessor symbols], 77)])
1337 else
1338 FC_DEFINE=$ac_cv_fc_pp_define
1339 $1
1340 fi
1341 AC_SUBST([FC_DEFINE])dnl
1342 AC_LANG_POP([Fortran])dnl
1343 ])
1346 # AC_FC_FREEFORM([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE])
1347 # ------------------------------------------------------------------
1348 # Look for a compiler flag to make the Fortran (FC) compiler accept
1349 # free-format source code, and adds it to FCFLAGS. Call
1350 # ACTION-IF-SUCCESS (defaults to nothing) if successful (i.e. can
1351 # compile code using new extension) and ACTION-IF-FAILURE (defaults to
1352 # failing with an error message) if not. (Defined via DEFUN_ONCE to
1353 # prevent flag from being added to FCFLAGS multiple times.)
1354 #
1355 # The known flags are:
1356 # -ffree-form: GNU g77, gfortran, g95
1357 # -FR, -free: Intel compiler (icc, ecc, ifort)
1358 # -free: Compaq compiler (fort), Sun compiler (f95)
1359 # -qfree: IBM compiler (xlf)
1360 # -Mfree, -Mfreeform: Portland Group compiler
1361 # -freeform: SGI compiler
1362 # -8, -f free: Absoft Fortran
1363 # +source=free: HP Fortran
1364 # (-)-nfix, -Free: Lahey/Fujitsu Fortran
1365 # -free: NAGWare
1366 # -f, -Wf,-f: f2c (but only a weak form of "free-form" and long lines)
1367 # We try to test the "more popular" flags first, by some prejudiced
1368 # notion of popularity.
1369 AC_DEFUN_ONCE([AC_FC_FREEFORM],
1370 [AC_LANG_PUSH([Fortran])dnl
1371 AC_CACHE_CHECK([for Fortran flag needed to accept free-form source],
1372 [ac_cv_fc_freeform],
1373 [ac_cv_fc_freeform=unknown
1374 ac_fc_freeform_FCFLAGS_save=$FCFLAGS
1375 for ac_flag in none -ffree-form -FR -free -qfree -Mfree -Mfreeform \
1376 -freeform "-f free" -8 +source=free -nfix --nfix -Free
1377 do
1378 test "x$ac_flag" != xnone && FCFLAGS="$ac_fc_freeform_FCFLAGS_save $ac_flag"
1379 dnl Use @&t@ below to ensure that editors don't turn 8+ spaces into tab.
1380 AC_COMPILE_IFELSE([[
1381 program freeform
1382 ! FIXME: how to best confuse non-freeform compilers?
1383 print *, 'Hello ', &
1384 @&t@ 'world.'
1385 end]],
1386 [ac_cv_fc_freeform=$ac_flag; break])
1387 done
1388 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1389 FCFLAGS=$ac_fc_freeform_FCFLAGS_save
1390 ])
1391 if test "x$ac_cv_fc_freeform" = xunknown; then
1392 m4_default([$2],
1393 [AC_MSG_ERROR([Fortran does not accept free-form source], 77)])
1394 else
1395 if test "x$ac_cv_fc_freeform" != xnone; then
1396 FCFLAGS="$FCFLAGS $ac_cv_fc_freeform"
1397 fi
1398 $1
1399 fi
1400 AC_LANG_POP([Fortran])dnl
1401 ])# AC_FC_FREEFORM
1404 # AC_FC_FIXEDFORM([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE])
1405 # ------------------------------------------------------------------
1406 # Look for a compiler flag to make the Fortran (FC) compiler accept
1407 # fixed-format source code, and adds it to FCFLAGS. Call
1408 # ACTION-IF-SUCCESS (defaults to nothing) if successful (i.e. can
1409 # compile code using new extension) and ACTION-IF-FAILURE (defaults to
1410 # failing with an error message) if not. (Defined via DEFUN_ONCE to
1411 # prevent flag from being added to FCFLAGS multiple times.)
1412 #
1413 # The known flags are:
1414 # -ffixed-form: GNU g77, gfortran, g95
1415 # -fixed: Intel compiler (ifort), Sun compiler (f95)
1416 # -qfixed: IBM compiler (xlf*)
1417 # -Mfixed: Portland Group compiler
1418 # -fixedform: SGI compiler
1419 # -f fixed: Absoft Fortran
1420 # +source=fixed: HP Fortran
1421 # (-)-fix, -Fixed: Lahey/Fujitsu Fortran
1422 # -fixed: NAGWare
1423 # Since compilers may accept fixed form based on file name extension,
1424 # but users may want to use it with others as well, call AC_FC_SRCEXT
1425 # with the respective source extension before calling this macro.
1426 AC_DEFUN_ONCE([AC_FC_FIXEDFORM],
1427 [AC_LANG_PUSH([Fortran])dnl
1428 AC_CACHE_CHECK([for Fortran flag needed to accept fixed-form source],
1429 [ac_cv_fc_fixedform],
1430 [ac_cv_fc_fixedform=unknown
1431 ac_fc_fixedform_FCFLAGS_save=$FCFLAGS
1432 for ac_flag in none -ffixed-form -fixed -qfixed -Mfixed -fixedform "-f fixed" \
1433 +source=fixed -fix --fix -Fixed
1434 do
1435 test "x$ac_flag" != xnone && FCFLAGS="$ac_fc_fixedform_FCFLAGS_save $ac_flag"
1436 AC_COMPILE_IFELSE([[
1437 C This comment should confuse free-form compilers.
1438 program main
1439 end]],
1440 [ac_cv_fc_fixedform=$ac_flag; break])
1441 done
1442 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1443 FCFLAGS=$ac_fc_fixedform_FCFLAGS_save
1444 ])
1445 if test "x$ac_cv_fc_fixedform" = xunknown; then
1446 m4_default([$2],
1447 [AC_MSG_ERROR([Fortran does not accept fixed-form source], 77)])
1448 else
1449 if test "x$ac_cv_fc_fixedform" != xnone; then
1450 FCFLAGS="$FCFLAGS $ac_cv_fc_fixedform"
1451 fi
1452 $1
1453 fi
1454 AC_LANG_POP([Fortran])dnl
1455 ])# AC_FC_FIXEDFORM
1458 # AC_FC_LINE_LENGTH([LENGTH], [ACTION-IF-SUCCESS],
1459 # [ACTION-IF-FAILURE = FAILURE])
1460 # ------------------------------------------------
1461 # Look for a compiler flag to make the Fortran (FC) compiler accept long lines
1462 # in the current (free- or fixed-format) source code, and adds it to FCFLAGS.
1463 # The optional LENGTH may be 80, 132 (default), or 'unlimited' for longer
1464 # lines. Note that line lengths above 250 columns are not portable, and some
1465 # compilers (hello ifort) do not accept more than 132 columns at least for
1466 # fixed format. Call ACTION-IF-SUCCESS (defaults to nothing) if successful
1467 # (i.e. can compile code using new extension) and ACTION-IF-FAILURE (defaults
1468 # to failing with an error message) if not. (Defined via DEFUN_ONCE to
1469 # prevent flag from being added to FCFLAGS multiple times.)
1470 # You should call AC_FC_FREEFORM or AC_FC_FIXEDFORM to set the desired format
1471 # prior to using this macro.
1472 #
1473 # The known flags are:
1474 # -f{free,fixed}-line-length-N with N 72, 80, 132, or 0 or none for none.
1475 # -ffree-line-length-none: GNU gfortran
1476 # -ffree-line-length-huge: g95 (also -ffixed-line-length-N as above)
1477 # -qfixed=132 80 72: IBM compiler (xlf)
1478 # -Mextend: Cray
1479 # -132 -80 -72: Intel compiler (ifort)
1480 # Needs to come before -extend_source because ifort
1481 # accepts that as well with an optional parameter and
1482 # doesn't fail but only warns about unknown arguments.
1483 # -extend_source: SGI compiler
1484 # -W, -WNN (132, 80, 72): Absoft Fortran
1485 # +es, +extend_source: HP Fortran (254 in either form, default is 72 fixed,
1486 # 132 free)
1487 # -w, (-)-wide: Lahey/Fujitsu Fortran (255 cols in fixed form)
1488 # -e: Sun Fortran compiler (132 characters)
1489 # -132: NAGWare
1490 # -72, -f, -Wf,-f: f2c (a weak form of "free-form" and long lines).
1491 # /XLine: Open Watcom
1492 AC_DEFUN_ONCE([AC_FC_LINE_LENGTH],
1493 [AC_LANG_PUSH([Fortran])dnl
1494 m4_case(m4_default([$1], [132]),
1495 [unlimited], [ac_fc_line_len_string=unlimited
1496 ac_fc_line_len=0
1497 ac_fc_line_length_test='
1498 subroutine longer_than_132(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,'\
1499 'arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19)'],
1500 [132], [ac_fc_line_len=132
1501 ac_fc_line_length_test='
1502 subroutine longer_than_80(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,'\
1503 'arg10)'],
1504 [80], [ac_fc_line_len=80
1505 ac_fc_line_length_test='
1506 subroutine longer_than_72(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9)'],
1507 [m4_warning([Invalid length argument '$1'])])
1508 : ${ac_fc_line_len_string=$ac_fc_line_len}
1509 AC_CACHE_CHECK(
1510 [for Fortran flag needed to accept $ac_fc_line_len_string column source lines],
1511 [ac_cv_fc_line_length],
1512 [ac_cv_fc_line_length=unknown
1513 ac_fc_line_length_FCFLAGS_save=$FCFLAGS
1514 for ac_flag in none \
1515 -ffree-line-length-none -ffixed-line-length-none \
1516 -ffree-line-length-huge \
1517 -ffree-line-length-$ac_fc_line_len \
1518 -ffixed-line-length-$ac_fc_line_len \
1519 -qfixed=$ac_fc_line_len -Mextend \
1520 -$ac_fc_line_len -extend_source \
1521 -W$ac_fc_line_len -W +extend_source +es -wide --wide -w -e \
1522 -f -Wf,-f -xline
1523 do
1524 test "x$ac_flag" != xnone && FCFLAGS="$ac_fc_line_length_FCFLAGS_save $ac_flag"
1525 AC_COMPILE_IFELSE([[$ac_fc_line_length_test
1526 end subroutine]],
1527 [ac_cv_fc_line_length=$ac_flag; break])
1528 done
1529 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1530 FCFLAGS=$ac_fc_line_length_FCFLAGS_save
1531 ])
1532 if test "x$ac_cv_fc_line_length" = xunknown; then
1533 m4_default([$3],
1534 [AC_MSG_ERROR([Fortran does not accept long source lines], 77)])
1535 else
1536 if test "x$ac_cv_fc_line_length" != xnone; then
1537 FCFLAGS="$FCFLAGS $ac_cv_fc_line_length"
1538 fi
1539 $2
1540 fi
1541 AC_LANG_POP([Fortran])dnl
1542 ])# AC_FC_LINE_LENGTH
1545 # AC_FC_CHECK_BOUNDS([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE])
1546 # ----------------------------------------------------------------------
1547 # Look for a compiler flag to turn on array bounds checking for the
1548 # Fortran (FC) compiler, and adds it to FCFLAGS. Call
1549 # ACTION-IF-SUCCESS (defaults to nothing) if successful (i.e. can
1550 # compile code using new extension) and ACTION-IF-FAILURE (defaults to
1551 # failing with an error message) if not. (Defined via DEFUN_ONCE to
1552 # prevent flag from being added to FCFLAGS multiple times.)
1553 #
1554 # The known flags are:
1555 # -fcheck=all, -fbounds-check: gfortran
1556 # -fbounds-check: g77, g95
1557 # -CB, -check bounds: Intel compiler (icc, ecc, ifort)
1558 # -C: Sun/Oracle compiler (f95)
1559 # -C, -qcheck: IBM compiler (xlf)
1560 # -Mbounds: Portland Group compiler
1561 # -C ,-Mbounds: Cray
1562 # -C, -check_bounds: SGI compiler
1563 # -check_bounds, +check=all: HP Fortran
1564 # -C, -Rb -Rc: Absoft (-Rb: array boundaries, -Rc: array conformance)
1565 # --chk e,s -chk (e,s): Lahey
1566 # -C -C=all: NAGWare
1567 # -C, -ffortran-bounds-check: PathScale pathf90
1568 # -C: f2c
1569 # -BOunds: Open Watcom
1570 AC_DEFUN_ONCE([AC_FC_CHECK_BOUNDS],
1571 [AC_LANG_PUSH([Fortran])dnl
1572 AC_CACHE_CHECK([for Fortran flag to enable array-bounds checking],
1573 [ac_cv_fc_check_bounds],
1574 [ac_cv_fc_check_bounds=unknown
1575 ac_fc_check_bounds_FCFLAGS_save=$FCFLAGS
1576 for ac_flag in -fcheck=bounds -fbounds-check -check_bounds -Mbounds -qcheck \
1577 '-check bounds' +check=all --check '-Rb -Rc' -CB -C=all -C \
1578 -ffortran-bounds-check "--chk e,s" "-chk e -chk s" -bounds
1579 do
1580 FCFLAGS="$ac_fc_check_bounds_FCFLAGS_save $ac_flag"
1581 # We should be able to link a correct program.
1582 AC_LINK_IFELSE([AC_LANG_PROGRAM([], [])],
1583 [AC_LINK_IFELSE([[
1584 subroutine sub(a)
1585 integer a(:)
1586 a(8) = 0
1587 end subroutine
1589 program main
1590 integer a(1:7)
1591 interface
1592 subroutine sub(a)
1593 integer a(:)
1594 end subroutine
1595 end interface
1597 call sub(a)
1598 end program]],
1599 [# If we can run the program, require failure at run time.
1600 # In cross-compiling mode, we rely on the compiler not accepting
1601 # unknown options.
1602 AS_IF([test "$cross_compiling" = yes],
1603 [ac_cv_fc_check_bounds=$ac_flag; break],
1604 [AS_IF([_AC_DO_TOKENS(./conftest$ac_exeext)],
1605 [],
1606 [ac_cv_fc_check_bounds=$ac_flag; break])])])])
1607 done
1608 rm -f conftest$ac_exeext conftest.err conftest.$ac_objext conftest.$ac_ext \
1609 core *.core core.conftest.*
1610 FCFLAGS=$ac_fc_check_bounds_FCFLAGS_save
1611 ])
1612 if test "x$ac_cv_fc_check_bounds" = xunknown; then
1613 m4_default([$2],
1614 [AC_MSG_ERROR([no Fortran flag for bounds checking found], 77)])
1615 else
1616 if test "x$ac_cv_fc_check_bounds" != xnone; then
1617 FCFLAGS="$FCFLAGS $ac_cv_fc_check_bounds"
1618 fi
1619 $1
1620 fi
1621 AC_LANG_POP([Fortran])dnl
1622 ])# AC_FC_CHECK_BOUNDS
1625 # _AC_FC_IMPLICIT_NONE([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE])
1626 # ------------------------------------------------------------------------
1627 # Look for a flag to disallow implicit declarations, and add it to FCFLAGS.
1628 # Call ACTION-IF-SUCCESS (defaults to nothing) if successful and
1629 # ACTION-IF-FAILURE (defaults to failing with an error message) if not.
1630 #
1631 # Known flags:
1632 # GNU gfortran, g95: -fimplicit-none, g77: -Wimplicit
1633 # Intel: -u, -implicitnone; might also need '-warn errors' to turn into error.
1634 # Sun/Oracle: -u
1635 # HP: +implicit_none
1636 # IBM: -u, -qundef
1637 # SGI: -u
1638 # Compaq: -u, -warn declarations
1639 # NAGWare: -u
1640 # Lahey: -in, --in, -AT
1641 # Cray: -Mdclchk -e I
1642 # PGI: -Mcdlchk
1643 # f2c: -u
1644 AC_DEFUN([_AC_FC_IMPLICIT_NONE],
1645 [_AC_FORTRAN_ASSERT()dnl
1646 AC_CACHE_CHECK([for flag to disallow _AC_LANG implicit declarations],
1647 [ac_cv_[]_AC_LANG_ABBREV[]_implicit_none],
1648 [ac_cv_[]_AC_LANG_ABBREV[]_implicit_none=unknown
1649 ac_fc_implicit_none_[]_AC_LANG_PREFIX[]FLAGS_save=$[]_AC_LANG_PREFIX[]FLAGS
1650 for ac_flag in none -fimplicit-none -u -Wimplicit -implicitnone +implicit_none \
1651 -qundef "-warn declarations" -in --in -AT "-e I" -Mdclchk \
1652 "-u -warn errors"
1653 do
1654 if test "x$ac_flag" != xnone; then
1655 _AC_LANG_PREFIX[]FLAGS="$ac_fc_implicit_none_[]_AC_LANG_PREFIX[]FLAGS_save $ac_flag"
1656 fi
1657 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [])],
1658 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[
1659 i = 0
1660 print *, i]])],
1661 [],
1662 [ac_cv_[]_AC_LANG_ABBREV[]_implicit_none=$ac_flag; break])])
1663 done
1664 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1665 _AC_LANG_PREFIX[]FLAGS=$ac_fc_implicit_none_[]_AC_LANG_PREFIX[]FLAGS_save
1666 ])
1667 if test "x$ac_cv_[]_AC_LANG_ABBREV[]_implicit_none" = xunknown; then
1668 m4_default([$3],
1669 [AC_MSG_ERROR([no Fortran flag to disallow implicit declarations found], 77)])
1670 else
1671 if test "x$ac_cv_[]_AC_LANG_ABBREV[]_implicit_none" != xnone; then
1672 _AC_LANG_PREFIX[]FLAGS="$_AC_LANG_PREFIX[]FLAGS $ac_cv_[]_AC_LANG_ABBREV[]_implicit_none"
1673 fi
1674 $2
1675 fi
1676 ])# _AC_FC_IMPLICIT_NONE
1679 # AC_F77_IMPLICIT_NONE([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE])
1680 # ------------------------------------------------------------------------
1681 AC_DEFUN([AC_F77_IMPLICIT_NONE],
1682 [AC_LANG_PUSH([Fortran 77])dnl
1683 _AC_FC_IMPLICIT_NONE($@)
1684 AC_LANG_POP([Fortran 77])dnl
1685 ])# AC_F77_IMPLICIT_NONE
1688 # AC_FC_IMPLICIT_NONE([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE])
1689 # -----------------------------------------------------------------------
1690 AC_DEFUN([AC_FC_IMPLICIT_NONE],
1691 [AC_LANG_PUSH([Fortran])dnl
1692 _AC_FC_IMPLICIT_NONE($@)
1693 AC_LANG_POP([Fortran])dnl
1694 ])# AC_FC_IMPLICIT_NONE
1697 # AC_FC_MODULE_EXTENSION
1698 # ----------------------
1699 # Find the Fortran 90 module file extension. The module extension is stored
1700 # in the variable FC_MODEXT and empty if it cannot be determined. The result
1701 # or "unknown" is cached in the cache variable ac_cv_fc_module_ext.
1702 AC_DEFUN([AC_FC_MODULE_EXTENSION],
1703 [AC_CACHE_CHECK([Fortran 90 module extension], [ac_cv_fc_module_ext],
1704 [AC_LANG_PUSH(Fortran)
1705 mkdir conftest.dir
1706 cd conftest.dir
1707 ac_cv_fc_module_ext=unknown
1708 AC_COMPILE_IFELSE([[
1709 module conftest_module
1710 contains
1711 subroutine conftest_routine
1712 write(*,'(a)') 'gotcha!'
1713 end subroutine
1714 end module]],
1715 [ac_cv_fc_module_ext=`ls | sed -n 's,conftest_module\.,,p'`
1716 if test x$ac_cv_fc_module_ext = x; then
1717 dnl Some F90 compilers use upper case characters for the module file name.
1718 ac_cv_fc_module_ext=`ls | sed -n 's,CONFTEST_MODULE\.,,p'`
1719 fi])
1720 cd ..
1721 rm -rf conftest.dir
1722 AC_LANG_POP(Fortran)
1723 ])
1724 FC_MODEXT=$ac_cv_fc_module_ext
1725 if test "$FC_MODEXT" = unknown; then
1726 FC_MODEXT=
1727 fi
1728 AC_SUBST([FC_MODEXT])dnl
1729 ])
1732 # AC_FC_MODULE_FLAG([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE])
1733 # ---------------------------------------------------------------------
1734 # Find a flag to include Fortran 90 modules from another directory.
1735 # If successful, run ACTION-IF-SUCCESS (defaults to nothing), otherwise
1736 # run ACTION-IF-FAILURE (defaults to failing with an error message).
1737 # The module flag is cached in the ac_cv_fc_module_flag variable.
1738 # It may contain significant trailing whitespace.
1739 #
1740 # Known flags:
1741 # gfortran: -Idir, -I dir (-M dir, -Mdir (deprecated), -Jdir for writing)
1742 # g95: -I dir (-fmod=dir for writing)
1743 # SUN: -Mdir, -M dir (-moddir=dir for writing;
1744 # -Idir for includes is also searched)
1745 # HP: -Idir, -I dir (+moddir=dir for writing)
1746 # IBM: -Idir (-qmoddir=dir for writing)
1747 # Intel: -Idir -I dir (-mod dir for writing)
1748 # Absoft: -pdir
1749 # Lahey: -mod dir
1750 # Cray: -module dir, -p dir (-J dir for writing)
1751 # -e m is needed to enable writing .mod files at all
1752 # Compaq: -Idir
1753 # NAGWare: -I dir
1754 # PathScale: -I dir (but -module dir is looked at first)
1755 # Portland: -module dir (first -module also names dir for writing)
1756 # Fujitsu: -Am -Idir (-Mdir for writing is searched first, then '.', then -I)
1757 # (-Am indicates how module information is saved)
1758 AC_DEFUN([AC_FC_MODULE_FLAG],[
1759 AC_CACHE_CHECK([Fortran 90 module inclusion flag], [ac_cv_fc_module_flag],
1760 [AC_LANG_PUSH([Fortran])
1761 ac_cv_fc_module_flag=unknown
1762 mkdir conftest.dir
1763 cd conftest.dir
1764 AC_COMPILE_IFELSE([[
1765 module conftest_module
1766 contains
1767 subroutine conftest_routine
1768 write(*,'(a)') 'gotcha!'
1769 end subroutine
1770 end module]],
1771 [cd ..
1772 ac_fc_module_flag_FCFLAGS_save=$FCFLAGS
1773 # Flag ordering is significant for gfortran and Sun.
1774 for ac_flag in -M -I '-I ' '-M ' -p '-mod ' '-module ' '-Am -I'; do
1775 # Add the flag twice to prevent matching an output flag.
1776 FCFLAGS="$ac_fc_module_flag_FCFLAGS_save ${ac_flag}conftest.dir ${ac_flag}conftest.dir"
1777 AC_COMPILE_IFELSE([[
1778 program main
1779 use conftest_module
1780 call conftest_routine
1781 end program]],
1782 [ac_cv_fc_module_flag="$ac_flag"])
1783 if test "$ac_cv_fc_module_flag" != unknown; then
1784 break
1785 fi
1786 done
1787 FCFLAGS=$ac_fc_module_flag_FCFLAGS_save
1788 ])
1789 rm -rf conftest.dir
1790 AC_LANG_POP([Fortran])
1791 ])
1792 if test "$ac_cv_fc_module_flag" != unknown; then
1793 FC_MODINC=$ac_cv_fc_module_flag
1794 $1
1795 else
1796 FC_MODINC=
1797 m4_default([$2],
1798 [AC_MSG_ERROR([unable to find compiler flag for module search path])])
1799 fi
1800 AC_SUBST([FC_MODINC])
1801 # Ensure trailing whitespace is preserved in a Makefile.
1802 AC_SUBST([ac_empty], [""])
1803 AC_CONFIG_COMMANDS_PRE([case $FC_MODINC in #(
1804 *\ ) FC_MODINC=$FC_MODINC'${ac_empty}' ;;
1805 esac])dnl
1806 ])
1809 # AC_FC_MODULE_OUTPUT_FLAG([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE])
1810 # ----------------------------------------------------------------------------
1811 # Find a flag to write Fortran 90 module information to another directory.
1812 # If successful, run ACTION-IF-SUCCESS (defaults to nothing), otherwise
1813 # run ACTION-IF-FAILURE (defaults to failing with an error message).
1814 # The module flag is cached in the ac_cv_fc_module_output_flag variable.
1815 # It may contain significant trailing whitespace.
1816 #
1817 # For known flags, see the documentation of AC_FC_MODULE_FLAG above.
1818 AC_DEFUN([AC_FC_MODULE_OUTPUT_FLAG],[
1819 AC_CACHE_CHECK([Fortran 90 module output flag], [ac_cv_fc_module_output_flag],
1820 [AC_LANG_PUSH([Fortran])
1821 mkdir conftest.dir conftest.dir/sub
1822 cd conftest.dir
1823 ac_cv_fc_module_output_flag=unknown
1824 ac_fc_module_output_flag_FCFLAGS_save=$FCFLAGS
1825 # Flag ordering is significant: put flags late which some compilers use
1826 # for the search path.
1827 for ac_flag in -J '-J ' -fmod= -moddir= +moddir= -qmoddir= '-mdir ' '-mod ' \
1828 '-module ' -M '-Am -M' '-e m -J '; do
1829 FCFLAGS="$ac_fc_module_output_flag_FCFLAGS_save ${ac_flag}sub"
1830 AC_COMPILE_IFELSE([[
1831 module conftest_module
1832 contains
1833 subroutine conftest_routine
1834 write(*,'(a)') 'gotcha!'
1835 end subroutine
1836 end module]],
1837 [cd sub
1838 AC_COMPILE_IFELSE([[
1839 program main
1840 use conftest_module
1841 call conftest_routine
1842 end program]],
1843 [ac_cv_fc_module_output_flag=$ac_flag])
1844 cd ..
1845 AS_IF([test x"$ac_cv_fc_module_output_flag" != xunknown],[break])])
1846 done
1847 FCFLAGS=$ac_fc_module_output_flag_FCFLAGS_save
1848 cd ..
1849 rm -rf conftest.dir
1850 AC_LANG_POP([Fortran])
1851 ])
1852 AS_IF([test x"$ac_cv_fc_module_output_flag" != xunknown],
1853 [FC_MODOUT=$ac_cv_fc_module_output_flag
1854 $1],
1855 [FC_MODOUT=
1856 m4_default([$2],
1857 [AC_MSG_ERROR([unable to find compiler flag to write module information to])])])
1858 AC_SUBST([FC_MODOUT])
1859 # Ensure trailing whitespace is preserved in a Makefile.
1860 AC_SUBST([ac_empty], [""])
1861 AC_CONFIG_COMMANDS_PRE([case $FC_MODOUT in #(
1862 *\ ) FC_MODOUT=$FC_MODOUT'${ac_empty}' ;;
1863 esac])dnl
1864 ])
1867 # _AC_FC_CRAY_POINTERS([ACTION-IF-SUCCESS], [ACTION-IF-FAILURE = FAILURE])
1868 #-------------------------------------------------------------------------
1869 # Try to ensure that the Fortran compiler supports Cray pointers, a
1870 # non-standard extension that provides a C-like pointer in Fortran.
1871 #
1872 # If successful, ACTION-IF-SUCCESS is called. If no argument is provided, then
1873 # any necessary flags are added to F[C]FLAGS. Otherwise, ACTION-IF-FAILURE is
1874 # called, which defaults to failing with an error message.
1875 #
1876 # Most compilers provide an implementation of Cray pointers, and often no
1877 # additional flags are required to enable support. A partial list of compilers
1878 # and flags which may be required are listed below.
1879 #
1880 # The known flags are:
1881 # -fcray-pointer: gfortran
1882 # -Mcray-pointer: PGI
1883 AC_DEFUN([_AC_FC_CRAY_POINTERS], [
1884 AC_MSG_CHECKING([for $[]_AC_FC[] option to support Cray pointers])
1885 AC_CACHE_VAL([ac_cv_[]_AC_LANG_ABBREV[]_cray_ptr], [
1886 ac_cv_[]_AC_LANG_ABBREV[]_cray_ptr='unknown'
1887 ac_save_[]_AC_LANG_PREFIX[]FLAGS=$[]_AC_LANG_PREFIX[]FLAGS
1888 for ac_option in none -fcray-pointer -Mcray=pointer; do
1889 test "$ac_option" != none && _AC_LANG_PREFIX[]FLAGS="$ac_save_[]_AC_LANG_PREFIX[]FLAGS $ac_option"
1890 AC_COMPILE_IFELSE(
1891 [AC_LANG_PROGRAM([], [
1892 integer aptr(2)
1893 pointer (iptr, aptr)
1894 ])],
1895 [ac_cv_[]_AC_LANG_ABBREV[]_cray_ptr=$ac_option],
1896 )
1897 _AC_LANG_PREFIX[]FLAGS=$ac_save_[]_AC_LANG_PREFIX[]FLAGS
1898 AS_IF([test "$ac_cv_[]_AC_LANG_ABBREV[]_cray_ptr" != unknown], [break])
1899 done
1900 ])
1901 AS_CASE([ac_cv_[]_AC_LANG_ABBREV[]_cray_ptr],
1902 [none], [AC_MSG_RESULT([none_needed])],
1903 [unknown], [AC_MSG_RESULT([unsupported])],
1904 [AC_MSG_RESULT([$ac_cv_[]_AC_LANG_ABBREV[]_cray_ptr])]
1905 )
1906 AS_IF([test "$ac_cv_[]_AC_LANG_ABBREV[]_cray_ptr" != unknown], [
1907 m4_default([$1], [
1908 AS_IF([test "$ac_cv_[]_AC_LANG_ABBREV[]_cray_ptr" != none],
1909 [_AC_LANG_PREFIX[]FLAGS="$[]_AC_LANG_PREFIX[]FLAGS $ac_cv_[]_AC_LANG_ABBREV[]_cray_ptr"]
1910 )
1911 ])],
1912 [m4_default([$2], [AC_MSG_ERROR(["$[]_AC_FC[] does not support Cray pointers"])])]
1913 )
1914 ])
1917 # AC_F77_CRAY_POINTERS
1918 #---------------------
1919 AC_DEFUN([AC_F77_CRAY_POINTERS], [
1920 AC_REQUIRE([AC_PROG_F77])
1921 AC_LANG_PUSH([Fortran 77])
1922 _AC_FC_CRAY_POINTERS($@)
1923 AC_LANG_POP([Fortran 77])
1924 ])
1927 # AC_FC_CRAY_POINTERS
1928 #--------------------
1929 AC_DEFUN([AC_FC_CRAY_POINTERS], [
1930 AC_REQUIRE([AC_PROG_FC])
1931 AC_LANG_PUSH([Fortran])
1932 _AC_FC_CRAY_POINTERS($@)
1933 AC_LANG_POP([Fortran])
1934 ])