* ggc.h (empty_string): Delete.
[official-gcc.git] / gcc / fortran / gfortran.texi
blob85afdda46ef05bb86bfa412f1b0986116f6f8c2c
1 \input texinfo  @c -*-texinfo-*-
2 @c %**start of header
3 @setfilename gfortran.info
4 @set copyrights-gfortran 1999-2017
6 @include gcc-common.texi
8 @settitle The GNU Fortran Compiler
10 @c Create a separate index for command line options
11 @defcodeindex op
12 @c Merge the standard indexes into a single one.
13 @syncodeindex fn cp
14 @syncodeindex vr cp
15 @syncodeindex ky cp
16 @syncodeindex pg cp
17 @syncodeindex tp cp
19 @c TODO: The following "Part" definitions are included here temporarily
20 @c until they are incorporated into the official Texinfo distribution.
21 @c They borrow heavily from Texinfo's \unnchapentry definitions.
23 @tex
24 \gdef\part#1#2{%
25   \pchapsepmacro
26   \gdef\thischapter{}
27   \begingroup
28     \vglue\titlepagetopglue
29     \titlefonts \rm
30     \leftline{Part #1:@* #2}
31     \vskip4pt \hrule height 4pt width \hsize \vskip4pt
32   \endgroup
33   \writetocentry{part}{#2}{#1}
35 \gdef\blankpart{%
36   \writetocentry{blankpart}{}{}
38 % Part TOC-entry definition for summary contents.
39 \gdef\dosmallpartentry#1#2#3#4{%
40   \vskip .5\baselineskip plus.2\baselineskip
41   \begingroup
42     \let\rm=\bf \rm
43     \tocentry{Part #2: #1}{\doshortpageno\bgroup#4\egroup}
44   \endgroup
46 \gdef\dosmallblankpartentry#1#2#3#4{%
47   \vskip .5\baselineskip plus.2\baselineskip
49 % Part TOC-entry definition for regular contents.  This has to be
50 % equated to an existing entry to not cause problems when the PDF
51 % outline is created.
52 \gdef\dopartentry#1#2#3#4{%
53   \unnchapentry{Part #2: #1}{}{#3}{#4}
55 \gdef\doblankpartentry#1#2#3#4{}
56 @end tex
58 @c %**end of header
60 @c Use with @@smallbook.
62 @c %** start of document
64 @c Cause even numbered pages to be printed on the left hand side of
65 @c the page and odd numbered pages to be printed on the right hand
66 @c side of the page.  Using this, you can print on both sides of a
67 @c sheet of paper and have the text on the same part of the sheet.
69 @c The text on right hand pages is pushed towards the right hand
70 @c margin and the text on left hand pages is pushed toward the left
71 @c hand margin.
72 @c (To provide the reverse effect, set bindingoffset to -0.75in.)
74 @c @tex
75 @c \global\bindingoffset=0.75in
76 @c \global\normaloffset =0.75in
77 @c @end tex
79 @copying
80 Copyright @copyright{} @value{copyrights-gfortran} Free Software Foundation, Inc.
82 Permission is granted to copy, distribute and/or modify this document
83 under the terms of the GNU Free Documentation License, Version 1.3 or
84 any later version published by the Free Software Foundation; with the
85 Invariant Sections being ``Funding Free Software'', the Front-Cover
86 Texts being (a) (see below), and with the Back-Cover Texts being (b)
87 (see below).  A copy of the license is included in the section entitled
88 ``GNU Free Documentation License''.
90 (a) The FSF's Front-Cover Text is:
92      A GNU Manual
94 (b) The FSF's Back-Cover Text is:
96      You have freedom to copy and modify this GNU Manual, like GNU
97      software.  Copies published by the Free Software Foundation raise
98      funds for GNU development.
99 @end copying
101 @ifinfo
102 @dircategory Software development
103 @direntry
104 * gfortran: (gfortran).                  The GNU Fortran Compiler.
105 @end direntry
106 This file documents the use and the internals of
107 the GNU Fortran compiler, (@command{gfortran}).
109 Published by the Free Software Foundation
110 51 Franklin Street, Fifth Floor
111 Boston, MA 02110-1301 USA
113 @insertcopying
114 @end ifinfo
117 @setchapternewpage odd
118 @titlepage
119 @title Using GNU Fortran
120 @versionsubtitle
121 @author The @t{gfortran} team
122 @page
123 @vskip 0pt plus 1filll
124 Published by the Free Software Foundation@*
125 51 Franklin Street, Fifth Floor@*
126 Boston, MA 02110-1301, USA@*
127 @c Last printed ??ber, 19??.@*
128 @c Printed copies are available for $? each.@*
129 @c ISBN ???
130 @sp 1
131 @insertcopying
132 @end titlepage
134 @c TODO: The following "Part" definitions are included here temporarily
135 @c until they are incorporated into the official Texinfo distribution.
137 @tex
138 \global\let\partentry=\dosmallpartentry
139 \global\let\blankpartentry=\dosmallblankpartentry
140 @end tex
141 @summarycontents
143 @tex
144 \global\let\partentry=\dopartentry
145 \global\let\blankpartentry=\doblankpartentry
146 @end tex
147 @contents
149 @page
151 @c ---------------------------------------------------------------------
152 @c TexInfo table of contents.
153 @c ---------------------------------------------------------------------
155 @ifnottex
156 @node Top
157 @top Introduction
158 @cindex Introduction
160 This manual documents the use of @command{gfortran},
161 the GNU Fortran compiler.  You can find in this manual how to invoke
162 @command{gfortran}, as well as its features and incompatibilities.
164 @ifset DEVELOPMENT
165 @emph{Warning:} This document, and the compiler it describes, are still
166 under development.  While efforts are made to keep it up-to-date, it might
167 not accurately reflect the status of the most recent GNU Fortran compiler.
168 @end ifset
170 @comment
171 @comment  When you add a new menu item, please keep the right hand
172 @comment  aligned to the same column.  Do not use tabs.  This provides
173 @comment  better formatting.
174 @comment
175 @menu
176 * Introduction::
178 Part I: Invoking GNU Fortran
179 * Invoking GNU Fortran:: Command options supported by @command{gfortran}.
180 * Runtime::              Influencing runtime behavior with environment variables.
182 Part II: Language Reference
183 * Fortran 2003 and 2008 status::  Fortran 2003 and 2008 features supported by GNU Fortran.
184 * Compiler Characteristics::      User-visible implementation details.
185 * Extensions::                    Language extensions implemented by GNU Fortran.
186 * Mixed-Language Programming::    Interoperability with C
187 * Coarray Programming::
188 * Intrinsic Procedures:: Intrinsic procedures supported by GNU Fortran.
189 * Intrinsic Modules::    Intrinsic modules supported by GNU Fortran.
191 * Contributing::         How you can help.
192 * Copying::              GNU General Public License says
193                          how you can copy and share GNU Fortran.
194 * GNU Free Documentation License::
195                          How you can copy and share this manual.
196 * Funding::              How to help assure continued work for free software.
197 * Option Index::         Index of command line options
198 * Keyword Index::        Index of concepts
199 @end menu
200 @end ifnottex
202 @c ---------------------------------------------------------------------
203 @c Introduction
204 @c ---------------------------------------------------------------------
206 @node Introduction
207 @chapter Introduction
209 @c The following duplicates the text on the TexInfo table of contents.
210 @iftex
211 This manual documents the use of @command{gfortran}, the GNU Fortran
212 compiler.  You can find in this manual how to invoke @command{gfortran},
213 as well as its features and incompatibilities.
215 @ifset DEVELOPMENT
216 @emph{Warning:} This document, and the compiler it describes, are still
217 under development.  While efforts are made to keep it up-to-date, it
218 might not accurately reflect the status of the most recent GNU Fortran
219 compiler.
220 @end ifset
221 @end iftex
223 The GNU Fortran compiler front end was
224 designed initially as a free replacement for,
225 or alternative to, the Unix @command{f95} command;
226 @command{gfortran} is the command you will use to invoke the compiler.
228 @menu
229 * About GNU Fortran::    What you should know about the GNU Fortran compiler.
230 * GNU Fortran and GCC::  You can compile Fortran, C, or other programs.
231 * Preprocessing and conditional compilation:: The Fortran preprocessor
232 * GNU Fortran and G77::  Why we chose to start from scratch.
233 * Project Status::       Status of GNU Fortran, roadmap, proposed extensions.
234 * Standards::            Standards supported by GNU Fortran.
235 @end menu
238 @c ---------------------------------------------------------------------
239 @c About GNU Fortran
240 @c ---------------------------------------------------------------------
242 @node About GNU Fortran
243 @section About GNU Fortran
245 The GNU Fortran compiler supports the Fortran 77, 90 and 95 standards
246 completely, parts of the Fortran 2003 and Fortran 2008 standards, and
247 several vendor extensions.  The development goal is to provide the
248 following features:
250 @itemize @bullet
251 @item
252 Read a user's program,
253 stored in a file and containing instructions written
254 in Fortran 77, Fortran 90, Fortran 95, Fortran 2003 or Fortran 2008.
255 This file contains @dfn{source code}.
257 @item
258 Translate the user's program into instructions a computer
259 can carry out more quickly than it takes to translate the
260 instructions in the first
261 place.  The result after compilation of a program is
262 @dfn{machine code},
263 code designed to be efficiently translated and processed
264 by a machine such as your computer.
265 Humans usually are not as good writing machine code
266 as they are at writing Fortran (or C++, Ada, or Java),
267 because it is easy to make tiny mistakes writing machine code.
269 @item
270 Provide the user with information about the reasons why
271 the compiler is unable to create a binary from the source code.
272 Usually this will be the case if the source code is flawed.
273 The Fortran 90 standard requires that the compiler can point out
274 mistakes to the user.
275 An incorrect usage of the language causes an @dfn{error message}.
277 The compiler will also attempt to diagnose cases where the
278 user's program contains a correct usage of the language,
279 but instructs the computer to do something questionable.
280 This kind of diagnostics message is called a @dfn{warning message}.
282 @item
283 Provide optional information about the translation passes
284 from the source code to machine code.
285 This can help a user of the compiler to find the cause of
286 certain bugs which may not be obvious in the source code,
287 but may be more easily found at a lower level compiler output.
288 It also helps developers to find bugs in the compiler itself.
290 @item
291 Provide information in the generated machine code that can
292 make it easier to find bugs in the program (using a debugging tool,
293 called a @dfn{debugger}, such as the GNU Debugger @command{gdb}).
295 @item
296 Locate and gather machine code already generated to
297 perform actions requested by statements in the user's program.
298 This machine code is organized into @dfn{modules} and is located
299 and @dfn{linked} to the user program.
300 @end itemize
302 The GNU Fortran compiler consists of several components:
304 @itemize @bullet
305 @item
306 A version of the @command{gcc} command
307 (which also might be installed as the system's @command{cc} command)
308 that also understands and accepts Fortran source code.
309 The @command{gcc} command is the @dfn{driver} program for
310 all the languages in the GNU Compiler Collection (GCC);
311 With @command{gcc},
312 you can compile the source code of any language for
313 which a front end is available in GCC.
315 @item
316 The @command{gfortran} command itself,
317 which also might be installed as the
318 system's @command{f95} command.
319 @command{gfortran} is just another driver program,
320 but specifically for the Fortran compiler only.
321 The difference with @command{gcc} is that @command{gfortran}
322 will automatically link the correct libraries to your program.
324 @item
325 A collection of run-time libraries.
326 These libraries contain the machine code needed to support
327 capabilities of the Fortran language that are not directly
328 provided by the machine code generated by the
329 @command{gfortran} compilation phase,
330 such as intrinsic functions and subroutines,
331 and routines for interaction with files and the operating system.
332 @c and mechanisms to spawn,
333 @c unleash and pause threads in parallelized code.
335 @item
336 The Fortran compiler itself, (@command{f951}).
337 This is the GNU Fortran parser and code generator,
338 linked to and interfaced with the GCC backend library.
339 @command{f951} ``translates'' the source code to
340 assembler code.  You would typically not use this
341 program directly;
342 instead, the @command{gcc} or @command{gfortran} driver
343 programs will call it for you.
344 @end itemize
347 @c ---------------------------------------------------------------------
348 @c GNU Fortran and GCC
349 @c ---------------------------------------------------------------------
351 @node GNU Fortran and GCC
352 @section GNU Fortran and GCC
353 @cindex GNU Compiler Collection
354 @cindex GCC
356 GNU Fortran is a part of GCC, the @dfn{GNU Compiler Collection}.  GCC
357 consists of a collection of front ends for various languages, which
358 translate the source code into a language-independent form called
359 @dfn{GENERIC}.  This is then processed by a common middle end which
360 provides optimization, and then passed to one of a collection of back
361 ends which generate code for different computer architectures and
362 operating systems.
364 Functionally, this is implemented with a driver program (@command{gcc})
365 which provides the command-line interface for the compiler.  It calls
366 the relevant compiler front-end program (e.g., @command{f951} for
367 Fortran) for each file in the source code, and then calls the assembler
368 and linker as appropriate to produce the compiled output.  In a copy of
369 GCC which has been compiled with Fortran language support enabled,
370 @command{gcc} will recognize files with @file{.f}, @file{.for}, @file{.ftn},
371 @file{.f90}, @file{.f95}, @file{.f03} and @file{.f08} extensions as
372 Fortran source code, and compile it accordingly.  A @command{gfortran}
373 driver program is also provided, which is identical to @command{gcc}
374 except that it automatically links the Fortran runtime libraries into the
375 compiled program.
377 Source files with @file{.f}, @file{.for}, @file{.fpp}, @file{.ftn}, @file{.F},
378 @file{.FOR}, @file{.FPP}, and @file{.FTN} extensions are treated as fixed form.
379 Source files with @file{.f90}, @file{.f95}, @file{.f03}, @file{.f08},
380 @file{.F90}, @file{.F95}, @file{.F03} and @file{.F08} extensions are
381 treated as free form.  The capitalized versions of either form are run
382 through preprocessing.  Source files with the lower case @file{.fpp}
383 extension are also run through preprocessing.
385 This manual specifically documents the Fortran front end, which handles
386 the programming language's syntax and semantics.  The aspects of GCC
387 which relate to the optimization passes and the back-end code generation
388 are documented in the GCC manual; see 
389 @ref{Top,,Introduction,gcc,Using the GNU Compiler Collection (GCC)}.
390 The two manuals together provide a complete reference for the GNU
391 Fortran compiler.
394 @c ---------------------------------------------------------------------
395 @c Preprocessing and conditional compilation
396 @c ---------------------------------------------------------------------
398 @node Preprocessing and conditional compilation
399 @section Preprocessing and conditional compilation
400 @cindex CPP
401 @cindex FPP
402 @cindex Conditional compilation
403 @cindex Preprocessing
404 @cindex preprocessor, include file handling
406 Many Fortran compilers including GNU Fortran allow passing the source code
407 through a C preprocessor (CPP; sometimes also called the Fortran preprocessor,
408 FPP) to allow for conditional compilation.  In the case of GNU Fortran,
409 this is the GNU C Preprocessor in the traditional mode.  On systems with
410 case-preserving file names, the preprocessor is automatically invoked if the
411 filename extension is @file{.F}, @file{.FOR}, @file{.FTN}, @file{.fpp},
412 @file{.FPP}, @file{.F90}, @file{.F95}, @file{.F03} or @file{.F08}.  To manually
413 invoke the preprocessor on any file, use @option{-cpp}, to disable
414 preprocessing on files where the preprocessor is run automatically, use
415 @option{-nocpp}.
417 If a preprocessed file includes another file with the Fortran @code{INCLUDE}
418 statement, the included file is not preprocessed.  To preprocess included
419 files, use the equivalent preprocessor statement @code{#include}.
421 If GNU Fortran invokes the preprocessor, @code{__GFORTRAN__}
422 is defined and @code{__GNUC__}, @code{__GNUC_MINOR__} and
423 @code{__GNUC_PATCHLEVEL__} can be used to determine the version of the
424 compiler.  See @ref{Top,,Overview,cpp,The C Preprocessor} for details.
426 While CPP is the de-facto standard for preprocessing Fortran code,
427 Part 3 of the Fortran 95 standard (ISO/IEC 1539-3:1998) defines
428 Conditional Compilation, which is not widely used and not directly
429 supported by the GNU Fortran compiler.  You can use the program coco
430 to preprocess such files (@uref{http://www.daniellnagle.com/coco.html}).
433 @c ---------------------------------------------------------------------
434 @c GNU Fortran and G77
435 @c ---------------------------------------------------------------------
437 @node GNU Fortran and G77
438 @section GNU Fortran and G77
439 @cindex Fortran 77
440 @cindex @command{g77}
442 The GNU Fortran compiler is the successor to @command{g77}, the Fortran 
443 77 front end included in GCC prior to version 4.  It is an entirely new 
444 program that has been designed to provide Fortran 95 support and 
445 extensibility for future Fortran language standards, as well as providing 
446 backwards compatibility for Fortran 77 and nearly all of the GNU language 
447 extensions supported by @command{g77}.
450 @c ---------------------------------------------------------------------
451 @c Project Status
452 @c ---------------------------------------------------------------------
454 @node Project Status
455 @section Project Status
457 @quotation
458 As soon as @command{gfortran} can parse all of the statements correctly,
459 it will be in the ``larva'' state.
460 When we generate code, the ``puppa'' state.
461 When @command{gfortran} is done,
462 we'll see if it will be a beautiful butterfly,
463 or just a big bug....
465 --Andy Vaught, April 2000
466 @end quotation
468 The start of the GNU Fortran 95 project was announced on
469 the GCC homepage in March 18, 2000
470 (even though Andy had already been working on it for a while,
471 of course).
473 The GNU Fortran compiler is able to compile nearly all
474 standard-compliant Fortran 95, Fortran 90, and Fortran 77 programs,
475 including a number of standard and non-standard extensions, and can be
476 used on real-world programs.  In particular, the supported extensions
477 include OpenMP, Cray-style pointers, some old vendor extensions, and several
478 Fortran 2003 and Fortran 2008 features, including TR 15581.  However, it is
479 still under development and has a few remaining rough edges.
480 There also is initial support for OpenACC.
481 Note that this is an experimental feature, incomplete, and subject to
482 change in future versions of GCC.  See
483 @uref{https://gcc.gnu.org/wiki/OpenACC} for more information.
485 At present, the GNU Fortran compiler passes the
486 @uref{http://www.fortran-2000.com/ArnaudRecipes/fcvs21_f95.html, 
487 NIST Fortran 77 Test Suite}, and produces acceptable results on the
488 @uref{http://www.netlib.org/lapack/faq.html#1.21, LAPACK Test Suite}.
489 It also provides respectable performance on 
490 the @uref{http://www.polyhedron.com/fortran-compiler-comparisons/polyhedron-benchmark-suite,
491 Polyhedron Fortran
492 compiler benchmarks} and the
493 @uref{http://www.netlib.org/benchmark/livermore,
494 Livermore Fortran Kernels test}.  It has been used to compile a number of
495 large real-world programs, including
496 @uref{http://hirlam.org/, the HARMONIE and HIRLAM weather forecasting code} and
497 @uref{http://physical-chemistry.scb.uwa.edu.au/tonto/wiki/index.php/Main_Page,
498 the Tonto quantum chemistry package}; see
499 @url{https://gcc.gnu.org/@/wiki/@/GfortranApps} for an extended list.
501 Among other things, the GNU Fortran compiler is intended as a replacement
502 for G77.  At this point, nearly all programs that could be compiled with
503 G77 can be compiled with GNU Fortran, although there are a few minor known
504 regressions.
506 The primary work remaining to be done on GNU Fortran falls into three
507 categories: bug fixing (primarily regarding the treatment of invalid code
508 and providing useful error messages), improving the compiler optimizations
509 and the performance of compiled code, and extending the compiler to support
510 future standards---in particular, Fortran 2003 and Fortran 2008.
513 @c ---------------------------------------------------------------------
514 @c Standards
515 @c ---------------------------------------------------------------------
517 @node Standards
518 @section Standards
519 @cindex Standards
521 @menu
522 * Varying Length Character Strings::
523 @end menu
525 The GNU Fortran compiler implements
526 ISO/IEC 1539:1997 (Fortran 95).  As such, it can also compile essentially all
527 standard-compliant Fortran 90 and Fortran 77 programs.   It also supports
528 the ISO/IEC TR-15581 enhancements to allocatable arrays.
530 GNU Fortran also have a partial support for ISO/IEC 1539-1:2004 (Fortran
531 2003), ISO/IEC 1539-1:2010 (Fortran 2008), the Technical Specification
532 @code{Further Interoperability of Fortran with C} (ISO/IEC TS 29113:2012).
533 Full support of those standards and future Fortran standards is planned.
534 The current status of the support is can be found in the
535 @ref{Fortran 2003 status}, @ref{Fortran 2008 status}, @ref{TS 29113 status}
536 and @ref{TS 18508 status} sections of the documentation.
538 Additionally, the GNU Fortran compilers supports the OpenMP specification
539 (version 4.0 and most of the features of the 4.5 version,
540 @url{http://openmp.org/@/wp/@/openmp-specifications/}).
541 There also is initial support for the OpenACC specification (targeting
542 version 2.0, @uref{http://www.openacc.org/}).
543 Note that this is an experimental feature, incomplete, and subject to
544 change in future versions of GCC.  See
545 @uref{https://gcc.gnu.org/wiki/OpenACC} for more information.
547 @node Varying Length Character Strings
548 @subsection Varying Length Character Strings
549 @cindex Varying length character strings
550 @cindex Varying length strings
551 @cindex strings, varying length
553 The Fortran 95 standard specifies in Part 2 (ISO/IEC 1539-2:2000)
554 varying length character strings.  While GNU Fortran currently does not
555 support such strings directly, there exist two Fortran implementations
556 for them, which work with GNU Fortran.  They can be found at
557 @uref{http://www.fortran.com/@/iso_varying_string.f95} and at
558 @uref{ftp://ftp.nag.co.uk/@/sc22wg5/@/ISO_VARYING_STRING/}.
560 Deferred-length character strings of Fortran 2003 supports part of
561 the features of @code{ISO_VARYING_STRING} and should be considered as
562 replacement. (Namely, allocatable or pointers of the type
563 @code{character(len=:)}.)
566 @c =====================================================================
567 @c PART I: INVOCATION REFERENCE
568 @c =====================================================================
570 @tex
571 \part{I}{Invoking GNU Fortran}
572 @end tex
574 @c ---------------------------------------------------------------------
575 @c Compiler Options
576 @c ---------------------------------------------------------------------
578 @include invoke.texi
581 @c ---------------------------------------------------------------------
582 @c Runtime
583 @c ---------------------------------------------------------------------
585 @node Runtime
586 @chapter Runtime:  Influencing runtime behavior with environment variables
587 @cindex environment variable
589 The behavior of the @command{gfortran} can be influenced by
590 environment variables.
592 Malformed environment variables are silently ignored.
594 @menu
595 * TMPDIR:: Directory for scratch files
596 * GFORTRAN_STDIN_UNIT:: Unit number for standard input
597 * GFORTRAN_STDOUT_UNIT:: Unit number for standard output
598 * GFORTRAN_STDERR_UNIT:: Unit number for standard error
599 * GFORTRAN_UNBUFFERED_ALL:: Do not buffer I/O for all units.
600 * GFORTRAN_UNBUFFERED_PRECONNECTED:: Do not buffer I/O for preconnected units.
601 * GFORTRAN_SHOW_LOCUS::  Show location for runtime errors
602 * GFORTRAN_OPTIONAL_PLUS:: Print leading + where permitted
603 * GFORTRAN_DEFAULT_RECL:: Default record length for new files
604 * GFORTRAN_LIST_SEPARATOR::  Separator for list output
605 * GFORTRAN_CONVERT_UNIT::  Set endianness for unformatted I/O
606 * GFORTRAN_ERROR_BACKTRACE:: Show backtrace on run-time errors
607 @end menu
609 @node TMPDIR
610 @section @env{TMPDIR}---Directory for scratch files
612 When opening a file with @code{STATUS='SCRATCH'}, GNU Fortran tries to
613 create the file in one of the potential directories by testing each
614 directory in the order below.
616 @enumerate
617 @item
618 The environment variable @env{TMPDIR}, if it exists.
620 @item
621 On the MinGW target, the directory returned by the @code{GetTempPath}
622 function. Alternatively, on the Cygwin target, the @env{TMP} and
623 @env{TEMP} environment variables, if they exist, in that order.
625 @item
626 The @code{P_tmpdir} macro if it is defined, otherwise the directory
627 @file{/tmp}.
628 @end enumerate
630 @node GFORTRAN_STDIN_UNIT
631 @section @env{GFORTRAN_STDIN_UNIT}---Unit number for standard input
633 This environment variable can be used to select the unit number
634 preconnected to standard input.  This must be a positive integer.
635 The default value is 5.
637 @node GFORTRAN_STDOUT_UNIT
638 @section @env{GFORTRAN_STDOUT_UNIT}---Unit number for standard output
640 This environment variable can be used to select the unit number
641 preconnected to standard output.  This must be a positive integer.
642 The default value is 6.
644 @node GFORTRAN_STDERR_UNIT
645 @section @env{GFORTRAN_STDERR_UNIT}---Unit number for standard error
647 This environment variable can be used to select the unit number
648 preconnected to standard error.  This must be a positive integer.
649 The default value is 0.
651 @node GFORTRAN_UNBUFFERED_ALL
652 @section @env{GFORTRAN_UNBUFFERED_ALL}---Do not buffer I/O on all units
654 This environment variable controls whether all I/O is unbuffered.  If
655 the first letter is @samp{y}, @samp{Y} or @samp{1}, all I/O is
656 unbuffered.  This will slow down small sequential reads and writes.  If
657 the first letter is @samp{n}, @samp{N} or @samp{0}, I/O is buffered.
658 This is the default.
660 @node GFORTRAN_UNBUFFERED_PRECONNECTED
661 @section @env{GFORTRAN_UNBUFFERED_PRECONNECTED}---Do not buffer I/O on preconnected units
663 The environment variable named @env{GFORTRAN_UNBUFFERED_PRECONNECTED} controls
664 whether I/O on a preconnected unit (i.e.@: STDOUT or STDERR) is unbuffered.  If 
665 the first letter is @samp{y}, @samp{Y} or @samp{1}, I/O is unbuffered.  This
666 will slow down small sequential reads and writes.  If the first letter
667 is @samp{n}, @samp{N} or @samp{0}, I/O is buffered.  This is the default.
669 @node GFORTRAN_SHOW_LOCUS
670 @section @env{GFORTRAN_SHOW_LOCUS}---Show location for runtime errors
672 If the first letter is @samp{y}, @samp{Y} or @samp{1}, filename and
673 line numbers for runtime errors are printed.  If the first letter is
674 @samp{n}, @samp{N} or @samp{0}, do not print filename and line numbers
675 for runtime errors.  The default is to print the location.
677 @node GFORTRAN_OPTIONAL_PLUS
678 @section @env{GFORTRAN_OPTIONAL_PLUS}---Print leading + where permitted
680 If the first letter is @samp{y}, @samp{Y} or @samp{1},
681 a plus sign is printed
682 where permitted by the Fortran standard.  If the first letter
683 is @samp{n}, @samp{N} or @samp{0}, a plus sign is not printed
684 in most cases.  Default is not to print plus signs.
686 @node GFORTRAN_DEFAULT_RECL
687 @section @env{GFORTRAN_DEFAULT_RECL}---Default record length for new files
689 This environment variable specifies the default record length, in
690 bytes, for files which are opened without a @code{RECL} tag in the
691 @code{OPEN} statement.  This must be a positive integer.  The
692 default value is 1073741824 bytes (1 GB).
694 @node GFORTRAN_LIST_SEPARATOR
695 @section @env{GFORTRAN_LIST_SEPARATOR}---Separator for list output
697 This environment variable specifies the separator when writing
698 list-directed output.  It may contain any number of spaces and
699 at most one comma.  If you specify this on the command line,
700 be sure to quote spaces, as in
701 @smallexample
702 $ GFORTRAN_LIST_SEPARATOR='  ,  ' ./a.out
703 @end smallexample
704 when @command{a.out} is the compiled Fortran program that you want to run.
705 Default is a single space.
707 @node GFORTRAN_CONVERT_UNIT
708 @section @env{GFORTRAN_CONVERT_UNIT}---Set endianness for unformatted I/O
710 By setting the @env{GFORTRAN_CONVERT_UNIT} variable, it is possible
711 to change the representation of data for unformatted files.
712 The syntax for the @env{GFORTRAN_CONVERT_UNIT} variable is:
713 @smallexample
714 GFORTRAN_CONVERT_UNIT: mode | mode ';' exception | exception ;
715 mode: 'native' | 'swap' | 'big_endian' | 'little_endian' ;
716 exception: mode ':' unit_list | unit_list ;
717 unit_list: unit_spec | unit_list unit_spec ;
718 unit_spec: INTEGER | INTEGER '-' INTEGER ;
719 @end smallexample
720 The variable consists of an optional default mode, followed by
721 a list of optional exceptions, which are separated by semicolons
722 from the preceding default and each other.  Each exception consists
723 of a format and a comma-separated list of units.  Valid values for
724 the modes are the same as for the @code{CONVERT} specifier:
726 @itemize @w{}
727 @item @code{NATIVE} Use the native format.  This is the default.
728 @item @code{SWAP} Swap between little- and big-endian.
729 @item @code{LITTLE_ENDIAN} Use the little-endian format
730 for unformatted files.
731 @item @code{BIG_ENDIAN} Use the big-endian format for unformatted files.
732 @end itemize
733 A missing mode for an exception is taken to mean @code{BIG_ENDIAN}.
734 Examples of values for @env{GFORTRAN_CONVERT_UNIT} are:
735 @itemize @w{}
736 @item @code{'big_endian'}  Do all unformatted I/O in big_endian mode.
737 @item @code{'little_endian;native:10-20,25'}  Do all unformatted I/O 
738 in little_endian mode, except for units 10 to 20 and 25, which are in
739 native format.
740 @item @code{'10-20'}  Units 10 to 20 are big-endian, the rest is native.
741 @end itemize
743 Setting the environment variables should be done on the command
744 line or via the @command{export}
745 command for @command{sh}-compatible shells and via @command{setenv}
746 for @command{csh}-compatible shells.
748 Example for @command{sh}:
749 @smallexample
750 $ gfortran foo.f90
751 $ GFORTRAN_CONVERT_UNIT='big_endian;native:10-20' ./a.out
752 @end smallexample
754 Example code for @command{csh}:
755 @smallexample
756 % gfortran foo.f90
757 % setenv GFORTRAN_CONVERT_UNIT 'big_endian;native:10-20'
758 % ./a.out
759 @end smallexample
761 Using anything but the native representation for unformatted data
762 carries a significant speed overhead.  If speed in this area matters
763 to you, it is best if you use this only for data that needs to be
764 portable.
766 @xref{CONVERT specifier}, for an alternative way to specify the
767 data representation for unformatted files.  @xref{Runtime Options}, for
768 setting a default data representation for the whole program.  The
769 @code{CONVERT} specifier overrides the @option{-fconvert} compile options.
771 @emph{Note that the values specified via the GFORTRAN_CONVERT_UNIT
772 environment variable will override the CONVERT specifier in the
773 open statement}.  This is to give control over data formats to
774 users who do not have the source code of their program available.
776 @node GFORTRAN_ERROR_BACKTRACE
777 @section @env{GFORTRAN_ERROR_BACKTRACE}---Show backtrace on run-time errors
779 If the @env{GFORTRAN_ERROR_BACKTRACE} variable is set to @samp{y},
780 @samp{Y} or @samp{1} (only the first letter is relevant) then a
781 backtrace is printed when a serious run-time error occurs.  To disable
782 the backtracing, set the variable to @samp{n}, @samp{N}, @samp{0}.
783 Default is to print a backtrace unless the @option{-fno-backtrace}
784 compile option was used.
786 @c =====================================================================
787 @c PART II: LANGUAGE REFERENCE
788 @c =====================================================================
790 @tex
791 \part{II}{Language Reference}
792 @end tex
794 @c ---------------------------------------------------------------------
795 @c Fortran 2003 and 2008 Status
796 @c ---------------------------------------------------------------------
798 @node Fortran 2003 and 2008 status
799 @chapter Fortran 2003 and 2008 Status
801 @menu
802 * Fortran 2003 status::
803 * Fortran 2008 status::
804 * TS 29113 status::
805 * TS 18508 status::
806 @end menu
808 @node Fortran 2003 status
809 @section Fortran 2003 status
811 GNU Fortran supports several Fortran 2003 features; an incomplete
812 list can be found below.  See also the
813 @uref{https://gcc.gnu.org/wiki/Fortran2003, wiki page} about Fortran 2003.
815 @itemize
816 @item Procedure pointers including procedure-pointer components with
817 @code{PASS} attribute.
819 @item Procedures which are bound to a derived type (type-bound procedures)
820 including @code{PASS}, @code{PROCEDURE} and @code{GENERIC}, and
821 operators bound to a type.
823 @item Abstract interfaces and type extension with the possibility to
824 override type-bound procedures or to have deferred binding.
826 @item Polymorphic entities (``@code{CLASS}'') for derived types and unlimited
827 polymorphism (``@code{CLASS(*)}'') -- including @code{SAME_TYPE_AS},
828 @code{EXTENDS_TYPE_OF} and @code{SELECT TYPE} for scalars and arrays and
829 finalization.
831 @item Generic interface names, which have the same name as derived types,
832 are now supported. This allows one to write constructor functions.  Note
833 that Fortran does not support static constructor functions.  For static
834 variables, only default initialization or structure-constructor
835 initialization are available.
837 @item The @code{ASSOCIATE} construct.
839 @item Interoperability with C including enumerations, 
841 @item In structure constructors the components with default values may be
842 omitted.
844 @item Extensions to the @code{ALLOCATE} statement, allowing for a
845 type-specification with type parameter and for allocation and initialization
846 from a @code{SOURCE=} expression; @code{ALLOCATE} and @code{DEALLOCATE}
847 optionally return an error message string via @code{ERRMSG=}.
849 @item Reallocation on assignment: If an intrinsic assignment is
850 used, an allocatable variable on the left-hand side is automatically allocated
851 (if unallocated) or reallocated (if the shape is different). Currently, scalar
852 deferred character length left-hand sides are correctly handled but arrays
853 are not yet fully implemented.
855 @item Deferred-length character variables and scalar deferred-length character
856 components of derived types are supported. (Note that array-valued compoents
857 are not yet implemented.)
859 @item Transferring of allocations via @code{MOVE_ALLOC}.
861 @item The @code{PRIVATE} and @code{PUBLIC} attributes may be given individually
862 to derived-type components.
864 @item In pointer assignments, the lower bound may be specified and
865 the remapping of elements is supported.
867 @item For pointers an @code{INTENT} may be specified which affect the
868 association status not the value of the pointer target.
870 @item Intrinsics @code{command_argument_count}, @code{get_command},
871 @code{get_command_argument}, and @code{get_environment_variable}.
873 @item Support for Unicode characters (ISO 10646) and UTF-8, including
874 the @code{SELECTED_CHAR_KIND} and @code{NEW_LINE} intrinsic functions.
876 @item Support for binary, octal and hexadecimal (BOZ) constants in the
877 intrinsic functions @code{INT}, @code{REAL}, @code{CMPLX} and @code{DBLE}.
879 @item Support for namelist variables with allocatable and pointer
880 attribute and nonconstant length type parameter.
882 @item
883 @cindex array, constructors
884 @cindex @code{[...]}
885 Array constructors using square brackets.  That is, @code{[...]} rather
886 than @code{(/.../)}.  Type-specification for array constructors like
887 @code{(/ some-type :: ... /)}.
889 @item Extensions to the specification and initialization expressions,
890 including the support for intrinsics with real and complex arguments.
892 @item Support for the asynchronous input/output syntax; however, the
893 data transfer is currently always synchronously performed. 
895 @item
896 @cindex @code{FLUSH} statement
897 @cindex statement, @code{FLUSH}
898 @code{FLUSH} statement.
900 @item
901 @cindex @code{IOMSG=} specifier
902 @code{IOMSG=} specifier for I/O statements.
904 @item
905 @cindex @code{ENUM} statement
906 @cindex @code{ENUMERATOR} statement
907 @cindex statement, @code{ENUM}
908 @cindex statement, @code{ENUMERATOR}
909 @opindex @code{fshort-enums}
910 Support for the declaration of enumeration constants via the
911 @code{ENUM} and @code{ENUMERATOR} statements.  Interoperability with
912 @command{gcc} is guaranteed also for the case where the
913 @command{-fshort-enums} command line option is given.
915 @item
916 @cindex TR 15581
917 TR 15581:
918 @itemize
919 @item
920 @cindex @code{ALLOCATABLE} dummy arguments
921 @code{ALLOCATABLE} dummy arguments.
922 @item
923 @cindex @code{ALLOCATABLE} function results
924 @code{ALLOCATABLE} function results
925 @item
926 @cindex @code{ALLOCATABLE} components of derived types
927 @code{ALLOCATABLE} components of derived types
928 @end itemize
930 @item
931 @cindex @code{STREAM} I/O
932 @cindex @code{ACCESS='STREAM'} I/O
933 The @code{OPEN} statement supports the @code{ACCESS='STREAM'} specifier,
934 allowing I/O without any record structure.
936 @item
937 Namelist input/output for internal files.
939 @item Minor I/O features: Rounding during formatted output, using of
940 a decimal comma instead of a decimal point, setting whether a plus sign
941 should appear for positive numbers. On systems where @code{strtod} honours
942 the rounding mode, the rounding mode is also supported for input.
944 @item
945 @cindex @code{PROTECTED} statement
946 @cindex statement, @code{PROTECTED}
947 The @code{PROTECTED} statement and attribute.
949 @item
950 @cindex @code{VALUE} statement
951 @cindex statement, @code{VALUE}
952 The @code{VALUE} statement and attribute.
954 @item
955 @cindex @code{VOLATILE} statement
956 @cindex statement, @code{VOLATILE}
957 The @code{VOLATILE} statement and attribute.
959 @item
960 @cindex @code{IMPORT} statement
961 @cindex statement, @code{IMPORT}
962 The @code{IMPORT} statement, allowing to import
963 host-associated derived types.
965 @item The intrinsic modules @code{ISO_FORTRAN_ENVIRONMENT} is supported,
966 which contains parameters of the I/O units, storage sizes. Additionally,
967 procedures for C interoperability are available in the @code{ISO_C_BINDING}
968 module.
970 @item
971 @cindex @code{USE, INTRINSIC} statement
972 @cindex statement, @code{USE, INTRINSIC}
973 @cindex @code{ISO_FORTRAN_ENV} statement
974 @cindex statement, @code{ISO_FORTRAN_ENV}
975 @code{USE} statement with @code{INTRINSIC} and @code{NON_INTRINSIC}
976 attribute; supported intrinsic modules: @code{ISO_FORTRAN_ENV},
977 @code{ISO_C_BINDING}, @code{OMP_LIB} and @code{OMP_LIB_KINDS},
978 and @code{OPENACC}.
980 @item
981 Renaming of operators in the @code{USE} statement.
983 @end itemize
986 @node Fortran 2008 status
987 @section Fortran 2008 status
989 The latest version of the Fortran standard is ISO/IEC 1539-1:2010, informally
990 known as Fortran 2008.  The official version is available from International
991 Organization for Standardization (ISO) or its national member organizations.
992 The the final draft (FDIS) can be downloaded free of charge from
993 @url{http://www.nag.co.uk/@/sc22wg5/@/links.html}.  Fortran is developed by the
994 Working Group 5 of Sub-Committee 22 of the Joint Technical Committee 1 of the
995 International Organization for Standardization and the International
996 Electrotechnical Commission (IEC).  This group is known as
997 @uref{http://www.nag.co.uk/sc22wg5/, WG5}.
999 The GNU Fortran compiler supports several of the new features of Fortran 2008;
1000 the @uref{https://gcc.gnu.org/wiki/Fortran2008Status, wiki} has some information
1001 about the current Fortran 2008 implementation status.  In particular, the
1002 following is implemented.
1004 @itemize
1005 @item The @option{-std=f2008} option and support for the file extensions 
1006 @file{.f08} and @file{.F08}.
1008 @item The @code{OPEN} statement now supports the @code{NEWUNIT=} option,
1009 which returns a unique file unit, thus preventing inadvertent use of the
1010 same unit in different parts of the program.
1012 @item The @code{g0} format descriptor and unlimited format items.
1014 @item The mathematical intrinsics @code{ASINH}, @code{ACOSH}, @code{ATANH},
1015 @code{ERF}, @code{ERFC}, @code{GAMMA}, @code{LOG_GAMMA}, @code{BESSEL_J0},
1016 @code{BESSEL_J1}, @code{BESSEL_JN}, @code{BESSEL_Y0}, @code{BESSEL_Y1},
1017 @code{BESSEL_YN}, @code{HYPOT}, @code{NORM2}, and @code{ERFC_SCALED}.
1019 @item Using complex arguments with @code{TAN}, @code{SINH}, @code{COSH},
1020 @code{TANH}, @code{ASIN}, @code{ACOS}, and @code{ATAN} is now possible;
1021 @code{ATAN}(@var{Y},@var{X}) is now an alias for @code{ATAN2}(@var{Y},@var{X}).
1023 @item Support of the @code{PARITY} intrinsic functions.
1025 @item The following bit intrinsics: @code{LEADZ} and @code{TRAILZ} for
1026 counting the number of leading and trailing zero bits, @code{POPCNT} and
1027 @code{POPPAR} for counting the number of one bits and returning the parity;
1028 @code{BGE}, @code{BGT}, @code{BLE}, and @code{BLT} for bitwise comparisons;
1029 @code{DSHIFTL} and @code{DSHIFTR} for combined left and right shifts,
1030 @code{MASKL} and @code{MASKR} for simple left and right justified masks,
1031 @code{MERGE_BITS} for a bitwise merge using a mask, @code{SHIFTA},
1032 @code{SHIFTL} and @code{SHIFTR} for shift operations, and the
1033 transformational bit intrinsics @code{IALL}, @code{IANY} and @code{IPARITY}.
1035 @item Support of the @code{EXECUTE_COMMAND_LINE} intrinsic subroutine.
1037 @item Support for the @code{STORAGE_SIZE} intrinsic inquiry function.
1039 @item The @code{INT@{8,16,32@}} and @code{REAL@{32,64,128@}} kind type
1040 parameters and the array-valued named constants @code{INTEGER_KINDS},
1041 @code{LOGICAL_KINDS}, @code{REAL_KINDS} and @code{CHARACTER_KINDS} of
1042 the intrinsic module @code{ISO_FORTRAN_ENV}.
1044 @item The module procedures @code{C_SIZEOF} of the intrinsic module
1045 @code{ISO_C_BINDINGS} and @code{COMPILER_VERSION} and @code{COMPILER_OPTIONS}
1046 of @code{ISO_FORTRAN_ENV}.
1048 @item Coarray support for serial programs with @option{-fcoarray=single} flag
1049 and experimental support for multiple images with the @option{-fcoarray=lib}
1050 flag.
1052 @item Submodules are supported. It should noted that @code{MODULEs} do not
1053 produce the smod file needed by the descendent @code{SUBMODULEs} unless they
1054 contain at least one @code{MODULE PROCEDURE} interface. The reason for this is
1055 that @code{SUBMODULEs} are useless without @code{MODULE PROCEDUREs}. See
1056 http://j3-fortran.org/doc/meeting/207/15-209.txt for a discussion and a draft
1057 interpretation. Adopting this interpretation has the advantage that code that
1058 does not use submodules does not generate smod files.
1060 @item The @code{DO CONCURRENT} construct is supported.
1062 @item The @code{BLOCK} construct is supported.
1064 @item The @code{STOP} and the new @code{ERROR STOP} statements now
1065 support all constant expressions. Both show the signals which were signaling
1066 at termination.
1068 @item Support for the @code{CONTIGUOUS} attribute.
1070 @item Support for @code{ALLOCATE} with @code{MOLD}.
1072 @item Support for the @code{IMPURE} attribute for procedures, which
1073 allows for @code{ELEMENTAL} procedures without the restrictions of
1074 @code{PURE}.
1076 @item Null pointers (including @code{NULL()}) and not-allocated variables
1077 can be used as actual argument to optional non-pointer, non-allocatable
1078 dummy arguments, denoting an absent argument.
1080 @item Non-pointer variables with @code{TARGET} attribute can be used as
1081 actual argument to @code{POINTER} dummies with @code{INTENT(IN)}.
1083 @item Pointers including procedure pointers and those in a derived
1084 type (pointer components) can now be initialized by a target instead
1085 of only by @code{NULL}.
1087 @item The @code{EXIT} statement (with construct-name) can be now be
1088 used to leave not only the @code{DO} but also the @code{ASSOCIATE},
1089 @code{BLOCK}, @code{IF}, @code{SELECT CASE} and @code{SELECT TYPE}
1090 constructs.
1092 @item Internal procedures can now be used as actual argument.
1094 @item Minor features: obsolesce diagnostics for @code{ENTRY} with
1095 @option{-std=f2008}; a line may start with a semicolon; for internal
1096 and module procedures @code{END} can be used instead of
1097 @code{END SUBROUTINE} and @code{END FUNCTION}; @code{SELECTED_REAL_KIND}
1098 now also takes a @code{RADIX} argument; intrinsic types are supported
1099 for @code{TYPE}(@var{intrinsic-type-spec}); multiple type-bound procedures
1100 can be declared in a single @code{PROCEDURE} statement; implied-shape
1101 arrays are supported for named constants (@code{PARAMETER}).
1102 @end itemize
1106 @node TS 29113 status
1107 @section Technical Specification 29113 Status
1109 GNU Fortran supports some of the new features of the Technical
1110 Specification (TS) 29113 on Further Interoperability of Fortran with C.
1111 The @uref{https://gcc.gnu.org/wiki/TS29113Status, wiki} has some information
1112 about the current TS 29113 implementation status.  In particular, the
1113 following is implemented.
1115 See also @ref{Further Interoperability of Fortran with C}.
1117 @itemize
1118 @item The @option{-std=f2008ts} option.
1120 @item The @code{OPTIONAL} attribute is allowed for dummy arguments
1121 of @code{BIND(C) procedures.}
1123 @item The @code{RANK} intrinsic is supported.
1125 @item GNU Fortran's implementation for variables with @code{ASYNCHRONOUS}
1126 attribute is compatible with TS 29113.
1128 @item Assumed types (@code{TYPE(*)}).
1130 @item Assumed-rank (@code{DIMENSION(..)}). However, the array descriptor
1131 of the TS is not yet supported.
1132 @end itemize
1135 @node TS 18508 status
1136 @section Technical Specification 18508 Status
1138 GNU Fortran supports the following new features of the Technical
1139 Specification 18508 on Additional Parallel Features in Fortran:
1141 @itemize
1142 @item The new atomic ADD, CAS, FETCH and ADD/OR/XOR, OR and XOR intrinsics.
1144 @item The @code{CO_MIN} and @code{CO_MAX} and @code{SUM} reduction intrinsics.
1145 And the @code{CO_BROADCAST} and @code{CO_REDUCE} intrinsic, except that those
1146 do not support polymorphic types or types with allocatable, pointer or
1147 polymorphic components.
1149 @item Events (@code{EVENT POST}, @code{EVENT WAIT}, @code{EVENT_QUERY})
1151 @item Failed images (@code{FAIL IMAGE}, @code{IMAGE_STATUS},
1152 @code{FAILED_IMAGES}, @code{STOPPED_IMAGES})
1154 @end itemize
1157 @c ---------------------------------------------------------------------
1158 @c Compiler Characteristics
1159 @c ---------------------------------------------------------------------
1161 @node Compiler Characteristics
1162 @chapter Compiler Characteristics
1164 This chapter describes certain characteristics of the GNU Fortran
1165 compiler, that are not specified by the Fortran standard, but which
1166 might in some way or another become visible to the programmer.
1168 @menu
1169 * KIND Type Parameters::
1170 * Internal representation of LOGICAL variables::
1171 * Thread-safety of the runtime library::
1172 * Data consistency and durability::
1173 * Files opened without an explicit ACTION= specifier::
1174 * File operations on symbolic links::
1175 @end menu
1178 @node KIND Type Parameters
1179 @section KIND Type Parameters
1180 @cindex kind
1182 The @code{KIND} type parameters supported by GNU Fortran for the primitive
1183 data types are:
1185 @table @code
1187 @item INTEGER
1188 1, 2, 4, 8*, 16*, default: 4**
1190 @item LOGICAL
1191 1, 2, 4, 8*, 16*, default: 4**
1193 @item REAL
1194 4, 8, 10*, 16*, default: 4***
1196 @item COMPLEX
1197 4, 8, 10*, 16*, default: 4***
1199 @item DOUBLE PRECISION
1200 4, 8, 10*, 16*, default: 8***
1202 @item CHARACTER
1203 1, 4, default: 1
1205 @end table
1207 @noindent
1208 * not available on all systems @*
1209 ** unless @option{-fdefault-integer-8} is used @*
1210 *** unless @option{-fdefault-real-8} is used (see @ref{Fortran Dialect Options})
1212 @noindent
1213 The @code{KIND} value matches the storage size in bytes, except for
1214 @code{COMPLEX} where the storage size is twice as much (or both real and
1215 imaginary part are a real value of the given size).  It is recommended to use
1216 the @ref{SELECTED_CHAR_KIND}, @ref{SELECTED_INT_KIND} and
1217 @ref{SELECTED_REAL_KIND} intrinsics or the @code{INT8}, @code{INT16},
1218 @code{INT32}, @code{INT64}, @code{REAL32}, @code{REAL64}, and @code{REAL128}
1219 parameters of the @code{ISO_FORTRAN_ENV} module instead of the concrete values.
1220 The available kind parameters can be found in the constant arrays
1221 @code{CHARACTER_KINDS}, @code{INTEGER_KINDS}, @code{LOGICAL_KINDS} and
1222 @code{REAL_KINDS} in the @ref{ISO_FORTRAN_ENV} module.  For C interoperability,
1223 the kind parameters of the @ref{ISO_C_BINDING} module should be used.
1226 @node Internal representation of LOGICAL variables
1227 @section Internal representation of LOGICAL variables
1228 @cindex logical, variable representation
1230 The Fortran standard does not specify how variables of @code{LOGICAL}
1231 type are represented, beyond requiring that @code{LOGICAL} variables
1232 of default kind have the same storage size as default @code{INTEGER}
1233 and @code{REAL} variables.  The GNU Fortran internal representation is
1234 as follows.
1236 A @code{LOGICAL(KIND=N)} variable is represented as an
1237 @code{INTEGER(KIND=N)} variable, however, with only two permissible
1238 values: @code{1} for @code{.TRUE.} and @code{0} for
1239 @code{.FALSE.}.  Any other integer value results in undefined behavior.
1241 See also @ref{Argument passing conventions} and @ref{Interoperability with C}.
1244 @node Thread-safety of the runtime library
1245 @section Thread-safety of the runtime library
1246 @cindex thread-safety, threads
1248 GNU Fortran can be used in programs with multiple threads, e.g.@: by
1249 using OpenMP, by calling OS thread handling functions via the
1250 @code{ISO_C_BINDING} facility, or by GNU Fortran compiled library code
1251 being called from a multi-threaded program.
1253 The GNU Fortran runtime library, (@code{libgfortran}), supports being
1254 called concurrently from multiple threads with the following
1255 exceptions. 
1257 During library initialization, the C @code{getenv} function is used,
1258 which need not be thread-safe.  Similarly, the @code{getenv}
1259 function is used to implement the @code{GET_ENVIRONMENT_VARIABLE} and
1260 @code{GETENV} intrinsics.  It is the responsibility of the user to
1261 ensure that the environment is not being updated concurrently when any
1262 of these actions are taking place.
1264 The @code{EXECUTE_COMMAND_LINE} and @code{SYSTEM} intrinsics are
1265 implemented with the @code{system} function, which need not be
1266 thread-safe.  It is the responsibility of the user to ensure that
1267 @code{system} is not called concurrently.
1269 For platforms not supporting thread-safe POSIX functions, further
1270 functionality might not be thread-safe.  For details, please consult
1271 the documentation for your operating system.
1273 The GNU Fortran runtime library uses various C library functions that
1274 depend on the locale, such as @code{strtod} and @code{snprintf}.  In
1275 order to work correctly in locale-aware programs that set the locale
1276 using @code{setlocale}, the locale is reset to the default ``C''
1277 locale while executing a formatted @code{READ} or @code{WRITE}
1278 statement.  On targets supporting the POSIX 2008 per-thread locale
1279 functions (e.g. @code{newlocale}, @code{uselocale},
1280 @code{freelocale}), these are used and thus the global locale set
1281 using @code{setlocale} or the per-thread locales in other threads are
1282 not affected.  However, on targets lacking this functionality, the
1283 global LC_NUMERIC locale is set to ``C'' during the formatted I/O.
1284 Thus, on such targets it's not safe to call @code{setlocale}
1285 concurrently from another thread while a Fortran formatted I/O
1286 operation is in progress.  Also, other threads doing something
1287 dependent on the LC_NUMERIC locale might not work correctly if a
1288 formatted I/O operation is in progress in another thread.
1290 @node Data consistency and durability
1291 @section Data consistency and durability
1292 @cindex consistency, durability
1294 This section contains a brief overview of data and metadata
1295 consistency and durability issues when doing I/O.
1297 With respect to durability, GNU Fortran makes no effort to ensure that
1298 data is committed to stable storage. If this is required, the GNU
1299 Fortran programmer can use the intrinsic @code{FNUM} to retrieve the
1300 low level file descriptor corresponding to an open Fortran unit. Then,
1301 using e.g. the @code{ISO_C_BINDING} feature, one can call the
1302 underlying system call to flush dirty data to stable storage, such as
1303 @code{fsync} on POSIX, @code{_commit} on MingW, or @code{fcntl(fd,
1304 F_FULLSYNC, 0)} on Mac OS X. The following example shows how to call
1305 fsync:
1307 @smallexample
1308   ! Declare the interface for POSIX fsync function
1309   interface
1310     function fsync (fd) bind(c,name="fsync")
1311     use iso_c_binding, only: c_int
1312       integer(c_int), value :: fd
1313       integer(c_int) :: fsync
1314     end function fsync
1315   end interface
1317   ! Variable declaration
1318   integer :: ret
1320   ! Opening unit 10
1321   open (10,file="foo")
1323   ! ...
1324   ! Perform I/O on unit 10
1325   ! ...
1327   ! Flush and sync
1328   flush(10)
1329   ret = fsync(fnum(10))
1331   ! Handle possible error
1332   if (ret /= 0) stop "Error calling FSYNC"
1333 @end smallexample
1335 With respect to consistency, for regular files GNU Fortran uses
1336 buffered I/O in order to improve performance. This buffer is flushed
1337 automatically when full and in some other situations, e.g. when
1338 closing a unit. It can also be explicitly flushed with the
1339 @code{FLUSH} statement. Also, the buffering can be turned off with the
1340 @code{GFORTRAN_UNBUFFERED_ALL} and
1341 @code{GFORTRAN_UNBUFFERED_PRECONNECTED} environment variables. Special
1342 files, such as terminals and pipes, are always unbuffered. Sometimes,
1343 however, further things may need to be done in order to allow other
1344 processes to see data that GNU Fortran has written, as follows.
1346 The Windows platform supports a relaxed metadata consistency model,
1347 where file metadata is written to the directory lazily. This means
1348 that, for instance, the @code{dir} command can show a stale size for a
1349 file. One can force a directory metadata update by closing the unit,
1350 or by calling @code{_commit} on the file descriptor. Note, though,
1351 that @code{_commit} will force all dirty data to stable storage, which
1352 is often a very slow operation.
1354 The Network File System (NFS) implements a relaxed consistency model
1355 called open-to-close consistency. Closing a file forces dirty data and
1356 metadata to be flushed to the server, and opening a file forces the
1357 client to contact the server in order to revalidate cached
1358 data. @code{fsync} will also force a flush of dirty data and metadata
1359 to the server. Similar to @code{open} and @code{close}, acquiring and
1360 releasing @code{fcntl} file locks, if the server supports them, will
1361 also force cache validation and flushing dirty data and metadata.
1364 @node Files opened without an explicit ACTION= specifier
1365 @section Files opened without an explicit ACTION= specifier
1366 @cindex open, action
1368 The Fortran standard says that if an @code{OPEN} statement is executed
1369 without an explicit @code{ACTION=} specifier, the default value is
1370 processor dependent.  GNU Fortran behaves as follows:
1372 @enumerate
1373 @item Attempt to open the file with @code{ACTION='READWRITE'}
1374 @item If that fails, try to open with @code{ACTION='READ'}
1375 @item If that fails, try to open with @code{ACTION='WRITE'}
1376 @item If that fails, generate an error
1377 @end enumerate
1380 @node File operations on symbolic links
1381 @section File operations on symbolic links
1382 @cindex file, symbolic link
1384 This section documents the behavior of GNU Fortran for file operations on
1385 symbolic links, on systems that support them. 
1387 @itemize
1389 @item Results of INQUIRE statements of the ``inquire by file'' form will
1390 relate to the target of the symbolic link. For example,
1391 @code{INQUIRE(FILE="foo",EXIST=ex)} will set @var{ex} to @var{.true.} if
1392 @var{foo} is a symbolic link pointing to an existing file, and @var{.false.}
1393 if @var{foo} points to an non-existing file (``dangling'' symbolic link).
1395 @item Using the @code{OPEN} statement with a @code{STATUS="NEW"} specifier
1396 on a symbolic link will result in an error condition, whether the symbolic
1397 link points to an existing target or is dangling.
1399 @item If a symbolic link was connected, using the @code{CLOSE} statement
1400 with a @code{STATUS="DELETE"} specifier will cause the symbolic link itself
1401 to be deleted, not its target.
1403 @end itemize
1407 @c ---------------------------------------------------------------------
1408 @c Extensions
1409 @c ---------------------------------------------------------------------
1411 @c Maybe this chapter should be merged with the 'Standards' section,
1412 @c whenever that is written :-)
1414 @node Extensions
1415 @chapter Extensions
1416 @cindex extensions
1418 The two sections below detail the extensions to standard Fortran that are
1419 implemented in GNU Fortran, as well as some of the popular or
1420 historically important extensions that are not (or not yet) implemented.
1421 For the latter case, we explain the alternatives available to GNU Fortran
1422 users, including replacement by standard-conforming code or GNU
1423 extensions.
1425 @menu
1426 * Extensions implemented in GNU Fortran::
1427 * Extensions not implemented in GNU Fortran::
1428 @end menu
1431 @node Extensions implemented in GNU Fortran
1432 @section Extensions implemented in GNU Fortran
1433 @cindex extensions, implemented
1435 GNU Fortran implements a number of extensions over standard
1436 Fortran.  This chapter contains information on their syntax and
1437 meaning.  There are currently two categories of GNU Fortran
1438 extensions, those that provide functionality beyond that provided
1439 by any standard, and those that are supported by GNU Fortran
1440 purely for backward compatibility with legacy compilers.  By default,
1441 @option{-std=gnu} allows the compiler to accept both types of
1442 extensions, but to warn about the use of the latter.  Specifying
1443 either @option{-std=f95}, @option{-std=f2003} or @option{-std=f2008}
1444 disables both types of extensions, and @option{-std=legacy} allows both
1445 without warning.  The special compile flag @option{-fdec} enables additional
1446 compatibility extensions along with those enabled by @option{-std=legacy}.
1448 @menu
1449 * Old-style kind specifications::
1450 * Old-style variable initialization::
1451 * Extensions to namelist::
1452 * X format descriptor without count field::
1453 * Commas in FORMAT specifications::
1454 * Missing period in FORMAT specifications::
1455 * I/O item lists::
1456 * @code{Q} exponent-letter::
1457 * BOZ literal constants::
1458 * Real array indices::
1459 * Unary operators::
1460 * Implicitly convert LOGICAL and INTEGER values::
1461 * Hollerith constants support::
1462 * Cray pointers::
1463 * CONVERT specifier::
1464 * OpenMP::
1465 * OpenACC::
1466 * Argument list functions::
1467 * Read/Write after EOF marker::
1468 * STRUCTURE and RECORD::
1469 * UNION and MAP::
1470 * Type variants for integer intrinsics::
1471 * AUTOMATIC and STATIC attributes::
1472 * Extended math intrinsics::
1473 * Form feed as whitespace::
1474 * TYPE as an alias for PRINT::
1475 * %LOC as an rvalue::
1476 * .XOR. operator::
1477 * Bitwise logical operators::
1478 * Extended I/O specifiers::
1479 * Legacy PARAMETER statements::
1480 * Default exponents::
1481 @end menu
1483 @node Old-style kind specifications
1484 @subsection Old-style kind specifications
1485 @cindex kind, old-style
1487 GNU Fortran allows old-style kind specifications in declarations.  These
1488 look like:
1489 @smallexample
1490       TYPESPEC*size x,y,z
1491 @end smallexample
1492 @noindent
1493 where @code{TYPESPEC} is a basic type (@code{INTEGER}, @code{REAL},
1494 etc.), and where @code{size} is a byte count corresponding to the
1495 storage size of a valid kind for that type.  (For @code{COMPLEX}
1496 variables, @code{size} is the total size of the real and imaginary
1497 parts.)  The statement then declares @code{x}, @code{y} and @code{z} to
1498 be of type @code{TYPESPEC} with the appropriate kind.  This is
1499 equivalent to the standard-conforming declaration
1500 @smallexample
1501       TYPESPEC(k) x,y,z
1502 @end smallexample
1503 @noindent
1504 where @code{k} is the kind parameter suitable for the intended precision.  As
1505 kind parameters are implementation-dependent, use the @code{KIND},
1506 @code{SELECTED_INT_KIND} and @code{SELECTED_REAL_KIND} intrinsics to retrieve
1507 the correct value, for instance @code{REAL*8 x} can be replaced by:
1508 @smallexample
1509 INTEGER, PARAMETER :: dbl = KIND(1.0d0)
1510 REAL(KIND=dbl) :: x
1511 @end smallexample
1513 @node Old-style variable initialization
1514 @subsection Old-style variable initialization
1516 GNU Fortran allows old-style initialization of variables of the
1517 form:
1518 @smallexample
1519       INTEGER i/1/,j/2/
1520       REAL x(2,2) /3*0.,1./
1521 @end smallexample
1522 The syntax for the initializers is as for the @code{DATA} statement, but
1523 unlike in a @code{DATA} statement, an initializer only applies to the
1524 variable immediately preceding the initialization.  In other words,
1525 something like @code{INTEGER I,J/2,3/} is not valid.  This style of
1526 initialization is only allowed in declarations without double colons
1527 (@code{::}); the double colons were introduced in Fortran 90, which also
1528 introduced a standard syntax for initializing variables in type
1529 declarations.
1531 Examples of standard-conforming code equivalent to the above example
1532 are:
1533 @smallexample
1534 ! Fortran 90
1535       INTEGER :: i = 1, j = 2
1536       REAL :: x(2,2) = RESHAPE((/0.,0.,0.,1./),SHAPE(x))
1537 ! Fortran 77
1538       INTEGER i, j
1539       REAL x(2,2)
1540       DATA i/1/, j/2/, x/3*0.,1./
1541 @end smallexample
1543 Note that variables which are explicitly initialized in declarations
1544 or in @code{DATA} statements automatically acquire the @code{SAVE}
1545 attribute.
1547 @node Extensions to namelist
1548 @subsection Extensions to namelist
1549 @cindex Namelist
1551 GNU Fortran fully supports the Fortran 95 standard for namelist I/O
1552 including array qualifiers, substrings and fully qualified derived types.
1553 The output from a namelist write is compatible with namelist read.  The
1554 output has all names in upper case and indentation to column 1 after the
1555 namelist name.  Two extensions are permitted:
1557 Old-style use of @samp{$} instead of @samp{&}
1558 @smallexample
1559 $MYNML
1560  X(:)%Y(2) = 1.0 2.0 3.0
1561  CH(1:4) = "abcd"
1562 $END
1563 @end smallexample
1565 It should be noted that the default terminator is @samp{/} rather than
1566 @samp{&END}.
1568 Querying of the namelist when inputting from stdin.  After at least
1569 one space, entering @samp{?} sends to stdout the namelist name and the names of
1570 the variables in the namelist:
1571 @smallexample
1574 &mynml
1576  x%y
1577  ch
1578 &end
1579 @end smallexample
1581 Entering @samp{=?} outputs the namelist to stdout, as if
1582 @code{WRITE(*,NML = mynml)} had been called:
1583 @smallexample
1586 &MYNML
1587  X(1)%Y=  0.000000    ,  1.000000    ,  0.000000    ,
1588  X(2)%Y=  0.000000    ,  2.000000    ,  0.000000    ,
1589  X(3)%Y=  0.000000    ,  3.000000    ,  0.000000    ,
1590  CH=abcd,  /
1591 @end smallexample
1593 To aid this dialog, when input is from stdin, errors send their
1594 messages to stderr and execution continues, even if @code{IOSTAT} is set.
1596 @code{PRINT} namelist is permitted.  This causes an error if
1597 @option{-std=f95} is used.
1598 @smallexample
1599 PROGRAM test_print
1600   REAL, dimension (4)  ::  x = (/1.0, 2.0, 3.0, 4.0/)
1601   NAMELIST /mynml/ x
1602   PRINT mynml
1603 END PROGRAM test_print
1604 @end smallexample
1606 Expanded namelist reads are permitted.  This causes an error if 
1607 @option{-std=f95} is used.  In the following example, the first element
1608 of the array will be given the value 0.00 and the two succeeding
1609 elements will be given the values 1.00 and 2.00.
1610 @smallexample
1611 &MYNML
1612   X(1,1) = 0.00 , 1.00 , 2.00
1614 @end smallexample
1616 When writing a namelist, if no @code{DELIM=} is specified, by default a
1617 double quote is used to delimit character strings. If -std=F95, F2003,
1618 or F2008, etc, the delim status is set to 'none'.  Defaulting to
1619 quotes ensures that namelists with character strings can be subsequently
1620 read back in accurately.
1622 @node X format descriptor without count field
1623 @subsection @code{X} format descriptor without count field
1625 To support legacy codes, GNU Fortran permits the count field of the
1626 @code{X} edit descriptor in @code{FORMAT} statements to be omitted.
1627 When omitted, the count is implicitly assumed to be one.
1629 @smallexample
1630        PRINT 10, 2, 3
1631 10     FORMAT (I1, X, I1)
1632 @end smallexample
1634 @node Commas in FORMAT specifications
1635 @subsection Commas in @code{FORMAT} specifications
1637 To support legacy codes, GNU Fortran allows the comma separator
1638 to be omitted immediately before and after character string edit
1639 descriptors in @code{FORMAT} statements.
1641 @smallexample
1642        PRINT 10, 2, 3
1643 10     FORMAT ('FOO='I1' BAR='I2)
1644 @end smallexample
1647 @node Missing period in FORMAT specifications
1648 @subsection Missing period in @code{FORMAT} specifications
1650 To support legacy codes, GNU Fortran allows missing periods in format
1651 specifications if and only if @option{-std=legacy} is given on the
1652 command line.  This is considered non-conforming code and is
1653 discouraged.
1655 @smallexample
1656        REAL :: value
1657        READ(*,10) value
1658 10     FORMAT ('F4')
1659 @end smallexample
1661 @node I/O item lists
1662 @subsection I/O item lists
1663 @cindex I/O item lists
1665 To support legacy codes, GNU Fortran allows the input item list
1666 of the @code{READ} statement, and the output item lists of the
1667 @code{WRITE} and @code{PRINT} statements, to start with a comma.
1669 @node @code{Q} exponent-letter
1670 @subsection @code{Q} exponent-letter
1671 @cindex @code{Q} exponent-letter
1673 GNU Fortran accepts real literal constants with an exponent-letter
1674 of @code{Q}, for example, @code{1.23Q45}.  The constant is interpreted
1675 as a @code{REAL(16)} entity on targets that support this type.  If
1676 the target does not support @code{REAL(16)} but has a @code{REAL(10)}
1677 type, then the real-literal-constant will be interpreted as a
1678 @code{REAL(10)} entity.  In the absence of @code{REAL(16)} and
1679 @code{REAL(10)}, an error will occur.
1681 @node BOZ literal constants
1682 @subsection BOZ literal constants
1683 @cindex BOZ literal constants
1685 Besides decimal constants, Fortran also supports binary (@code{b}),
1686 octal (@code{o}) and hexadecimal (@code{z}) integer constants.  The
1687 syntax is: @samp{prefix quote digits quote}, were the prefix is
1688 either @code{b}, @code{o} or @code{z}, quote is either @code{'} or
1689 @code{"} and the digits are for binary @code{0} or @code{1}, for
1690 octal between @code{0} and @code{7}, and for hexadecimal between
1691 @code{0} and @code{F}.  (Example: @code{b'01011101'}.)
1693 Up to Fortran 95, BOZ literals were only allowed to initialize
1694 integer variables in DATA statements.  Since Fortran 2003 BOZ literals
1695 are also allowed as argument of @code{REAL}, @code{DBLE}, @code{INT}
1696 and @code{CMPLX}; the result is the same as if the integer BOZ
1697 literal had been converted by @code{TRANSFER} to, respectively,
1698 @code{real}, @code{double precision}, @code{integer} or @code{complex}.
1699 As GNU Fortran extension the intrinsic procedures @code{FLOAT},
1700 @code{DFLOAT}, @code{COMPLEX} and @code{DCMPLX} are treated alike.
1702 As an extension, GNU Fortran allows hexadecimal BOZ literal constants to
1703 be specified using the @code{X} prefix, in addition to the standard
1704 @code{Z} prefix.  The BOZ literal can also be specified by adding a
1705 suffix to the string, for example, @code{Z'ABC'} and @code{'ABC'Z} are
1706 equivalent.
1708 Furthermore, GNU Fortran allows using BOZ literal constants outside
1709 DATA statements and the four intrinsic functions allowed by Fortran 2003.
1710 In DATA statements, in direct assignments, where the right-hand side
1711 only contains a BOZ literal constant, and for old-style initializers of
1712 the form @code{integer i /o'0173'/}, the constant is transferred
1713 as if @code{TRANSFER} had been used; for @code{COMPLEX} numbers, only
1714 the real part is initialized unless @code{CMPLX} is used.  In all other
1715 cases, the BOZ literal constant is converted to an @code{INTEGER} value with
1716 the largest decimal representation.  This value is then converted
1717 numerically to the type and kind of the variable in question.
1718 (For instance, @code{real :: r = b'0000001' + 1} initializes @code{r}
1719 with @code{2.0}.) As different compilers implement the extension
1720 differently, one should be careful when doing bitwise initialization
1721 of non-integer variables.
1723 Note that initializing an @code{INTEGER} variable with a statement such
1724 as @code{DATA i/Z'FFFFFFFF'/} will give an integer overflow error rather
1725 than the desired result of @math{-1} when @code{i} is a 32-bit integer
1726 on a system that supports 64-bit integers.  The @samp{-fno-range-check}
1727 option can be used as a workaround for legacy code that initializes
1728 integers in this manner.
1730 @node Real array indices
1731 @subsection Real array indices
1732 @cindex array, indices of type real
1734 As an extension, GNU Fortran allows the use of @code{REAL} expressions
1735 or variables as array indices.
1737 @node Unary operators
1738 @subsection Unary operators
1739 @cindex operators, unary
1741 As an extension, GNU Fortran allows unary plus and unary minus operators
1742 to appear as the second operand of binary arithmetic operators without
1743 the need for parenthesis.
1745 @smallexample
1746        X = Y * -Z
1747 @end smallexample
1749 @node Implicitly convert LOGICAL and INTEGER values
1750 @subsection Implicitly convert @code{LOGICAL} and @code{INTEGER} values
1751 @cindex conversion, to integer
1752 @cindex conversion, to logical
1754 As an extension for backwards compatibility with other compilers, GNU
1755 Fortran allows the implicit conversion of @code{LOGICAL} values to
1756 @code{INTEGER} values and vice versa.  When converting from a
1757 @code{LOGICAL} to an @code{INTEGER}, @code{.FALSE.} is interpreted as
1758 zero, and @code{.TRUE.} is interpreted as one.  When converting from
1759 @code{INTEGER} to @code{LOGICAL}, the value zero is interpreted as
1760 @code{.FALSE.} and any nonzero value is interpreted as @code{.TRUE.}.
1762 @smallexample
1763         LOGICAL :: l
1764         l = 1
1765 @end smallexample
1766 @smallexample
1767         INTEGER :: i
1768         i = .TRUE.
1769 @end smallexample
1771 However, there is no implicit conversion of @code{INTEGER} values in
1772 @code{if}-statements, nor of @code{LOGICAL} or @code{INTEGER} values
1773 in I/O operations.
1775 @node Hollerith constants support
1776 @subsection Hollerith constants support
1777 @cindex Hollerith constants
1779 GNU Fortran supports Hollerith constants in assignments, function
1780 arguments, and @code{DATA} and @code{ASSIGN} statements.  A Hollerith
1781 constant is written as a string of characters preceded by an integer
1782 constant indicating the character count, and the letter @code{H} or
1783 @code{h}, and stored in bytewise fashion in a numeric (@code{INTEGER},
1784 @code{REAL}, or @code{complex}) or @code{LOGICAL} variable.  The
1785 constant will be padded or truncated to fit the size of the variable in
1786 which it is stored.
1788 Examples of valid uses of Hollerith constants:
1789 @smallexample
1790       complex*16 x(2)
1791       data x /16Habcdefghijklmnop, 16Hqrstuvwxyz012345/
1792       x(1) = 16HABCDEFGHIJKLMNOP
1793       call foo (4h abc)
1794 @end smallexample
1796 Invalid Hollerith constants examples:
1797 @smallexample
1798       integer*4 a
1799       a = 8H12345678 ! Valid, but the Hollerith constant will be truncated.
1800       a = 0H         ! At least one character is needed.
1801 @end smallexample
1803 In general, Hollerith constants were used to provide a rudimentary
1804 facility for handling character strings in early Fortran compilers,
1805 prior to the introduction of @code{CHARACTER} variables in Fortran 77;
1806 in those cases, the standard-compliant equivalent is to convert the
1807 program to use proper character strings.  On occasion, there may be a
1808 case where the intent is specifically to initialize a numeric variable
1809 with a given byte sequence.  In these cases, the same result can be
1810 obtained by using the @code{TRANSFER} statement, as in this example.
1811 @smallexample
1812       INTEGER(KIND=4) :: a
1813       a = TRANSFER ("abcd", a)     ! equivalent to: a = 4Habcd
1814 @end smallexample
1817 @node Cray pointers
1818 @subsection Cray pointers
1819 @cindex pointer, Cray
1821 Cray pointers are part of a non-standard extension that provides a
1822 C-like pointer in Fortran.  This is accomplished through a pair of
1823 variables: an integer "pointer" that holds a memory address, and a
1824 "pointee" that is used to dereference the pointer.
1826 Pointer/pointee pairs are declared in statements of the form:
1827 @smallexample
1828         pointer ( <pointer> , <pointee> )
1829 @end smallexample
1831 @smallexample
1832         pointer ( <pointer1> , <pointee1> ), ( <pointer2> , <pointee2> ), ...
1833 @end smallexample
1834 The pointer is an integer that is intended to hold a memory address.
1835 The pointee may be an array or scalar.  A pointee can be an assumed
1836 size array---that is, the last dimension may be left unspecified by
1837 using a @code{*} in place of a value---but a pointee cannot be an
1838 assumed shape array.  No space is allocated for the pointee.
1840 The pointee may have its type declared before or after the pointer
1841 statement, and its array specification (if any) may be declared
1842 before, during, or after the pointer statement.  The pointer may be
1843 declared as an integer prior to the pointer statement.  However, some
1844 machines have default integer sizes that are different than the size
1845 of a pointer, and so the following code is not portable:
1846 @smallexample
1847         integer ipt
1848         pointer (ipt, iarr)
1849 @end smallexample
1850 If a pointer is declared with a kind that is too small, the compiler
1851 will issue a warning; the resulting binary will probably not work
1852 correctly, because the memory addresses stored in the pointers may be
1853 truncated.  It is safer to omit the first line of the above example;
1854 if explicit declaration of ipt's type is omitted, then the compiler
1855 will ensure that ipt is an integer variable large enough to hold a
1856 pointer.
1858 Pointer arithmetic is valid with Cray pointers, but it is not the same
1859 as C pointer arithmetic.  Cray pointers are just ordinary integers, so
1860 the user is responsible for determining how many bytes to add to a
1861 pointer in order to increment it.  Consider the following example:
1862 @smallexample
1863         real target(10)
1864         real pointee(10)
1865         pointer (ipt, pointee)
1866         ipt = loc (target)
1867         ipt = ipt + 1       
1868 @end smallexample
1869 The last statement does not set @code{ipt} to the address of
1870 @code{target(1)}, as it would in C pointer arithmetic.  Adding @code{1}
1871 to @code{ipt} just adds one byte to the address stored in @code{ipt}.
1873 Any expression involving the pointee will be translated to use the
1874 value stored in the pointer as the base address.
1876 To get the address of elements, this extension provides an intrinsic
1877 function @code{LOC()}.  The @code{LOC()} function is equivalent to the
1878 @code{&} operator in C, except the address is cast to an integer type:
1879 @smallexample
1880         real ar(10)
1881         pointer(ipt, arpte(10))
1882         real arpte
1883         ipt = loc(ar)  ! Makes arpte is an alias for ar
1884         arpte(1) = 1.0 ! Sets ar(1) to 1.0
1885 @end smallexample
1886 The pointer can also be set by a call to the @code{MALLOC} intrinsic
1887 (see @ref{MALLOC}).
1889 Cray pointees often are used to alias an existing variable.  For
1890 example:
1891 @smallexample
1892         integer target(10)
1893         integer iarr(10)
1894         pointer (ipt, iarr)
1895         ipt = loc(target)
1896 @end smallexample
1897 As long as @code{ipt} remains unchanged, @code{iarr} is now an alias for
1898 @code{target}.  The optimizer, however, will not detect this aliasing, so
1899 it is unsafe to use @code{iarr} and @code{target} simultaneously.  Using
1900 a pointee in any way that violates the Fortran aliasing rules or
1901 assumptions is illegal.  It is the user's responsibility to avoid doing
1902 this; the compiler works under the assumption that no such aliasing
1903 occurs.
1905 Cray pointers will work correctly when there is no aliasing (i.e., when
1906 they are used to access a dynamically allocated block of memory), and
1907 also in any routine where a pointee is used, but any variable with which
1908 it shares storage is not used.  Code that violates these rules may not
1909 run as the user intends.  This is not a bug in the optimizer; any code
1910 that violates the aliasing rules is illegal.  (Note that this is not
1911 unique to GNU Fortran; any Fortran compiler that supports Cray pointers
1912 will ``incorrectly'' optimize code with illegal aliasing.)
1914 There are a number of restrictions on the attributes that can be applied
1915 to Cray pointers and pointees.  Pointees may not have the
1916 @code{ALLOCATABLE}, @code{INTENT}, @code{OPTIONAL}, @code{DUMMY},
1917 @code{TARGET}, @code{INTRINSIC}, or @code{POINTER} attributes.  Pointers
1918 may not have the @code{DIMENSION}, @code{POINTER}, @code{TARGET},
1919 @code{ALLOCATABLE}, @code{EXTERNAL}, or @code{INTRINSIC} attributes, nor
1920 may they be function results.  Pointees may not occur in more than one
1921 pointer statement.  A pointee cannot be a pointer.  Pointees cannot occur
1922 in equivalence, common, or data statements.
1924 A Cray pointer may also point to a function or a subroutine.  For
1925 example, the following excerpt is valid:
1926 @smallexample
1927   implicit none
1928   external sub
1929   pointer (subptr,subpte)
1930   external subpte
1931   subptr = loc(sub)
1932   call subpte()
1933   [...]
1934   subroutine sub
1935   [...]
1936   end subroutine sub
1937 @end smallexample
1939 A pointer may be modified during the course of a program, and this
1940 will change the location to which the pointee refers.  However, when
1941 pointees are passed as arguments, they are treated as ordinary
1942 variables in the invoked function.  Subsequent changes to the pointer
1943 will not change the base address of the array that was passed.
1945 @node CONVERT specifier
1946 @subsection @code{CONVERT} specifier
1947 @cindex @code{CONVERT} specifier
1949 GNU Fortran allows the conversion of unformatted data between little-
1950 and big-endian representation to facilitate moving of data
1951 between different systems.  The conversion can be indicated with
1952 the @code{CONVERT} specifier on the @code{OPEN} statement.
1953 @xref{GFORTRAN_CONVERT_UNIT}, for an alternative way of specifying
1954 the data format via an environment variable.
1956 Valid values for @code{CONVERT} are:
1957 @itemize @w{}
1958 @item @code{CONVERT='NATIVE'} Use the native format.  This is the default.
1959 @item @code{CONVERT='SWAP'} Swap between little- and big-endian.
1960 @item @code{CONVERT='LITTLE_ENDIAN'} Use the little-endian representation
1961 for unformatted files.
1962 @item @code{CONVERT='BIG_ENDIAN'} Use the big-endian representation for
1963 unformatted files.
1964 @end itemize
1966 Using the option could look like this:
1967 @smallexample
1968   open(file='big.dat',form='unformatted',access='sequential', &
1969        convert='big_endian')
1970 @end smallexample
1972 The value of the conversion can be queried by using
1973 @code{INQUIRE(CONVERT=ch)}.  The values returned are
1974 @code{'BIG_ENDIAN'} and @code{'LITTLE_ENDIAN'}.
1976 @code{CONVERT} works between big- and little-endian for
1977 @code{INTEGER} values of all supported kinds and for @code{REAL}
1978 on IEEE systems of kinds 4 and 8.  Conversion between different
1979 ``extended double'' types on different architectures such as
1980 m68k and x86_64, which GNU Fortran
1981 supports as @code{REAL(KIND=10)} and @code{REAL(KIND=16)}, will
1982 probably not work.
1984 @emph{Note that the values specified via the GFORTRAN_CONVERT_UNIT
1985 environment variable will override the CONVERT specifier in the
1986 open statement}.  This is to give control over data formats to
1987 users who do not have the source code of their program available.
1989 Using anything but the native representation for unformatted data
1990 carries a significant speed overhead.  If speed in this area matters
1991 to you, it is best if you use this only for data that needs to be
1992 portable.
1994 @node OpenMP
1995 @subsection OpenMP
1996 @cindex OpenMP
1998 OpenMP (Open Multi-Processing) is an application programming
1999 interface (API) that supports multi-platform shared memory 
2000 multiprocessing programming in C/C++ and Fortran on many 
2001 architectures, including Unix and Microsoft Windows platforms.
2002 It consists of a set of compiler directives, library routines,
2003 and environment variables that influence run-time behavior.
2005 GNU Fortran strives to be compatible to the 
2006 @uref{http://openmp.org/wp/openmp-specifications/,
2007 OpenMP Application Program Interface v4.5}.
2009 To enable the processing of the OpenMP directive @code{!$omp} in
2010 free-form source code; the @code{c$omp}, @code{*$omp} and @code{!$omp}
2011 directives in fixed form; the @code{!$} conditional compilation sentinels
2012 in free form; and the @code{c$}, @code{*$} and @code{!$} sentinels
2013 in fixed form, @command{gfortran} needs to be invoked with the
2014 @option{-fopenmp}.  This also arranges for automatic linking of the
2015 GNU Offloading and Multi Processing Runtime Library
2016 @ref{Top,,libgomp,libgomp,GNU Offloading and Multi Processing Runtime
2017 Library}.
2019 The OpenMP Fortran runtime library routines are provided both in a
2020 form of a Fortran 90 module named @code{omp_lib} and in a form of
2021 a Fortran @code{include} file named @file{omp_lib.h}.
2023 An example of a parallelized loop taken from Appendix A.1 of
2024 the OpenMP Application Program Interface v2.5:
2025 @smallexample
2026 SUBROUTINE A1(N, A, B)
2027   INTEGER I, N
2028   REAL B(N), A(N)
2029 !$OMP PARALLEL DO !I is private by default
2030   DO I=2,N
2031     B(I) = (A(I) + A(I-1)) / 2.0
2032   ENDDO
2033 !$OMP END PARALLEL DO
2034 END SUBROUTINE A1
2035 @end smallexample
2037 Please note:
2038 @itemize
2039 @item
2040 @option{-fopenmp} implies @option{-frecursive}, i.e., all local arrays
2041 will be allocated on the stack.  When porting existing code to OpenMP,
2042 this may lead to surprising results, especially to segmentation faults
2043 if the stacksize is limited.
2045 @item
2046 On glibc-based systems, OpenMP enabled applications cannot be statically
2047 linked due to limitations of the underlying pthreads-implementation.  It
2048 might be possible to get a working solution if 
2049 @command{-Wl,--whole-archive -lpthread -Wl,--no-whole-archive} is added
2050 to the command line.  However, this is not supported by @command{gcc} and
2051 thus not recommended.
2052 @end itemize
2054 @node OpenACC
2055 @subsection OpenACC
2056 @cindex OpenACC
2058 OpenACC is an application programming interface (API) that supports
2059 offloading of code to accelerator devices.  It consists of a set of
2060 compiler directives, library routines, and environment variables that
2061 influence run-time behavior.
2063 GNU Fortran strives to be compatible to the
2064 @uref{http://www.openacc.org/, OpenACC Application Programming
2065 Interface v2.0}.
2067 To enable the processing of the OpenACC directive @code{!$acc} in
2068 free-form source code; the @code{c$acc}, @code{*$acc} and @code{!$acc}
2069 directives in fixed form; the @code{!$} conditional compilation
2070 sentinels in free form; and the @code{c$}, @code{*$} and @code{!$}
2071 sentinels in fixed form, @command{gfortran} needs to be invoked with
2072 the @option{-fopenacc}.  This also arranges for automatic linking of
2073 the GNU Offloading and Multi Processing Runtime Library
2074 @ref{Top,,libgomp,libgomp,GNU Offloading and Multi Processing Runtime
2075 Library}.
2077 The OpenACC Fortran runtime library routines are provided both in a
2078 form of a Fortran 90 module named @code{openacc} and in a form of a
2079 Fortran @code{include} file named @file{openacc_lib.h}.
2081 Note that this is an experimental feature, incomplete, and subject to
2082 change in future versions of GCC.  See
2083 @uref{https://gcc.gnu.org/wiki/OpenACC} for more information.
2085 @node Argument list functions
2086 @subsection Argument list functions @code{%VAL}, @code{%REF} and @code{%LOC}
2087 @cindex argument list functions
2088 @cindex @code{%VAL}
2089 @cindex @code{%REF}
2090 @cindex @code{%LOC}
2092 GNU Fortran supports argument list functions @code{%VAL}, @code{%REF} 
2093 and @code{%LOC} statements, for backward compatibility with g77. 
2094 It is recommended that these should be used only for code that is 
2095 accessing facilities outside of GNU Fortran, such as operating system 
2096 or windowing facilities.  It is best to constrain such uses to isolated 
2097 portions of a program--portions that deal specifically and exclusively 
2098 with low-level, system-dependent facilities.  Such portions might well 
2099 provide a portable interface for use by the program as a whole, but are 
2100 themselves not portable, and should be thoroughly tested each time they 
2101 are rebuilt using a new compiler or version of a compiler.
2103 @code{%VAL} passes a scalar argument by value, @code{%REF} passes it by 
2104 reference and @code{%LOC} passes its memory location.  Since gfortran 
2105 already passes scalar arguments by reference, @code{%REF} is in effect 
2106 a do-nothing.  @code{%LOC} has the same effect as a Fortran pointer.
2108 An example of passing an argument by value to a C subroutine foo.:
2109 @smallexample
2111 C prototype      void foo_ (float x);
2113       external foo
2114       real*4 x
2115       x = 3.14159
2116       call foo (%VAL (x))
2117       end
2118 @end smallexample
2120 For details refer to the g77 manual
2121 @uref{https://gcc.gnu.org/@/onlinedocs/@/gcc-3.4.6/@/g77/@/index.html#Top}.
2123 Also, @code{c_by_val.f} and its partner @code{c_by_val.c} of the
2124 GNU Fortran testsuite are worth a look.
2126 @node Read/Write after EOF marker
2127 @subsection Read/Write after EOF marker
2128 @cindex @code{EOF}
2129 @cindex @code{BACKSPACE}
2130 @cindex @code{REWIND}
2132 Some legacy codes rely on allowing @code{READ} or @code{WRITE} after the
2133 EOF file marker in order to find the end of a file. GNU Fortran normally
2134 rejects these codes with a run-time error message and suggests the user
2135 consider @code{BACKSPACE} or @code{REWIND} to properly position
2136 the file before the EOF marker.  As an extension, the run-time error may
2137 be disabled using -std=legacy.
2140 @node STRUCTURE and RECORD
2141 @subsection @code{STRUCTURE} and @code{RECORD}
2142 @cindex @code{STRUCTURE}
2143 @cindex @code{RECORD}
2145 Record structures are a pre-Fortran-90 vendor extension to create
2146 user-defined aggregate data types.  Support for record structures in GNU
2147 Fortran can be enabled with the @option{-fdec-structure} compile flag.
2148 If you have a choice, you should instead use Fortran 90's ``derived types'',
2149 which have a different syntax.
2151 In many cases, record structures can easily be converted to derived types.
2152 To convert, replace @code{STRUCTURE /}@var{structure-name}@code{/}
2153 by @code{TYPE} @var{type-name}.  Additionally, replace
2154 @code{RECORD /}@var{structure-name}@code{/} by
2155 @code{TYPE(}@var{type-name}@code{)}. Finally, in the component access,
2156 replace the period (@code{.}) by the percent sign (@code{%}).
2158 Here is an example of code using the non portable record structure syntax:
2160 @example
2161 ! Declaring a structure named ``item'' and containing three fields:
2162 ! an integer ID, an description string and a floating-point price.
2163 STRUCTURE /item/
2164   INTEGER id
2165   CHARACTER(LEN=200) description
2166   REAL price
2167 END STRUCTURE
2169 ! Define two variables, an single record of type ``item''
2170 ! named ``pear'', and an array of items named ``store_catalog''
2171 RECORD /item/ pear, store_catalog(100)
2173 ! We can directly access the fields of both variables
2174 pear.id = 92316
2175 pear.description = "juicy D'Anjou pear"
2176 pear.price = 0.15
2177 store_catalog(7).id = 7831
2178 store_catalog(7).description = "milk bottle"
2179 store_catalog(7).price = 1.2
2181 ! We can also manipulate the whole structure
2182 store_catalog(12) = pear
2183 print *, store_catalog(12)
2184 @end example
2186 @noindent
2187 This code can easily be rewritten in the Fortran 90 syntax as following:
2189 @example
2190 ! ``STRUCTURE /name/ ... END STRUCTURE'' becomes
2191 ! ``TYPE name ... END TYPE''
2192 TYPE item
2193   INTEGER id
2194   CHARACTER(LEN=200) description
2195   REAL price
2196 END TYPE
2198 ! ``RECORD /name/ variable'' becomes ``TYPE(name) variable''
2199 TYPE(item) pear, store_catalog(100)
2201 ! Instead of using a dot (.) to access fields of a record, the
2202 ! standard syntax uses a percent sign (%)
2203 pear%id = 92316
2204 pear%description = "juicy D'Anjou pear"
2205 pear%price = 0.15
2206 store_catalog(7)%id = 7831
2207 store_catalog(7)%description = "milk bottle"
2208 store_catalog(7)%price = 1.2
2210 ! Assignments of a whole variable do not change
2211 store_catalog(12) = pear
2212 print *, store_catalog(12)
2213 @end example
2215 @noindent
2216 GNU Fortran implements STRUCTURES like derived types with the following
2217 rules and exceptions:
2219 @itemize @bullet
2220 @item Structures act like derived types with the @code{SEQUENCE} attribute.
2221 Otherwise they may contain no specifiers.
2223 @item Structures may share names with other symbols. For example, the following
2224 is invalid for derived types, but valid for structures:
2226 @smallexample
2227 structure /header/
2228   ! ...
2229 end structure
2230 record /header/ header
2231 @end smallexample
2233 @item Structure types may be declared nested within another parent structure.
2234 The syntax is:
2235 @smallexample
2236 structure /type-name/
2237     ...
2238     structure [/<type-name>/] <field-list>
2240 @end smallexample
2242 The type name may be ommitted, in which case the structure type itself is
2243 anonymous, and other structures of the same type cannot be instantiated. The
2244 following shows some examples:
2246 @example
2247 structure /appointment/
2248   ! nested structure definition: app_time is an array of two 'time'
2249   structure /time/ app_time (2) 
2250     integer(1) hour, minute
2251   end structure
2252   character(10) memo
2253 end structure
2255 ! The 'time' structure is still usable
2256 record /time/ now
2257 now = time(5, 30)
2261 structure /appointment/
2262   ! anonymous nested structure definition
2263   structure start, end
2264     integer(1) hour, minute
2265   end structure
2266   character(10) memo
2267 end structure
2268 @end example
2270 @item Structures may contain @code{UNION} blocks. For more detail see the
2271 section on @ref{UNION and MAP}.
2273 @item Structures support old-style initialization of components, like
2274 those described in @ref{Old-style variable initialization}. For array
2275 initializers, an initializer may contain a repeat specification of the form
2276 @code{<literal-integer> * <constant-initializer>}. The value of the integer
2277 indicates the number of times to repeat the constant initializer when expanding
2278 the initializer list.
2279 @end itemize
2281 @node UNION and MAP
2282 @subsection @code{UNION} and @code{MAP}
2283 @cindex @code{UNION}
2284 @cindex @code{MAP}
2286 Unions are an old vendor extension which were commonly used with the
2287 non-standard @ref{STRUCTURE and RECORD} extensions. Use of @code{UNION} and
2288 @code{MAP} is automatically enabled with @option{-fdec-structure}.
2290 A @code{UNION} declaration occurs within a structure; within the definition of
2291 each union is a number of @code{MAP} blocks. Each @code{MAP} shares storage
2292 with its sibling maps (in the same union), and the size of the union is the
2293 size of the largest map within it, just as with unions in C. The major
2294 difference is that component references do not indicate which union or map the
2295 component is in (the compiler gets to figure that out).
2297 Here is a small example:
2298 @smallexample
2299 structure /myunion/
2300 union
2301   map
2302     character(2) w0, w1, w2
2303   end map
2304   map
2305     character(6) long
2306   end map
2307 end union
2308 end structure
2310 record /myunion/ rec
2311 ! After this assignment...
2312 rec.long = 'hello!'
2314 ! The following is true:
2315 ! rec.w0 === 'he'
2316 ! rec.w1 === 'll'
2317 ! rec.w2 === 'o!'
2318 @end smallexample
2320 The two maps share memory, and the size of the union is ultimately six bytes:
2322 @example
2323 0    1    2    3    4   5   6     Byte offset
2324 -------------------------------
2325 |    |    |    |    |    |    |
2326 -------------------------------
2328 ^    W0   ^    W1   ^    W2   ^
2329  \-------/ \-------/ \-------/
2331 ^             LONG            ^
2332  \---------------------------/
2333 @end example
2335 Following is an example mirroring the layout of an Intel x86_64 register:
2337 @example
2338 structure /reg/
2339   union ! U0                ! rax
2340     map
2341       character(16) rx
2342     end map
2343     map
2344       character(8) rh         ! rah
2345       union ! U1
2346         map
2347           character(8) rl     ! ral
2348         end map
2349         map
2350           character(8) ex     ! eax
2351         end map
2352         map
2353           character(4) eh     ! eah
2354           union ! U2
2355             map
2356               character(4) el ! eal
2357             end map
2358             map
2359               character(4) x  ! ax
2360             end map
2361             map
2362               character(2) h  ! ah
2363               character(2) l  ! al
2364             end map
2365           end union
2366         end map
2367       end union
2368     end map
2369   end union
2370 end structure
2371 record /reg/ a
2373 ! After this assignment...
2374 a.rx     =     'AAAAAAAA.BBB.C.D'
2376 ! The following is true:
2377 a.rx === 'AAAAAAAA.BBB.C.D'
2378 a.rh === 'AAAAAAAA'
2379 a.rl ===         '.BBB.C.D'
2380 a.ex ===         '.BBB.C.D'
2381 a.eh ===         '.BBB'
2382 a.el ===             '.C.D'
2383 a.x  ===             '.C.D'
2384 a.h  ===             '.C'
2385 a.l  ===               '.D'
2386 @end example
2388 @node Type variants for integer intrinsics
2389 @subsection Type variants for integer intrinsics
2390 @cindex intrinsics, integer
2392 Similar to the D/C prefixes to real functions to specify the input/output
2393 types, GNU Fortran offers B/I/J/K prefixes to integer functions for
2394 compatibility with DEC programs. The types implied by each are:
2396 @example
2397 @code{B} - @code{INTEGER(kind=1)}
2398 @code{I} - @code{INTEGER(kind=2)}
2399 @code{J} - @code{INTEGER(kind=4)}
2400 @code{K} - @code{INTEGER(kind=8)}
2401 @end example
2403 GNU Fortran supports these with the flag @option{-fdec-intrinsic-ints}.
2404 Intrinsics for which prefixed versions are available and in what form are noted
2405 in @ref{Intrinsic Procedures}. The complete list of supported intrinsics is
2406 here:
2408 @multitable @columnfractions .2 .2 .2 .2 .2
2410 @headitem Intrinsic @tab B @tab I @tab J @tab K
2412 @item @code{@ref{ABS}}
2413   @tab @code{BABS} @tab @code{IIABS} @tab @code{JIABS} @tab @code{KIABS}
2414 @item @code{@ref{BTEST}}
2415   @tab @code{BBTEST} @tab @code{BITEST} @tab @code{BJTEST} @tab @code{BKTEST}
2416 @item @code{@ref{IAND}}
2417   @tab @code{BIAND} @tab @code{IIAND} @tab @code{JIAND} @tab @code{KIAND}
2418 @item @code{@ref{IBCLR}}
2419   @tab @code{BBCLR} @tab @code{IIBCLR} @tab @code{JIBCLR} @tab @code{KIBCLR}
2420 @item @code{@ref{IBITS}}
2421   @tab @code{BBITS} @tab @code{IIBITS} @tab @code{JIBITS} @tab @code{KIBITS}
2422 @item @code{@ref{IBSET}}
2423   @tab @code{BBSET} @tab @code{IIBSET} @tab @code{JIBSET} @tab @code{KIBSET}
2424 @item @code{@ref{IEOR}}
2425   @tab @code{BIEOR} @tab @code{IIEOR} @tab @code{JIEOR} @tab @code{KIEOR}
2426 @item @code{@ref{IOR}}
2427   @tab @code{BIOR} @tab @code{IIOR} @tab @code{JIOR} @tab @code{KIOR}
2428 @item @code{@ref{ISHFT}}
2429   @tab @code{BSHFT} @tab @code{IISHFT} @tab @code{JISHFT} @tab @code{KISHFT}
2430 @item @code{@ref{ISHFTC}}
2431   @tab @code{BSHFTC} @tab @code{IISHFTC} @tab @code{JISHFTC} @tab @code{KISHFTC}
2432 @item @code{@ref{MOD}}
2433   @tab @code{BMOD} @tab @code{IMOD} @tab @code{JMOD} @tab @code{KMOD}
2434 @item @code{@ref{NOT}}
2435   @tab @code{BNOT} @tab @code{INOT} @tab @code{JNOT} @tab @code{KNOT}
2436 @item @code{@ref{REAL}}
2437   @tab @code{--} @tab @code{FLOATI} @tab @code{FLOATJ} @tab @code{FLOATK}
2438 @end multitable
2440 @node AUTOMATIC and STATIC attributes
2441 @subsection @code{AUTOMATIC} and @code{STATIC} attributes
2442 @cindex variable attributes
2443 @cindex @code{AUTOMATIC}
2444 @cindex @code{STATIC}
2446 With @option{-fdec-static} GNU Fortran supports the DEC extended attributes
2447 @code{STATIC} and @code{AUTOMATIC} to provide explicit specification of entity
2448 storage.  These follow the syntax of the Fortran standard @code{SAVE} attribute.
2450 @code{STATIC} is exactly equivalent to @code{SAVE}, and specifies that
2451 an entity should be allocated in static memory.  As an example, @code{STATIC}
2452 local variables will retain their values across multiple calls to a function.
2454 Entities marked @code{AUTOMATIC} will be stack automatic whenever possible.
2455 @code{AUTOMATIC} is the default for local variables smaller than
2456 @option{-fmax-stack-var-size}, unless @option{-fno-automatic} is given.  This
2457 attribute overrides @option{-fno-automatic}, @option{-fmax-stack-var-size}, and
2458 blanket @code{SAVE} statements.
2461 Examples:
2463 @example
2464 subroutine f
2465   integer, automatic :: i  ! automatic variable
2466   integer x, y             ! static variables
2467   save
2468   ...
2469 endsubroutine
2470 @end example
2471 @example
2472 subroutine f
2473   integer a, b, c, x, y, z
2474   static :: x
2475   save y
2476   automatic z, c
2477   ! a, b, c, and z are automatic
2478   ! x and y are static
2479 endsubroutine
2480 @end example
2481 @example
2482 ! Compiled with -fno-automatic
2483 subroutine f
2484   integer a, b, c, d
2485   automatic :: a
2486   ! a is automatic; b, c, and d are static
2487 endsubroutine
2488 @end example
2490 @node Extended math intrinsics
2491 @subsection Extended math intrinsics
2492 @cindex intrinsics, math
2493 @cindex intrinsics, trigonometric functions
2495 GNU Fortran supports an extended list of mathematical intrinsics with the
2496 compile flag @option{-fdec-math} for compatability with legacy code.
2497 These intrinsics are described fully in @ref{Intrinsic Procedures} where it is
2498 noted that they are extensions and should be avoided whenever possible.
2500 Specifically, @option{-fdec-math} enables the @ref{COTAN} intrinsic, and
2501 trigonometric intrinsics which accept or produce values in degrees instead of
2502 radians.  Here is a summary of the new intrinsics:
2504 @multitable @columnfractions .5 .5
2505 @headitem Radians @tab Degrees
2506 @item @code{@ref{ACOS}}   @tab @code{@ref{ACOSD}}*
2507 @item @code{@ref{ASIN}}   @tab @code{@ref{ASIND}}*
2508 @item @code{@ref{ATAN}}   @tab @code{@ref{ATAND}}*
2509 @item @code{@ref{ATAN2}}  @tab @code{@ref{ATAN2D}}*
2510 @item @code{@ref{COS}}    @tab @code{@ref{COSD}}*
2511 @item @code{@ref{COTAN}}* @tab @code{@ref{COTAND}}*
2512 @item @code{@ref{SIN}}    @tab @code{@ref{SIND}}*
2513 @item @code{@ref{TAN}}    @tab @code{@ref{TAND}}*
2514 @end multitable
2516 * Enabled with @option{-fdec-math}.
2518 For advanced users, it may be important to know the implementation of these
2519 functions. They are simply wrappers around the standard radian functions, which
2520 have more accurate builtin versions. These functions convert their arguments
2521 (or results) to degrees (or radians) by taking the value modulus 360 (or 2*pi)
2522 and then multiplying it by a constant radian-to-degree (or degree-to-radian)
2523 factor, as appropriate. The factor is computed at compile-time as 180/pi (or
2524 pi/180).
2526 @node Form feed as whitespace
2527 @subsection Form feed as whitespace
2528 @cindex form feed whitespace
2530 Historically, legacy compilers allowed insertion of form feed characters ('\f',
2531 ASCII 0xC) at the beginning of lines for formatted output to line printers,
2532 though the Fortran standard does not mention this. GNU Fortran supports the
2533 interpretation of form feed characters in source as whitespace for
2534 compatibility.
2536 @node TYPE as an alias for PRINT
2537 @subsection TYPE as an alias for PRINT
2538 @cindex type alias print
2539 For compatibility, GNU Fortran will interpret @code{TYPE} statements as
2540 @code{PRINT} statements with the flag @option{-fdec}.  With this flag asserted,
2541 the following two examples are equivalent:
2543 @smallexample
2544 TYPE *, 'hello world'
2545 @end smallexample
2547 @smallexample
2548 PRINT *, 'hello world'
2549 @end smallexample
2551 @node %LOC as an rvalue
2552 @subsection %LOC as an rvalue
2553 @cindex LOC
2554 Normally @code{%LOC} is allowed only in parameter lists.  However the intrinsic
2555 function @code{LOC} does the same thing, and is usable as the right-hand-side of
2556 assignments. For compatibility, GNU Fortran supports the use of @code{%LOC} as
2557 an alias for the builtin @code{LOC} with @option{-std=legacy}.  With this
2558 feature enabled the following two examples are equivalent:
2560 @smallexample
2561 integer :: i, l
2562 l = %loc(i)
2563 call sub(l)
2564 @end smallexample
2566 @smallexample
2567 integer :: i
2568 call sub(%loc(i))
2569 @end smallexample
2571 @node .XOR. operator
2572 @subsection .XOR. operator
2573 @cindex operators, xor
2575 GNU Fortran supports @code{.XOR.} as a logical operator with @code{-std=legacy}
2576 for compatibility with legacy code. @code{.XOR.} is equivalent to
2577 @code{.NEQV.}. That is, the output is true if and only if the inputs differ.
2579 @node Bitwise logical operators
2580 @subsection Bitwise logical operators
2581 @cindex logical, bitwise
2583 With @option{-fdec}, GNU Fortran relaxes the type constraints on
2584 logical operators to allow integer operands, and performs the corresponding
2585 bitwise operation instead.  This flag is for compatibility only, and should be
2586 avoided in new code.  Consider:
2588 @smallexample
2589   INTEGER :: i, j
2590   i = z'33'
2591   j = z'cc'
2592   print *, i .AND. j
2593 @end smallexample
2595 In this example, compiled with @option{-fdec}, GNU Fortran will
2596 replace the @code{.AND.} operation with a call to the intrinsic
2597 @code{@ref{IAND}} function, yielding the bitwise-and of @code{i} and @code{j}.
2599 Note that this conversion will occur if at least one operand is of integral
2600 type.  As a result, a logical operand will be converted to an integer when the
2601 other operand is an integer in a logical operation.  In this case,
2602 @code{.TRUE.} is converted to @code{1} and @code{.FALSE.} to @code{0}.
2604 Here is the mapping of logical operator to bitwise intrinsic used with
2605 @option{-fdec}:
2607 @multitable @columnfractions .25 .25 .5
2608 @headitem Operator @tab Intrinsic @tab Bitwise operation
2609 @item @code{.NOT.} @tab @code{@ref{NOT}} @tab complement
2610 @item @code{.AND.} @tab @code{@ref{IAND}} @tab intersection
2611 @item @code{.OR.} @tab @code{@ref{IOR}} @tab union
2612 @item @code{.NEQV.} @tab @code{@ref{IEOR}} @tab exclusive or
2613 @item @code{.EQV.} @tab @code{@ref{NOT}(@ref{IEOR})} @tab complement of exclusive or
2614 @end multitable
2616 @node Extended I/O specifiers
2617 @subsection Extended I/O specifiers
2618 @cindex @code{CARRIAGECONTROL}
2619 @cindex @code{READONLY}
2620 @cindex @code{SHARE}
2621 @cindex @code{SHARED}
2622 @cindex @code{NOSHARED}
2623 @cindex I/O specifiers
2625 GNU Fortran supports the additional legacy I/O specifiers
2626 @code{CARRIAGECONTROL}, @code{READONLY}, and @code{SHARE} with the
2627 compile flag @option{-fdec}, for compatibility.
2629 @table @code
2630 @item CARRIAGECONTROL
2631 The @code{CARRIAGECONTROL} specifier allows a user to control line
2632 termination settings between output records for an I/O unit. The specifier has
2633 no meaning for readonly files. When @code{CARRAIGECONTROL} is specified upon
2634 opening a unit for formatted writing, the exact @code{CARRIAGECONTROL} setting
2635 determines what characters to write between output records. The syntax is:
2637 @smallexample
2638 OPEN(..., CARRIAGECONTROL=cc)
2639 @end smallexample
2641 Where @emph{cc} is a character expression that evaluates to one of the
2642 following values:
2644 @multitable @columnfractions .2 .8
2645 @item @code{'LIST'} @tab One line feed between records (default)
2646 @item @code{'FORTRAN'} @tab Legacy interpretation of the first character (see below)
2647 @item @code{'NONE'} @tab No separator between records
2648 @end multitable
2650 With @code{CARRIAGECONTROL='FORTRAN'}, when a record is written, the first
2651 character of the input record is not written, and instead determines the output
2652 record separator as follows:
2654 @multitable @columnfractions .3 .3 .4
2655 @headitem Leading character @tab Meaning @tab Output separating character(s)
2656 @item @code{'+'} @tab Overprinting @tab Carriage return only
2657 @item @code{'-'} @tab New line @tab Line feed and carriage return
2658 @item @code{'0'} @tab Skip line @tab Two line feeds and carriage return
2659 @item @code{'1'} @tab New page @tab Form feed and carriage return
2660 @item @code{'$'} @tab Prompting @tab Line feed (no carriage return)
2661 @item @code{CHAR(0)} @tab Overprinting (no advance) @tab None
2662 @end multitable
2664 @item READONLY
2665 The @code{READONLY} specifier may be given upon opening a unit, and is
2666 equivalent to specifying @code{ACTION='READ'}, except that the file may not be
2667 deleted on close (i.e. @code{CLOSE} with @code{STATUS="DELETE"}). The syntax
2670 @smallexample
2671 @code{OPEN(..., READONLY)}
2672 @end smallexample
2674 @item SHARE
2675 The @code{SHARE} specifier allows system-level locking on a unit upon opening
2676 it for controlled access from multiple processes/threads. The @code{SHARE}
2677 specifier has several forms:
2679 @smallexample
2680 OPEN(..., SHARE=sh)
2681 OPEN(..., SHARED)
2682 OPEN(..., NOSHARED)
2683 @end smallexample
2685 Where @emph{sh} in the first form is a character expression that evaluates to
2686 a value as seen in the table below. The latter two forms are aliases
2687 for particular values of @emph{sh}:
2689 @multitable @columnfractions .3 .3 .4
2690 @headitem Explicit form @tab Short form @tab Meaning
2691 @item @code{SHARE='DENYRW'} @tab @code{NOSHARED} @tab Exclusive (write) lock
2692 @item @code{SHARE='DENYNONE'} @tab @code{SHARED} @tab Shared (read) lock
2693 @end multitable
2695 In general only one process may hold an exclusive (write) lock for a given file
2696 at a time, whereas many processes may hold shared (read) locks for the same
2697 file.
2699 The behavior of locking may vary with your operating system. On POSIX systems,
2700 locking is implemented with @code{fcntl}. Consult your corresponding operating
2701 system's manual pages for further details. Locking via @code{SHARE=} is not
2702 supported on other systems.
2704 @end table
2706 @node Legacy PARAMETER statements
2707 @subsection Legacy PARAMETER statements
2708 @cindex PARAMETER
2710 For compatibility, GNU Fortran supports legacy PARAMETER statements without
2711 parentheses with @option{-std=legacy}.  A warning is emitted if used with
2712 @option{-std=gnu}, and an error is acknowledged with a real Fortran standard
2713 flag (@option{-std=f95}, etc...).  These statements take the following form:
2715 @smallexample
2716 implicit real (E)
2717 parameter e = 2.718282
2718 real c
2719 parameter c = 3.0e8
2720 @end smallexample
2722 @node Default exponents
2723 @subsection Default exponents
2724 @cindex exponent
2726 For compatibility, GNU Fortran supports a default exponent of zero in real
2727 constants with @option{-fdec}.  For example, @code{9e} would be
2728 interpreted as @code{9e0}, rather than an error.
2731 @node Extensions not implemented in GNU Fortran
2732 @section Extensions not implemented in GNU Fortran
2733 @cindex extensions, not implemented
2735 The long history of the Fortran language, its wide use and broad
2736 userbase, the large number of different compiler vendors and the lack of
2737 some features crucial to users in the first standards have lead to the
2738 existence of a number of important extensions to the language.  While
2739 some of the most useful or popular extensions are supported by the GNU
2740 Fortran compiler, not all existing extensions are supported.  This section
2741 aims at listing these extensions and offering advice on how best make
2742 code that uses them running with the GNU Fortran compiler.
2744 @c More can be found here:
2745 @c   -- https://gcc.gnu.org/onlinedocs/gcc-3.4.6/g77/Missing-Features.html
2746 @c   -- the list of Fortran and libgfortran bugs closed as WONTFIX:
2747 @c      http://tinyurl.com/2u4h5y
2749 @menu
2750 * ENCODE and DECODE statements::
2751 * Variable FORMAT expressions::
2752 @c * Q edit descriptor::
2753 @c * TYPE and ACCEPT I/O Statements::
2754 @c * DEFAULTFILE, DISPOSE and RECORDTYPE I/O specifiers::
2755 @c * Omitted arguments in procedure call::
2756 * Alternate complex function syntax::
2757 * Volatile COMMON blocks::
2758 * OPEN( ... NAME=)::
2759 @end menu
2761 @node ENCODE and DECODE statements
2762 @subsection @code{ENCODE} and @code{DECODE} statements
2763 @cindex @code{ENCODE}
2764 @cindex @code{DECODE}
2766 GNU Fortran does not support the @code{ENCODE} and @code{DECODE}
2767 statements.  These statements are best replaced by @code{READ} and
2768 @code{WRITE} statements involving internal files (@code{CHARACTER}
2769 variables and arrays), which have been part of the Fortran standard since
2770 Fortran 77.  For example, replace a code fragment like
2772 @smallexample
2773       INTEGER*1 LINE(80)
2774       REAL A, B, C
2775 c     ... Code that sets LINE
2776       DECODE (80, 9000, LINE) A, B, C
2777  9000 FORMAT (1X, 3(F10.5))
2778 @end smallexample
2780 @noindent
2781 with the following:
2783 @smallexample
2784       CHARACTER(LEN=80) LINE
2785       REAL A, B, C
2786 c     ... Code that sets LINE
2787       READ (UNIT=LINE, FMT=9000) A, B, C
2788  9000 FORMAT (1X, 3(F10.5))
2789 @end smallexample
2791 Similarly, replace a code fragment like
2793 @smallexample
2794       INTEGER*1 LINE(80)
2795       REAL A, B, C
2796 c     ... Code that sets A, B and C
2797       ENCODE (80, 9000, LINE) A, B, C
2798  9000 FORMAT (1X, 'OUTPUT IS ', 3(F10.5))
2799 @end smallexample
2801 @noindent
2802 with the following:
2804 @smallexample
2805       CHARACTER(LEN=80) LINE
2806       REAL A, B, C
2807 c     ... Code that sets A, B and C
2808       WRITE (UNIT=LINE, FMT=9000) A, B, C
2809  9000 FORMAT (1X, 'OUTPUT IS ', 3(F10.5))
2810 @end smallexample
2813 @node Variable FORMAT expressions
2814 @subsection Variable @code{FORMAT} expressions
2815 @cindex @code{FORMAT}
2817 A variable @code{FORMAT} expression is format statement which includes
2818 angle brackets enclosing a Fortran expression: @code{FORMAT(I<N>)}.  GNU
2819 Fortran does not support this legacy extension.  The effect of variable
2820 format expressions can be reproduced by using the more powerful (and
2821 standard) combination of internal output and string formats.  For example,
2822 replace a code fragment like this:
2824 @smallexample
2825       WRITE(6,20) INT1
2826  20   FORMAT(I<N+1>)
2827 @end smallexample
2829 @noindent
2830 with the following:
2832 @smallexample
2833 c     Variable declaration
2834       CHARACTER(LEN=20) FMT
2835 c     
2836 c     Other code here...
2838       WRITE(FMT,'("(I", I0, ")")') N+1
2839       WRITE(6,FMT) INT1
2840 @end smallexample
2842 @noindent
2843 or with:
2845 @smallexample
2846 c     Variable declaration
2847       CHARACTER(LEN=20) FMT
2848 c     
2849 c     Other code here...
2851       WRITE(FMT,*) N+1
2852       WRITE(6,"(I" // ADJUSTL(FMT) // ")") INT1
2853 @end smallexample
2856 @node Alternate complex function syntax
2857 @subsection Alternate complex function syntax
2858 @cindex Complex function
2860 Some Fortran compilers, including @command{g77}, let the user declare
2861 complex functions with the syntax @code{COMPLEX FUNCTION name*16()}, as
2862 well as @code{COMPLEX*16 FUNCTION name()}.  Both are non-standard, legacy
2863 extensions.  @command{gfortran} accepts the latter form, which is more
2864 common, but not the former.
2867 @node Volatile COMMON blocks
2868 @subsection Volatile @code{COMMON} blocks
2869 @cindex @code{VOLATILE}
2870 @cindex @code{COMMON}
2872 Some Fortran compilers, including @command{g77}, let the user declare
2873 @code{COMMON} with the @code{VOLATILE} attribute. This is
2874 invalid standard Fortran syntax and is not supported by
2875 @command{gfortran}.  Note that @command{gfortran} accepts
2876 @code{VOLATILE} variables in @code{COMMON} blocks since revision 4.3.
2879 @node OPEN( ... NAME=)
2880 @subsection @code{OPEN( ... NAME=)}
2881 @cindex @code{NAM}
2883 Some Fortran compilers, including @command{g77}, let the user declare
2884 @code{OPEN( ... NAME=)}. This is
2885 invalid standard Fortran syntax and is not supported by
2886 @command{gfortran}.  @code{OPEN( ... NAME=)} should be replaced
2887 with @code{OPEN( ... FILE=)}.
2891 @c ---------------------------------------------------------------------
2892 @c ---------------------------------------------------------------------
2893 @c Mixed-Language Programming
2894 @c ---------------------------------------------------------------------
2896 @node Mixed-Language Programming
2897 @chapter Mixed-Language Programming
2898 @cindex Interoperability
2899 @cindex Mixed-language programming
2901 @menu
2902 * Interoperability with C::
2903 * GNU Fortran Compiler Directives::
2904 * Non-Fortran Main Program::
2905 * Naming and argument-passing conventions::
2906 @end menu
2908 This chapter is about mixed-language interoperability, but also applies
2909 if one links Fortran code compiled by different compilers.  In most cases,
2910 use of the C Binding features of the Fortran 2003 standard is sufficient,
2911 and their use is highly recommended.
2914 @node Interoperability with C
2915 @section Interoperability with C
2917 @menu
2918 * Intrinsic Types::
2919 * Derived Types and struct::
2920 * Interoperable Global Variables::
2921 * Interoperable Subroutines and Functions::
2922 * Working with Pointers::
2923 * Further Interoperability of Fortran with C::
2924 @end menu
2926 Since Fortran 2003 (ISO/IEC 1539-1:2004(E)) there is a
2927 standardized way to generate procedure and derived-type
2928 declarations and global variables which are interoperable with C
2929 (ISO/IEC 9899:1999).  The @code{bind(C)} attribute has been added
2930 to inform the compiler that a symbol shall be interoperable with C;
2931 also, some constraints are added.  Note, however, that not
2932 all C features have a Fortran equivalent or vice versa.  For instance,
2933 neither C's unsigned integers nor C's functions with variable number
2934 of arguments have an equivalent in Fortran.
2936 Note that array dimensions are reversely ordered in C and that arrays in
2937 C always start with index 0 while in Fortran they start by default with
2938 1.  Thus, an array declaration @code{A(n,m)} in Fortran matches
2939 @code{A[m][n]} in C and accessing the element @code{A(i,j)} matches
2940 @code{A[j-1][i-1]}.  The element following @code{A(i,j)} (C: @code{A[j-1][i-1]};
2941 assuming @math{i < n}) in memory is @code{A(i+1,j)} (C: @code{A[j-1][i]}).
2943 @node Intrinsic Types
2944 @subsection Intrinsic Types
2946 In order to ensure that exactly the same variable type and kind is used
2947 in C and Fortran, the named constants shall be used which are defined in the
2948 @code{ISO_C_BINDING} intrinsic module.  That module contains named constants
2949 for kind parameters and character named constants for the escape sequences
2950 in C.  For a list of the constants, see @ref{ISO_C_BINDING}.
2952 For logical types, please note that the Fortran standard only guarantees
2953 interoperability between C99's @code{_Bool} and Fortran's @code{C_Bool}-kind
2954 logicals and C99 defines that @code{true} has the value 1 and @code{false}
2955 the value 0.  Using any other integer value with GNU Fortran's @code{LOGICAL}
2956 (with any kind parameter) gives an undefined result.  (Passing other integer
2957 values than 0 and 1 to GCC's @code{_Bool} is also undefined, unless the
2958 integer is explicitly or implicitly casted to @code{_Bool}.)
2962 @node Derived Types and struct
2963 @subsection Derived Types and struct
2965 For compatibility of derived types with @code{struct}, one needs to use
2966 the @code{BIND(C)} attribute in the type declaration.  For instance, the
2967 following type declaration
2969 @smallexample
2970  USE ISO_C_BINDING
2971  TYPE, BIND(C) :: myType
2972    INTEGER(C_INT) :: i1, i2
2973    INTEGER(C_SIGNED_CHAR) :: i3
2974    REAL(C_DOUBLE) :: d1
2975    COMPLEX(C_FLOAT_COMPLEX) :: c1
2976    CHARACTER(KIND=C_CHAR) :: str(5)
2977  END TYPE
2978 @end smallexample
2980 matches the following @code{struct} declaration in C
2982 @smallexample
2983  struct @{
2984    int i1, i2;
2985    /* Note: "char" might be signed or unsigned.  */
2986    signed char i3;
2987    double d1;
2988    float _Complex c1;
2989    char str[5];
2990  @} myType;
2991 @end smallexample
2993 Derived types with the C binding attribute shall not have the @code{sequence}
2994 attribute, type parameters, the @code{extends} attribute, nor type-bound
2995 procedures.  Every component must be of interoperable type and kind and may not
2996 have the @code{pointer} or @code{allocatable} attribute.  The names of the
2997 components are irrelevant for interoperability.
2999 As there exist no direct Fortran equivalents, neither unions nor structs
3000 with bit field or variable-length array members are interoperable.
3002 @node Interoperable Global Variables
3003 @subsection Interoperable Global Variables
3005 Variables can be made accessible from C using the C binding attribute,
3006 optionally together with specifying a binding name.  Those variables
3007 have to be declared in the declaration part of a @code{MODULE},
3008 be of interoperable type, and have neither the @code{pointer} nor
3009 the @code{allocatable} attribute.
3011 @smallexample
3012   MODULE m
3013     USE myType_module
3014     USE ISO_C_BINDING
3015     integer(C_INT), bind(C, name="_MyProject_flags") :: global_flag
3016     type(myType), bind(C) :: tp
3017   END MODULE
3018 @end smallexample
3020 Here, @code{_MyProject_flags} is the case-sensitive name of the variable
3021 as seen from C programs while @code{global_flag} is the case-insensitive
3022 name as seen from Fortran.  If no binding name is specified, as for
3023 @var{tp}, the C binding name is the (lowercase) Fortran binding name.
3024 If a binding name is specified, only a single variable may be after the
3025 double colon.  Note of warning: You cannot use a global variable to
3026 access @var{errno} of the C library as the C standard allows it to be
3027 a macro.  Use the @code{IERRNO} intrinsic (GNU extension) instead.
3029 @node Interoperable Subroutines and Functions
3030 @subsection Interoperable Subroutines and Functions
3032 Subroutines and functions have to have the @code{BIND(C)} attribute to
3033 be compatible with C.  The dummy argument declaration is relatively
3034 straightforward.  However, one needs to be careful because C uses
3035 call-by-value by default while Fortran behaves usually similar to
3036 call-by-reference.  Furthermore, strings and pointers are handled
3037 differently.  Note that in Fortran 2003 and 2008 only explicit size
3038 and assumed-size arrays are supported but not assumed-shape or
3039 deferred-shape (i.e. allocatable or pointer) arrays.  However, those
3040 are allowed since the Technical Specification 29113, see
3041 @ref{Further Interoperability of Fortran with C}
3043 To pass a variable by value, use the @code{VALUE} attribute.
3044 Thus, the following C prototype
3046 @smallexample
3047 @code{int func(int i, int *j)}
3048 @end smallexample
3050 matches the Fortran declaration
3052 @smallexample
3053   integer(c_int) function func(i,j)
3054     use iso_c_binding, only: c_int
3055     integer(c_int), VALUE :: i
3056     integer(c_int) :: j
3057 @end smallexample
3059 Note that pointer arguments also frequently need the @code{VALUE} attribute,
3060 see @ref{Working with Pointers}.
3062 Strings are handled quite differently in C and Fortran.  In C a string
3063 is a @code{NUL}-terminated array of characters while in Fortran each string
3064 has a length associated with it and is thus not terminated (by e.g.
3065 @code{NUL}).  For example, if one wants to use the following C function,
3067 @smallexample
3068   #include <stdio.h>
3069   void print_C(char *string) /* equivalent: char string[]  */
3070   @{
3071      printf("%s\n", string);
3072   @}
3073 @end smallexample
3075 to print ``Hello World'' from Fortran, one can call it using
3077 @smallexample
3078   use iso_c_binding, only: C_CHAR, C_NULL_CHAR
3079   interface
3080     subroutine print_c(string) bind(C, name="print_C")
3081       use iso_c_binding, only: c_char
3082       character(kind=c_char) :: string(*)
3083     end subroutine print_c
3084   end interface
3085   call print_c(C_CHAR_"Hello World"//C_NULL_CHAR)
3086 @end smallexample
3088 As the example shows, one needs to ensure that the
3089 string is @code{NUL} terminated.  Additionally, the dummy argument
3090 @var{string} of @code{print_C} is a length-one assumed-size
3091 array; using @code{character(len=*)} is not allowed.  The example
3092 above uses @code{c_char_"Hello World"} to ensure the string
3093 literal has the right type; typically the default character
3094 kind and @code{c_char} are the same and thus @code{"Hello World"}
3095 is equivalent.  However, the standard does not guarantee this.
3097 The use of strings is now further illustrated using the C library
3098 function @code{strncpy}, whose prototype is
3100 @smallexample
3101   char *strncpy(char *restrict s1, const char *restrict s2, size_t n);
3102 @end smallexample
3104 The function @code{strncpy} copies at most @var{n} characters from
3105 string @var{s2} to @var{s1} and returns @var{s1}.  In the following
3106 example, we ignore the return value:
3108 @smallexample
3109   use iso_c_binding
3110   implicit none
3111   character(len=30) :: str,str2
3112   interface
3113     ! Ignore the return value of strncpy -> subroutine
3114     ! "restrict" is always assumed if we do not pass a pointer
3115     subroutine strncpy(dest, src, n) bind(C)
3116       import
3117       character(kind=c_char),  intent(out) :: dest(*)
3118       character(kind=c_char),  intent(in)  :: src(*)
3119       integer(c_size_t), value, intent(in) :: n
3120     end subroutine strncpy
3121   end interface
3122   str = repeat('X',30) ! Initialize whole string with 'X'
3123   call strncpy(str, c_char_"Hello World"//C_NULL_CHAR, &
3124                len(c_char_"Hello World",kind=c_size_t))
3125   print '(a)', str ! prints: "Hello WorldXXXXXXXXXXXXXXXXXXX"
3126   end
3127 @end smallexample
3129 The intrinsic procedures are described in @ref{Intrinsic Procedures}.
3131 @node Working with Pointers
3132 @subsection Working with Pointers
3134 C pointers are represented in Fortran via the special opaque derived type
3135 @code{type(c_ptr)} (with private components).  Thus one needs to
3136 use intrinsic conversion procedures to convert from or to C pointers.
3138 For some applications, using an assumed type (@code{TYPE(*)}) can be an
3139 alternative to a C pointer; see
3140 @ref{Further Interoperability of Fortran with C}.
3142 For example,
3144 @smallexample
3145   use iso_c_binding
3146   type(c_ptr) :: cptr1, cptr2
3147   integer, target :: array(7), scalar
3148   integer, pointer :: pa(:), ps
3149   cptr1 = c_loc(array(1)) ! The programmer needs to ensure that the
3150                           ! array is contiguous if required by the C
3151                           ! procedure
3152   cptr2 = c_loc(scalar)
3153   call c_f_pointer(cptr2, ps)
3154   call c_f_pointer(cptr2, pa, shape=[7])
3155 @end smallexample
3157 When converting C to Fortran arrays, the one-dimensional @code{SHAPE} argument
3158 has to be passed.
3160 If a pointer is a dummy-argument of an interoperable procedure, it usually
3161 has to be declared using the @code{VALUE} attribute.  @code{void*}
3162 matches @code{TYPE(C_PTR), VALUE}, while @code{TYPE(C_PTR)} alone
3163 matches @code{void**}.
3165 Procedure pointers are handled analogously to pointers; the C type is
3166 @code{TYPE(C_FUNPTR)} and the intrinsic conversion procedures are
3167 @code{C_F_PROCPOINTER} and @code{C_FUNLOC}.
3169 Let us consider two examples of actually passing a procedure pointer from
3170 C to Fortran and vice versa.  Note that these examples are also very
3171 similar to passing ordinary pointers between both languages. First,
3172 consider this code in C:
3174 @smallexample
3175 /* Procedure implemented in Fortran.  */
3176 void get_values (void (*)(double));
3178 /* Call-back routine we want called from Fortran.  */
3179 void
3180 print_it (double x)
3182   printf ("Number is %f.\n", x);
3185 /* Call Fortran routine and pass call-back to it.  */
3186 void
3187 foobar ()
3189   get_values (&print_it);
3191 @end smallexample
3193 A matching implementation for @code{get_values} in Fortran, that correctly
3194 receives the procedure pointer from C and is able to call it, is given
3195 in the following @code{MODULE}:
3197 @smallexample
3198 MODULE m
3199   IMPLICIT NONE
3201   ! Define interface of call-back routine.
3202   ABSTRACT INTERFACE
3203     SUBROUTINE callback (x)
3204       USE, INTRINSIC :: ISO_C_BINDING
3205       REAL(KIND=C_DOUBLE), INTENT(IN), VALUE :: x
3206     END SUBROUTINE callback
3207   END INTERFACE
3209 CONTAINS
3211   ! Define C-bound procedure.
3212   SUBROUTINE get_values (cproc) BIND(C)
3213     USE, INTRINSIC :: ISO_C_BINDING
3214     TYPE(C_FUNPTR), INTENT(IN), VALUE :: cproc
3216     PROCEDURE(callback), POINTER :: proc
3218     ! Convert C to Fortran procedure pointer.
3219     CALL C_F_PROCPOINTER (cproc, proc)
3221     ! Call it.
3222     CALL proc (1.0_C_DOUBLE)
3223     CALL proc (-42.0_C_DOUBLE)
3224     CALL proc (18.12_C_DOUBLE)
3225   END SUBROUTINE get_values
3227 END MODULE m
3228 @end smallexample
3230 Next, we want to call a C routine that expects a procedure pointer argument
3231 and pass it a Fortran procedure (which clearly must be interoperable!).
3232 Again, the C function may be:
3234 @smallexample
3236 call_it (int (*func)(int), int arg)
3238   return func (arg);
3240 @end smallexample
3242 It can be used as in the following Fortran code:
3244 @smallexample
3245 MODULE m
3246   USE, INTRINSIC :: ISO_C_BINDING
3247   IMPLICIT NONE
3249   ! Define interface of C function.
3250   INTERFACE
3251     INTEGER(KIND=C_INT) FUNCTION call_it (func, arg) BIND(C)
3252       USE, INTRINSIC :: ISO_C_BINDING
3253       TYPE(C_FUNPTR), INTENT(IN), VALUE :: func
3254       INTEGER(KIND=C_INT), INTENT(IN), VALUE :: arg
3255     END FUNCTION call_it
3256   END INTERFACE
3258 CONTAINS
3260   ! Define procedure passed to C function.
3261   ! It must be interoperable!
3262   INTEGER(KIND=C_INT) FUNCTION double_it (arg) BIND(C)
3263     INTEGER(KIND=C_INT), INTENT(IN), VALUE :: arg
3264     double_it = arg + arg
3265   END FUNCTION double_it
3267   ! Call C function.
3268   SUBROUTINE foobar ()
3269     TYPE(C_FUNPTR) :: cproc
3270     INTEGER(KIND=C_INT) :: i
3272     ! Get C procedure pointer.
3273     cproc = C_FUNLOC (double_it)
3275     ! Use it.
3276     DO i = 1_C_INT, 10_C_INT
3277       PRINT *, call_it (cproc, i)
3278     END DO
3279   END SUBROUTINE foobar
3281 END MODULE m
3282 @end smallexample
3284 @node Further Interoperability of Fortran with C
3285 @subsection Further Interoperability of Fortran with C
3287 The Technical Specification ISO/IEC TS 29113:2012 on further
3288 interoperability of Fortran with C extends the interoperability support
3289 of Fortran 2003 and Fortran 2008. Besides removing some restrictions
3290 and constraints, it adds assumed-type (@code{TYPE(*)}) and assumed-rank
3291 (@code{dimension}) variables and allows for interoperability of
3292 assumed-shape, assumed-rank and deferred-shape arrays, including
3293 allocatables and pointers.
3295 Note: Currently, GNU Fortran does not support the array descriptor
3296 (dope vector) as specified in the Technical Specification, but uses
3297 an array descriptor with different fields. The Chasm Language
3298 Interoperability Tools, @url{http://chasm-interop.sourceforge.net/},
3299 provide an interface to GNU Fortran's array descriptor.
3301 The Technical Specification adds the following new features, which
3302 are supported by GNU Fortran:
3304 @itemize @bullet
3306 @item The @code{ASYNCHRONOUS} attribute has been clarified and
3307 extended to allow its use with asynchronous communication in
3308 user-provided libraries such as in implementations of the
3309 Message Passing Interface specification.
3311 @item Many constraints have been relaxed, in particular for
3312 the @code{C_LOC} and @code{C_F_POINTER} intrinsics.
3314 @item The @code{OPTIONAL} attribute is now allowed for dummy
3315 arguments; an absent argument matches a @code{NULL} pointer.
3317 @item Assumed types (@code{TYPE(*)}) have been added, which may
3318 only be used for dummy arguments.  They are unlimited polymorphic
3319 but contrary to @code{CLASS(*)} they do not contain any type
3320 information, similar to C's @code{void *} pointers.  Expressions
3321 of any type and kind can be passed; thus, it can be used as
3322 replacement for @code{TYPE(C_PTR)}, avoiding the use of
3323 @code{C_LOC} in the caller.
3325 Note, however, that @code{TYPE(*)} only accepts scalar arguments,
3326 unless the @code{DIMENSION} is explicitly specified.  As
3327 @code{DIMENSION(*)} only supports array (including array elements) but
3328 no scalars, it is not a full replacement for @code{C_LOC}.  On the
3329 other hand, assumed-type assumed-rank dummy arguments
3330 (@code{TYPE(*), DIMENSION(..)}) allow for both scalars and arrays, but
3331 require special code on the callee side to handle the array descriptor.
3333 @item Assumed-rank arrays (@code{DIMENSION(..)}) as dummy argument
3334 allow that scalars and arrays of any rank can be passed as actual
3335 argument. As the Technical Specification does not provide for direct
3336 means to operate with them, they have to be used either from the C side
3337 or be converted using @code{C_LOC} and @code{C_F_POINTER} to scalars
3338 or arrays of a specific rank. The rank can be determined using the
3339 @code{RANK} intrinisic.
3340 @end itemize
3343 Currently unimplemented:
3345 @itemize @bullet
3347 @item GNU Fortran always uses an array descriptor, which does not
3348 match the one of the Technical Specification. The
3349 @code{ISO_Fortran_binding.h} header file and the C functions it
3350 specifies are not available.
3352 @item Using assumed-shape, assumed-rank and deferred-shape arrays in
3353 @code{BIND(C)} procedures is not fully supported. In particular,
3354 C interoperable strings of other length than one are not supported
3355 as this requires the new array descriptor.
3356 @end itemize
3359 @node GNU Fortran Compiler Directives
3360 @section GNU Fortran Compiler Directives
3362 The Fortran standard describes how a conforming program shall
3363 behave; however, the exact implementation is not standardized.  In order
3364 to allow the user to choose specific implementation details, compiler
3365 directives can be used to set attributes of variables and procedures
3366 which are not part of the standard.  Whether a given attribute is
3367 supported and its exact effects depend on both the operating system and
3368 on the processor; see
3369 @ref{Top,,C Extensions,gcc,Using the GNU Compiler Collection (GCC)}
3370 for details.
3372 For procedures and procedure pointers, the following attributes can
3373 be used to change the calling convention:
3375 @itemize
3376 @item @code{CDECL} -- standard C calling convention
3377 @item @code{STDCALL} -- convention where the called procedure pops the stack
3378 @item @code{FASTCALL} -- part of the arguments are passed via registers
3379 instead using the stack
3380 @end itemize
3382 Besides changing the calling convention, the attributes also influence
3383 the decoration of the symbol name, e.g., by a leading underscore or by
3384 a trailing at-sign followed by the number of bytes on the stack.  When
3385 assigning a procedure to a procedure pointer, both should use the same
3386 calling convention.
3388 On some systems, procedures and global variables (module variables and
3389 @code{COMMON} blocks) need special handling to be accessible when they
3390 are in a shared library.  The following attributes are available:
3392 @itemize
3393 @item @code{DLLEXPORT} -- provide a global pointer to a pointer in the DLL
3394 @item @code{DLLIMPORT} -- reference the function or variable using a
3395 global pointer
3396 @end itemize
3398 For dummy arguments, the @code{NO_ARG_CHECK} attribute can be used; in
3399 other compilers, it is also known as @code{IGNORE_TKR}.  For dummy arguments
3400 with this attribute actual arguments of any type and kind (similar to
3401 @code{TYPE(*)}), scalars and arrays of any rank (no equivalent
3402 in Fortran standard) are accepted.  As with @code{TYPE(*)}, the argument
3403 is unlimited polymorphic and no type information is available.
3404 Additionally, the argument may only be passed to dummy arguments
3405 with the @code{NO_ARG_CHECK} attribute and as argument to the
3406 @code{PRESENT} intrinsic function and to @code{C_LOC} of the
3407 @code{ISO_C_BINDING} module.
3409 Variables with @code{NO_ARG_CHECK} attribute shall be of assumed-type
3410 (@code{TYPE(*)}; recommended) or of type @code{INTEGER}, @code{LOGICAL},
3411 @code{REAL} or @code{COMPLEX}. They shall not have the @code{ALLOCATE},
3412 @code{CODIMENSION}, @code{INTENT(OUT)}, @code{POINTER} or @code{VALUE}
3413 attribute; furthermore, they shall be either scalar or of assumed-size
3414 (@code{dimension(*)}). As @code{TYPE(*)}, the @code{NO_ARG_CHECK} attribute
3415 requires an explicit interface.
3417 @itemize
3418 @item @code{NO_ARG_CHECK} -- disable the type, kind and rank checking
3419 @end itemize
3422 The attributes are specified using the syntax
3424 @code{!GCC$ ATTRIBUTES} @var{attribute-list} @code{::} @var{variable-list}
3426 where in free-form source code only whitespace is allowed before @code{!GCC$}
3427 and in fixed-form source code @code{!GCC$}, @code{cGCC$} or @code{*GCC$} shall
3428 start in the first column.
3430 For procedures, the compiler directives shall be placed into the body
3431 of the procedure; for variables and procedure pointers, they shall be in
3432 the same declaration part as the variable or procedure pointer.
3436 @node Non-Fortran Main Program
3437 @section Non-Fortran Main Program
3439 @menu
3440 * _gfortran_set_args:: Save command-line arguments
3441 * _gfortran_set_options:: Set library option flags
3442 * _gfortran_set_convert:: Set endian conversion
3443 * _gfortran_set_record_marker:: Set length of record markers
3444 * _gfortran_set_fpe:: Set when a Floating Point Exception should be raised
3445 * _gfortran_set_max_subrecord_length:: Set subrecord length
3446 @end menu
3448 Even if you are doing mixed-language programming, it is very
3449 likely that you do not need to know or use the information in this
3450 section.  Since it is about the internal structure of GNU Fortran,
3451 it may also change in GCC minor releases.
3453 When you compile a @code{PROGRAM} with GNU Fortran, a function
3454 with the name @code{main} (in the symbol table of the object file)
3455 is generated, which initializes the libgfortran library and then
3456 calls the actual program which uses the name @code{MAIN__}, for
3457 historic reasons.  If you link GNU Fortran compiled procedures
3458 to, e.g., a C or C++ program or to a Fortran program compiled by
3459 a different compiler, the libgfortran library is not initialized
3460 and thus a few intrinsic procedures do not work properly, e.g.
3461 those for obtaining the command-line arguments.
3463 Therefore, if your @code{PROGRAM} is not compiled with
3464 GNU Fortran and the GNU Fortran compiled procedures require
3465 intrinsics relying on the library initialization, you need to
3466 initialize the library yourself.  Using the default options,
3467 gfortran calls @code{_gfortran_set_args} and
3468 @code{_gfortran_set_options}.  The initialization of the former
3469 is needed if the called procedures access the command line
3470 (and for backtracing); the latter sets some flags based on the
3471 standard chosen or to enable backtracing.  In typical programs,
3472 it is not necessary to call any initialization function.
3474 If your @code{PROGRAM} is compiled with GNU Fortran, you shall
3475 not call any of the following functions.  The libgfortran
3476 initialization functions are shown in C syntax but using C
3477 bindings they are also accessible from Fortran.
3480 @node _gfortran_set_args
3481 @subsection @code{_gfortran_set_args} --- Save command-line arguments
3482 @fnindex _gfortran_set_args
3483 @cindex libgfortran initialization, set_args
3485 @table @asis
3486 @item @emph{Description}:
3487 @code{_gfortran_set_args} saves the command-line arguments; this
3488 initialization is required if any of the command-line intrinsics
3489 is called.  Additionally, it shall be called if backtracing is
3490 enabled (see @code{_gfortran_set_options}).
3492 @item @emph{Syntax}:
3493 @code{void _gfortran_set_args (int argc, char *argv[])}
3495 @item @emph{Arguments}:
3496 @multitable @columnfractions .15 .70
3497 @item @var{argc} @tab number of command line argument strings
3498 @item @var{argv} @tab the command-line argument strings; argv[0]
3499 is the pathname of the executable itself.
3500 @end multitable
3502 @item @emph{Example}:
3503 @smallexample
3504 int main (int argc, char *argv[])
3506   /* Initialize libgfortran.  */
3507   _gfortran_set_args (argc, argv);
3508   return 0;
3510 @end smallexample
3511 @end table
3514 @node _gfortran_set_options
3515 @subsection @code{_gfortran_set_options} --- Set library option flags
3516 @fnindex _gfortran_set_options
3517 @cindex libgfortran initialization, set_options
3519 @table @asis
3520 @item @emph{Description}:
3521 @code{_gfortran_set_options} sets several flags related to the Fortran
3522 standard to be used, whether backtracing should be enabled
3523 and whether range checks should be performed.  The syntax allows for
3524 upward compatibility since the number of passed flags is specified; for
3525 non-passed flags, the default value is used.  See also
3526 @pxref{Code Gen Options}.  Please note that not all flags are actually
3527 used.
3529 @item @emph{Syntax}:
3530 @code{void _gfortran_set_options (int num, int options[])}
3532 @item @emph{Arguments}:
3533 @multitable @columnfractions .15 .70
3534 @item @var{num} @tab number of options passed
3535 @item @var{argv} @tab The list of flag values
3536 @end multitable
3538 @item @emph{option flag list}:
3539 @multitable @columnfractions .15 .70
3540 @item @var{option}[0] @tab Allowed standard; can give run-time errors
3541 if e.g. an input-output edit descriptor is invalid in a given standard.
3542 Possible values are (bitwise or-ed) @code{GFC_STD_F77} (1),
3543 @code{GFC_STD_F95_OBS} (2), @code{GFC_STD_F95_DEL} (4), @code{GFC_STD_F95}
3544 (8), @code{GFC_STD_F2003} (16), @code{GFC_STD_GNU} (32),
3545 @code{GFC_STD_LEGACY} (64), @code{GFC_STD_F2008} (128),
3546 @code{GFC_STD_F2008_OBS} (256) and GFC_STD_F2008_TS (512). Default:
3547 @code{GFC_STD_F95_OBS | GFC_STD_F95_DEL | GFC_STD_F95 | GFC_STD_F2003
3548 | GFC_STD_F2008 | GFC_STD_F2008_TS | GFC_STD_F2008_OBS | GFC_STD_F77
3549 | GFC_STD_GNU | GFC_STD_LEGACY}.
3550 @item @var{option}[1] @tab Standard-warning flag; prints a warning to
3551 standard error.  Default: @code{GFC_STD_F95_DEL | GFC_STD_LEGACY}.
3552 @item @var{option}[2] @tab If non zero, enable pedantic checking.
3553 Default: off.
3554 @item @var{option}[3] @tab Unused.
3555 @item @var{option}[4] @tab If non zero, enable backtracing on run-time
3556 errors.  Default: off. (Default in the compiler: on.)
3557 Note: Installs a signal handler and requires command-line
3558 initialization using @code{_gfortran_set_args}.
3559 @item @var{option}[5] @tab If non zero, supports signed zeros.
3560 Default: enabled.
3561 @item @var{option}[6] @tab Enables run-time checking.  Possible values
3562 are (bitwise or-ed): GFC_RTCHECK_BOUNDS (1), GFC_RTCHECK_ARRAY_TEMPS (2),
3563 GFC_RTCHECK_RECURSION (4), GFC_RTCHECK_DO (16), GFC_RTCHECK_POINTER (32).
3564 Default: disabled.
3565 @item @var{option}[7] @tab Unused.
3566 @item @var{option}[8] @tab Show a warning when invoking @code{STOP} and
3567 @code{ERROR STOP} if a floating-point exception occurred. Possible values
3568 are (bitwise or-ed) @code{GFC_FPE_INVALID} (1), @code{GFC_FPE_DENORMAL} (2),
3569 @code{GFC_FPE_ZERO} (4), @code{GFC_FPE_OVERFLOW} (8),
3570 @code{GFC_FPE_UNDERFLOW} (16), @code{GFC_FPE_INEXACT} (32). Default: None (0).
3571 (Default in the compiler: @code{GFC_FPE_INVALID | GFC_FPE_DENORMAL |
3572 GFC_FPE_ZERO | GFC_FPE_OVERFLOW | GFC_FPE_UNDERFLOW}.)
3573 @end multitable
3575 @item @emph{Example}:
3576 @smallexample
3577   /* Use gfortran 4.9 default options.  */
3578   static int options[] = @{68, 511, 0, 0, 1, 1, 0, 0, 31@};
3579   _gfortran_set_options (9, &options);
3580 @end smallexample
3581 @end table
3584 @node _gfortran_set_convert
3585 @subsection @code{_gfortran_set_convert} --- Set endian conversion
3586 @fnindex _gfortran_set_convert
3587 @cindex libgfortran initialization, set_convert
3589 @table @asis
3590 @item @emph{Description}:
3591 @code{_gfortran_set_convert} set the representation of data for
3592 unformatted files.
3594 @item @emph{Syntax}:
3595 @code{void _gfortran_set_convert (int conv)}
3597 @item @emph{Arguments}:
3598 @multitable @columnfractions .15 .70
3599 @item @var{conv} @tab Endian conversion, possible values:
3600 GFC_CONVERT_NATIVE (0, default), GFC_CONVERT_SWAP (1),
3601 GFC_CONVERT_BIG (2), GFC_CONVERT_LITTLE (3).
3602 @end multitable
3604 @item @emph{Example}:
3605 @smallexample
3606 int main (int argc, char *argv[])
3608   /* Initialize libgfortran.  */
3609   _gfortran_set_args (argc, argv);
3610   _gfortran_set_convert (1);
3611   return 0;
3613 @end smallexample
3614 @end table
3617 @node _gfortran_set_record_marker
3618 @subsection @code{_gfortran_set_record_marker} --- Set length of record markers
3619 @fnindex _gfortran_set_record_marker
3620 @cindex libgfortran initialization, set_record_marker
3622 @table @asis
3623 @item @emph{Description}:
3624 @code{_gfortran_set_record_marker} sets the length of record markers
3625 for unformatted files.
3627 @item @emph{Syntax}:
3628 @code{void _gfortran_set_record_marker (int val)}
3630 @item @emph{Arguments}:
3631 @multitable @columnfractions .15 .70
3632 @item @var{val} @tab Length of the record marker; valid values
3633 are 4 and 8.  Default is 4.
3634 @end multitable
3636 @item @emph{Example}:
3637 @smallexample
3638 int main (int argc, char *argv[])
3640   /* Initialize libgfortran.  */
3641   _gfortran_set_args (argc, argv);
3642   _gfortran_set_record_marker (8);
3643   return 0;
3645 @end smallexample
3646 @end table
3649 @node _gfortran_set_fpe
3650 @subsection @code{_gfortran_set_fpe} --- Enable floating point exception traps
3651 @fnindex _gfortran_set_fpe
3652 @cindex libgfortran initialization, set_fpe
3654 @table @asis
3655 @item @emph{Description}:
3656 @code{_gfortran_set_fpe} enables floating point exception traps for
3657 the specified exceptions.  On most systems, this will result in a
3658 SIGFPE signal being sent and the program being aborted.
3660 @item @emph{Syntax}:
3661 @code{void _gfortran_set_fpe (int val)}
3663 @item @emph{Arguments}:
3664 @multitable @columnfractions .15 .70
3665 @item @var{option}[0] @tab IEEE exceptions.  Possible values are
3666 (bitwise or-ed) zero (0, default) no trapping,
3667 @code{GFC_FPE_INVALID} (1), @code{GFC_FPE_DENORMAL} (2),
3668 @code{GFC_FPE_ZERO} (4), @code{GFC_FPE_OVERFLOW} (8),
3669 @code{GFC_FPE_UNDERFLOW} (16), and @code{GFC_FPE_INEXACT} (32).
3670 @end multitable
3672 @item @emph{Example}:
3673 @smallexample
3674 int main (int argc, char *argv[])
3676   /* Initialize libgfortran.  */
3677   _gfortran_set_args (argc, argv);
3678   /* FPE for invalid operations such as SQRT(-1.0).  */
3679   _gfortran_set_fpe (1);
3680   return 0;
3682 @end smallexample
3683 @end table
3686 @node _gfortran_set_max_subrecord_length
3687 @subsection @code{_gfortran_set_max_subrecord_length} --- Set subrecord length
3688 @fnindex _gfortran_set_max_subrecord_length
3689 @cindex libgfortran initialization, set_max_subrecord_length
3691 @table @asis
3692 @item @emph{Description}:
3693 @code{_gfortran_set_max_subrecord_length} set the maximum length
3694 for a subrecord.  This option only makes sense for testing and
3695 debugging of unformatted I/O.
3697 @item @emph{Syntax}:
3698 @code{void _gfortran_set_max_subrecord_length (int val)}
3700 @item @emph{Arguments}:
3701 @multitable @columnfractions .15 .70
3702 @item @var{val} @tab the maximum length for a subrecord;
3703 the maximum permitted value is 2147483639, which is also
3704 the default.
3705 @end multitable
3707 @item @emph{Example}:
3708 @smallexample
3709 int main (int argc, char *argv[])
3711   /* Initialize libgfortran.  */
3712   _gfortran_set_args (argc, argv);
3713   _gfortran_set_max_subrecord_length (8);
3714   return 0;
3716 @end smallexample
3717 @end table
3720 @node Naming and argument-passing conventions
3721 @section Naming and argument-passing conventions
3723 This section gives an overview about the naming convention of procedures
3724 and global variables and about the argument passing conventions used by
3725 GNU Fortran.  If a C binding has been specified, the naming convention
3726 and some of the argument-passing conventions change.  If possible,
3727 mixed-language and mixed-compiler projects should use the better defined
3728 C binding for interoperability.  See @pxref{Interoperability with C}.
3730 @menu
3731 * Naming conventions::
3732 * Argument passing conventions::
3733 @end menu
3736 @node Naming conventions
3737 @subsection Naming conventions
3739 According the Fortran standard, valid Fortran names consist of a letter
3740 between @code{A} to @code{Z}, @code{a} to @code{z}, digits @code{0},
3741 @code{1} to @code{9} and underscores (@code{_}) with the restriction
3742 that names may only start with a letter.  As vendor extension, the
3743 dollar sign (@code{$}) is additionally permitted with the option
3744 @option{-fdollar-ok}, but not as first character and only if the
3745 target system supports it.
3747 By default, the procedure name is the lower-cased Fortran name with an
3748 appended underscore (@code{_}); using @option{-fno-underscoring} no
3749 underscore is appended while @code{-fsecond-underscore} appends two
3750 underscores.  Depending on the target system and the calling convention,
3751 the procedure might be additionally dressed; for instance, on 32bit
3752 Windows with @code{stdcall}, an at-sign @code{@@} followed by an integer
3753 number is appended.  For the changing the calling convention, see
3754 @pxref{GNU Fortran Compiler Directives}.
3756 For common blocks, the same convention is used, i.e. by default an
3757 underscore is appended to the lower-cased Fortran name.  Blank commons
3758 have the name @code{__BLNK__}.
3760 For procedures and variables declared in the specification space of a
3761 module, the name is formed by @code{__}, followed by the lower-cased
3762 module name, @code{_MOD_}, and the lower-cased Fortran name.  Note that
3763 no underscore is appended.
3766 @node Argument passing conventions
3767 @subsection Argument passing conventions
3769 Subroutines do not return a value (matching C99's @code{void}) while
3770 functions either return a value as specified in the platform ABI or
3771 the result variable is passed as hidden argument to the function and
3772 no result is returned.  A hidden result variable is used when the
3773 result variable is an array or of type @code{CHARACTER}.
3775 Arguments are passed according to the platform ABI. In particular,
3776 complex arguments might not be compatible to a struct with two real
3777 components for the real and imaginary part. The argument passing
3778 matches the one of C99's @code{_Complex}.  Functions with scalar
3779 complex result variables return their value and do not use a
3780 by-reference argument.  Note that with the @option{-ff2c} option,
3781 the argument passing is modified and no longer completely matches
3782 the platform ABI.  Some other Fortran compilers use @code{f2c}
3783 semantic by default; this might cause problems with
3784 interoperablility.
3786 GNU Fortran passes most arguments by reference, i.e. by passing a
3787 pointer to the data.  Note that the compiler might use a temporary
3788 variable into which the actual argument has been copied, if required
3789 semantically (copy-in/copy-out).
3791 For arguments with @code{ALLOCATABLE} and @code{POINTER}
3792 attribute (including procedure pointers), a pointer to the pointer
3793 is passed such that the pointer address can be modified in the
3794 procedure.
3796 For dummy arguments with the @code{VALUE} attribute: Scalar arguments
3797 of the type @code{INTEGER}, @code{LOGICAL}, @code{REAL} and
3798 @code{COMPLEX} are passed by value according to the platform ABI.
3799 (As vendor extension and not recommended, using @code{%VAL()} in the
3800 call to a procedure has the same effect.) For @code{TYPE(C_PTR)} and
3801 procedure pointers, the pointer itself is passed such that it can be
3802 modified without affecting the caller.
3803 @c FIXME: Document how VALUE is handled for CHARACTER, TYPE,
3804 @c CLASS and arrays, i.e. whether the copy-in is done in the caller
3805 @c or in the callee.
3807 For Boolean (@code{LOGICAL}) arguments, please note that GCC expects
3808 only the integer value 0 and 1.  If a GNU Fortran @code{LOGICAL}
3809 variable contains another integer value, the result is undefined.
3810 As some other Fortran compilers use @math{-1} for @code{.TRUE.},
3811 extra care has to be taken -- such as passing the value as
3812 @code{INTEGER}.  (The same value restriction also applies to other
3813 front ends of GCC, e.g. to GCC's C99 compiler for @code{_Bool}
3814 or GCC's Ada compiler for @code{Boolean}.)
3816 For arguments of @code{CHARACTER} type, the character length is passed
3817 as hidden argument.  For deferred-length strings, the value is passed
3818 by reference, otherwise by value.  The character length has the type
3819 @code{INTEGER(kind=4)}.  Note with C binding, @code{CHARACTER(len=1)}
3820 result variables are returned according to the platform ABI and no
3821 hidden length argument is used for dummy arguments; with @code{VALUE},
3822 those variables are passed by value.
3824 For @code{OPTIONAL} dummy arguments, an absent argument is denoted
3825 by a NULL pointer, except for scalar dummy arguments of type
3826 @code{INTEGER}, @code{LOGICAL}, @code{REAL} and @code{COMPLEX}
3827 which have the @code{VALUE} attribute.  For those, a hidden Boolean
3828 argument (@code{logical(kind=C_bool),value}) is used to indicate
3829 whether the argument is present.
3831 Arguments which are assumed-shape, assumed-rank or deferred-rank
3832 arrays or, with @option{-fcoarray=lib}, allocatable scalar coarrays use
3833 an array descriptor.  All other arrays pass the address of the
3834 first element of the array.  With @option{-fcoarray=lib}, the token
3835 and the offset belonging to nonallocatable coarrays dummy arguments
3836 are passed as hidden argument along the character length hidden
3837 arguments.  The token is an oparque pointer identifying the coarray
3838 and the offset is a passed-by-value integer of kind @code{C_PTRDIFF_T},
3839 denoting the byte offset between the base address of the coarray and
3840 the passed scalar or first element of the passed array.
3842 The arguments are passed in the following order
3843 @itemize @bullet
3844 @item Result variable, when the function result is passed by reference
3845 @item Character length of the function result, if it is a of type
3846 @code{CHARACTER} and no C binding is used
3847 @item The arguments in the order in which they appear in the Fortran
3848 declaration
3849 @item The the present status for optional arguments with value attribute,
3850 which are internally passed by value
3851 @item The character length and/or coarray token and offset for the first
3852 argument which is a @code{CHARACTER} or a nonallocatable coarray dummy
3853 argument, followed by the hidden arguments of the next dummy argument
3854 of such a type
3855 @end itemize
3858 @c ---------------------------------------------------------------------
3859 @c Coarray Programming
3860 @c ---------------------------------------------------------------------
3862 @node Coarray Programming
3863 @chapter Coarray Programming
3864 @cindex Coarrays
3866 @menu
3867 * Type and enum ABI Documentation::
3868 * Function ABI Documentation::
3869 @end menu
3872 @node Type and enum ABI Documentation
3873 @section Type and enum ABI Documentation
3875 @menu
3876 * caf_token_t::
3877 * caf_register_t::
3878 * caf_deregister_t::
3879 * caf_reference_t::
3880 * caf_team_t::
3881 @end menu
3883 @node caf_token_t
3884 @subsection @code{caf_token_t}
3886 Typedef of type @code{void *} on the compiler side. Can be any data
3887 type on the library side.
3889 @node caf_register_t
3890 @subsection @code{caf_register_t}
3892 Indicates which kind of coarray variable should be registered.
3894 @verbatim
3895 typedef enum caf_register_t {
3896   CAF_REGTYPE_COARRAY_STATIC,
3897   CAF_REGTYPE_COARRAY_ALLOC,
3898   CAF_REGTYPE_LOCK_STATIC,
3899   CAF_REGTYPE_LOCK_ALLOC,
3900   CAF_REGTYPE_CRITICAL,
3901   CAF_REGTYPE_EVENT_STATIC,
3902   CAF_REGTYPE_EVENT_ALLOC,
3903   CAF_REGTYPE_COARRAY_ALLOC_REGISTER_ONLY,
3904   CAF_REGTYPE_COARRAY_ALLOC_ALLOCATE_ONLY
3906 caf_register_t;
3907 @end verbatim
3909 The values @code{CAF_REGTYPE_COARRAY_ALLOC_REGISTER_ONLY} and
3910 @code{CAF_REGTYPE_COARRAY_ALLOC_ALLOCATE_ONLY} are for allocatable components
3911 in derived type coarrays only.  The first one sets up the token without
3912 allocating memory for allocatable component.  The latter one only allocates the
3913 memory for an allocatable component in a derived type coarray.  The token
3914 needs to be setup previously by the REGISTER_ONLY.  This allows to have
3915 allocatable components un-allocated on some images.  The status whether an
3916 allocatable component is allocated on a remote image can be queried by
3917 @code{_caf_is_present} which used internally by the @code{ALLOCATED}
3918 intrinsic.
3920 @node caf_deregister_t
3921 @subsection @code{caf_deregister_t}
3923 @verbatim
3924 typedef enum caf_deregister_t {
3925   CAF_DEREGTYPE_COARRAY_DEREGISTER,
3926   CAF_DEREGTYPE_COARRAY_DEALLOCATE_ONLY
3928 caf_deregister_t;
3929 @end verbatim
3931 Allows to specifiy the type of deregistration of a coarray object.  The
3932 @code{CAF_DEREGTYPE_COARRAY_DEALLOCATE_ONLY} flag is only allowed for
3933 allocatable components in derived type coarrays.
3935 @node caf_reference_t
3936 @subsection @code{caf_reference_t}
3938 The structure used for implementing arbitrary reference chains.
3939 A @code{CAF_REFERENCE_T} allows to specify a component reference or any kind
3940 of array reference of any rank supported by gfortran.  For array references all
3941 kinds as known by the compiler/Fortran standard are supported indicated by
3942 a @code{MODE}.
3944 @verbatim
3945 typedef enum caf_ref_type_t {
3946   /* Reference a component of a derived type, either regular one or an
3947      allocatable or pointer type.  For regular ones idx in caf_reference_t is
3948      set to -1.  */
3949   CAF_REF_COMPONENT,
3950   /* Reference an allocatable array.  */
3951   CAF_REF_ARRAY,
3952   /* Reference a non-allocatable/non-pointer array.  I.e., the coarray object
3953      has no array descriptor associated and the addressing is done
3954      completely using the ref.  */
3955   CAF_REF_STATIC_ARRAY
3956 } caf_ref_type_t;
3957 @end verbatim
3959 @verbatim
3960 typedef enum caf_array_ref_t {
3961   /* No array ref.  This terminates the array ref.  */
3962   CAF_ARR_REF_NONE = 0,
3963   /* Reference array elements given by a vector.  Only for this mode
3964      caf_reference_t.u.a.dim[i].v is valid.  */
3965   CAF_ARR_REF_VECTOR,
3966   /* A full array ref (:).  */
3967   CAF_ARR_REF_FULL,
3968   /* Reference a range on elements given by start, end and stride.  */
3969   CAF_ARR_REF_RANGE,
3970   /* Only a single item is referenced given in the start member.  */
3971   CAF_ARR_REF_SINGLE,
3972   /* An array ref of the kind (i:), where i is an arbitrary valid index in the
3973      array.  The index i is given in the start member.  */
3974   CAF_ARR_REF_OPEN_END,
3975   /* An array ref of the kind (:i), where the lower bound of the array ref
3976      is given by the remote side.  The index i is given in the end member.  */
3977   CAF_ARR_REF_OPEN_START
3978 } caf_array_ref_t;
3979 @end verbatim
3981 @verbatim
3982 /* References to remote components of a derived type.  */
3983 typedef struct caf_reference_t {
3984   /* A pointer to the next ref or NULL.  */
3985   struct caf_reference_t *next;
3986   /* The type of the reference.  */
3987   /* caf_ref_type_t, replaced by int to allow specification in fortran FE.  */
3988   int type;
3989   /* The size of an item referenced in bytes.  I.e. in an array ref this is
3990      the factor to advance the array pointer with to get to the next item.
3991      For component refs this gives just the size of the element referenced.  */
3992   size_t item_size;
3993   union {
3994     struct {
3995       /* The offset (in bytes) of the component in the derived type.
3996          Unused for allocatable or pointer components.  */
3997       ptrdiff_t offset;
3998       /* The offset (in bytes) to the caf_token associated with this
3999          component.  NULL, when not allocatable/pointer ref.  */
4000       ptrdiff_t caf_token_offset;
4001     } c;
4002     struct {
4003       /* The mode of the array ref.  See CAF_ARR_REF_*.  */
4004       /* caf_array_ref_t, replaced by unsigend char to allow specification in
4005          fortran FE.  */
4006      unsigned char mode[GFC_MAX_DIMENSIONS];
4007       /* The type of a static array.  Unset for array's with descriptors.  */
4008       int static_array_type;
4009       /* Subscript refs (s) or vector refs (v).  */
4010       union {
4011         struct {
4012           /* The start and end boundary of the ref and the stride.  */
4013           index_type start, end, stride;
4014         } s;
4015         struct {
4016           /* nvec entries of kind giving the elements to reference.  */
4017           void *vector;
4018           /* The number of entries in vector.  */
4019           size_t nvec;
4020           /* The integer kind used for the elements in vector.  */
4021           int kind;
4022         } v;
4023       } dim[GFC_MAX_DIMENSIONS];
4024     } a;
4025   } u;
4026 } caf_reference_t;
4027 @end verbatim
4029 The references make up a single linked list of reference operations.  The
4030 @code{NEXT} member links to the next reference or NULL to indicate the end of
4031 the chain.  Component and array refs can be arbitrarly mixed as long as they
4032 comply to the Fortran standard.
4034 @emph{NOTES}
4035 The member @code{STATIC_ARRAY_TYPE} is used only when the @code{TYPE} is
4036 @code{CAF_REF_STATIC_ARRAY}.  The member gives the type of the data referenced.
4037 Because no array descriptor is available for a descriptor-less array and
4038 type conversion still needs to take place the type is transported here.
4040 At the moment @code{CAF_ARR_REF_VECTOR} is not implemented in the front end for
4041 descriptor-less arrays.  The library caf_single has untested support for it.
4043 @node caf_team_t
4044 @subsection @code{caf_team_t}
4046 Opaque pointer to represent a team-handle.  This type is a stand-in for the
4047 future implementation of teams.  It is about to change without further notice.
4049 @node Function ABI Documentation
4050 @section Function ABI Documentation
4052 @menu
4053 * _gfortran_caf_init:: Initialiation function
4054 * _gfortran_caf_finish:: Finalization function
4055 * _gfortran_caf_this_image:: Querying the image number
4056 * _gfortran_caf_num_images:: Querying the maximal number of images
4057 * _gfortran_caf_image_status :: Query the status of an image
4058 * _gfortran_caf_failed_images :: Get an array of the indexes of the failed images
4059 * _gfortran_caf_stopped_images :: Get an array of the indexes of the stopped images
4060 * _gfortran_caf_register:: Registering coarrays
4061 * _gfortran_caf_deregister:: Deregistering coarrays
4062 * _gfortran_caf_is_present:: Query whether an allocatable or pointer component in a derived type coarray is allocated
4063 * _gfortran_caf_send:: Sending data from a local image to a remote image
4064 * _gfortran_caf_get:: Getting data from a remote image
4065 * _gfortran_caf_sendget:: Sending data between remote images
4066 * _gfortran_caf_send_by_ref:: Sending data from a local image to a remote image using enhanced references
4067 * _gfortran_caf_get_by_ref:: Getting data from a remote image using enhanced references
4068 * _gfortran_caf_sendget_by_ref:: Sending data between remote images using enhanced references
4069 * _gfortran_caf_lock:: Locking a lock variable
4070 * _gfortran_caf_unlock:: Unlocking a lock variable
4071 * _gfortran_caf_event_post:: Post an event
4072 * _gfortran_caf_event_wait:: Wait that an event occurred
4073 * _gfortran_caf_event_query:: Query event count
4074 * _gfortran_caf_sync_all:: All-image barrier
4075 * _gfortran_caf_sync_images:: Barrier for selected images
4076 * _gfortran_caf_sync_memory:: Wait for completion of segment-memory operations
4077 * _gfortran_caf_error_stop:: Error termination with exit code
4078 * _gfortran_caf_error_stop_str:: Error termination with string
4079 * _gfortran_caf_fail_image :: Mark the image failed and end its execution
4080 * _gfortran_caf_atomic_define:: Atomic variable assignment
4081 * _gfortran_caf_atomic_ref:: Atomic variable reference
4082 * _gfortran_caf_atomic_cas:: Atomic compare and swap
4083 * _gfortran_caf_atomic_op:: Atomic operation
4084 * _gfortran_caf_co_broadcast:: Sending data to all images
4085 * _gfortran_caf_co_max:: Collective maximum reduction
4086 * _gfortran_caf_co_min:: Collective minimum reduction
4087 * _gfortran_caf_co_sum:: Collective summing reduction
4088 * _gfortran_caf_co_reduce:: Generic collective reduction
4089 @end menu
4092 @node _gfortran_caf_init
4093 @subsection @code{_gfortran_caf_init} --- Initialiation function
4094 @cindex Coarray, _gfortran_caf_init
4096 @table @asis
4097 @item @emph{Description}:
4098 This function is called at startup of the program before the Fortran main
4099 program, if the latter has been compiled with @option{-fcoarray=lib}.
4100 It takes as arguments the command-line arguments of the program.  It is
4101 permitted to pass two @code{NULL} pointers as argument; if non-@code{NULL},
4102 the library is permitted to modify the arguments.
4104 @item @emph{Syntax}:
4105 @code{void _gfortran_caf_init (int *argc, char ***argv)}
4107 @item @emph{Arguments}:
4108 @multitable @columnfractions .15 .70
4109 @item @var{argc} @tab intent(inout) An integer pointer with the number of
4110 arguments passed to the program or @code{NULL}.
4111 @item @var{argv} @tab intent(inout) A pointer to an array of strings with the
4112 command-line arguments or @code{NULL}.
4113 @end multitable
4115 @item @emph{NOTES}
4116 The function is modelled after the initialization function of the Message
4117 Passing Interface (MPI) specification.  Due to the way coarray registration
4118 works, it might not be the first call to the library.  If the main program is
4119 not written in Fortran and only a library uses coarrays, it can happen that
4120 this function is never called.  Therefore, it is recommended that the library
4121 does not rely on the passed arguments and whether the call has been done.
4122 @end table
4125 @node _gfortran_caf_finish
4126 @subsection @code{_gfortran_caf_finish} --- Finalization function
4127 @cindex Coarray, _gfortran_caf_finish
4129 @table @asis
4130 @item @emph{Description}:
4131 This function is called at the end of the Fortran main program, if it has
4132 been compiled with the @option{-fcoarray=lib} option.
4134 @item @emph{Syntax}:
4135 @code{void _gfortran_caf_finish (void)}
4137 @item @emph{NOTES}
4138 For non-Fortran programs, it is recommended to call the function at the end
4139 of the main program.  To ensure that the shutdown is also performed for
4140 programs where this function is not explicitly invoked, for instance
4141 non-Fortran programs or calls to the system's exit() function, the library
4142 can use a destructor function.  Note that programs can also be terminated
4143 using the STOP and ERROR STOP statements; those use different library calls.
4144 @end table
4147 @node _gfortran_caf_this_image
4148 @subsection @code{_gfortran_caf_this_image} --- Querying the image number
4149 @cindex Coarray, _gfortran_caf_this_image
4151 @table @asis
4152 @item @emph{Description}:
4153 This function returns the current image number, which is a positive number.
4155 @item @emph{Syntax}:
4156 @code{int _gfortran_caf_this_image (int distance)}
4158 @item @emph{Arguments}:
4159 @multitable @columnfractions .15 .70
4160 @item @var{distance} @tab As specified for the @code{this_image} intrinsic
4161 in TS18508.  Shall be a non-negative number.
4162 @end multitable
4164 @item @emph{NOTES}
4165 If the Fortran intrinsic @code{this_image} is invoked without an argument, which
4166 is the only permitted form in Fortran 2008, GCC passes @code{0} as
4167 first argument.
4168 @end table
4171 @node _gfortran_caf_num_images
4172 @subsection @code{_gfortran_caf_num_images} --- Querying the maximal number of images
4173 @cindex Coarray, _gfortran_caf_num_images
4175 @table @asis
4176 @item @emph{Description}:
4177 This function returns the number of images in the current team, if
4178 @var{distance} is 0 or the number of images in the parent team at the specified
4179 distance. If failed is -1, the function returns the number of all images at
4180 the specified distance; if it is 0, the function returns the number of
4181 nonfailed images, and if it is 1, it returns the number of failed images.
4183 @item @emph{Syntax}:
4184 @code{int _gfortran_caf_num_images(int distance, int failed)}
4186 @item @emph{Arguments}:
4187 @multitable @columnfractions .15 .70
4188 @item @var{distance} @tab the distance from this image to the ancestor.
4189 Shall be positive.
4190 @item @var{failed} @tab shall be -1, 0, or 1
4191 @end multitable
4193 @item @emph{NOTES}
4194 This function follows TS18508. If the num_image intrinsic has no arguments,
4195 then the compiler passes @code{distance=0} and @code{failed=-1} to the function.
4196 @end table
4199 @node _gfortran_caf_image_status
4200 @subsection @code{_gfortran_caf_image_status} --- Query the status of an image
4201 @cindex Coarray, _gfortran_caf_image_status
4203 @table @asis
4204 @item @emph{Description}:
4205 Get the status of the image given by the id @var{image} of the team given by
4206 @var{team}.  Valid results are zero, for image is ok, @code{STAT_STOPPED_IMAGE}
4207 from the ISO_FORTRAN_ENV module to indicate that the image has been stopped and
4208 @code{STAT_FAILED_IMAGE} also from ISO_FORTRAN_ENV to indicate that the image
4209 has executed a @code{FAIL IMAGE} statement.
4211 @item @emph{Syntax}:
4212 @code{int _gfortran_caf_image_status (int image, caf_team_t * team)}
4214 @item @emph{Arguments}:
4215 @multitable @columnfractions .15 .70
4216 @item @var{image} @tab the positive scalar id of the image in the current TEAM.
4217 @item @var{team} @tab optional; team on the which the inquiry is to be
4218 performed.
4219 @end multitable
4221 @item @emph{NOTES}
4222 This function follows TS18508.  Because team-functionality is not yet
4223 implemented a null-pointer is passed for the @var{team} argument at the moment.
4224 @end table
4227 @node _gfortran_caf_failed_images
4228 @subsection @code{_gfortran_caf_failed_images} --- Get an array of the indexes of the failed images
4229 @cindex Coarray, _gfortran_caf_failed_images
4231 @table @asis
4232 @item @emph{Description}:
4233 Get an array of image indexes in the current @var{team} that have failed.  The
4234 array is sorted ascendingly.  When @var{team} is not provided the current team
4235 is to be used.  When @var{kind} is provided then the resulting array is of that
4236 integer kind else it is of default integer kind.  The returns an unallocated
4237 size zero array when no images have failed.
4239 @item @emph{Syntax}:
4240 @code{int _gfortran_caf_failed_images (caf_team_t * team, int * kind)}
4242 @item @emph{Arguments}:
4243 @multitable @columnfractions .15 .70
4244 @item @var{team} @tab optional; team on the which the inquiry is to be
4245 performed.
4246 @item @var{image} @tab optional; the kind of the resulting integer array.
4247 @end multitable
4249 @item @emph{NOTES}
4250 This function follows TS18508.  Because team-functionality is not yet
4251 implemented a null-pointer is passed for the @var{team} argument at the moment.
4252 @end table
4255 @node _gfortran_caf_stopped_images
4256 @subsection @code{_gfortran_caf_stopped_images} --- Get an array of the indexes of the stopped images
4257 @cindex Coarray, _gfortran_caf_stopped_images
4259 @table @asis
4260 @item @emph{Description}:
4261 Get an array of image indexes in the current @var{team} that have stopped.  The
4262 array is sorted ascendingly.  When @var{team} is not provided the current team
4263 is to be used.  When @var{kind} is provided then the resulting array is of that
4264 integer kind else it is of default integer kind.  The returns an unallocated
4265 size zero array when no images have failed.
4267 @item @emph{Syntax}:
4268 @code{int _gfortran_caf_stopped_images (caf_team_t * team, int * kind)}
4270 @item @emph{Arguments}:
4271 @multitable @columnfractions .15 .70
4272 @item @var{team} @tab optional; team on the which the inquiry is to be
4273 performed.
4274 @item @var{image} @tab optional; the kind of the resulting integer array.
4275 @end multitable
4277 @item @emph{NOTES}
4278 This function follows TS18508.  Because team-functionality is not yet
4279 implemented a null-pointer is passed for the @var{team} argument at the moment.
4280 @end table
4283 @node _gfortran_caf_register
4284 @subsection @code{_gfortran_caf_register} --- Registering coarrays
4285 @cindex Coarray, _gfortran_caf_register
4287 @table @asis
4288 @item @emph{Description}:
4289 Registers memory for a coarray and creates a token to identify the coarray.  The
4290 routine is called for both coarrays with @code{SAVE} attribute and using an
4291 explicit @code{ALLOCATE} statement.  If an error occurs and @var{STAT} is a
4292 @code{NULL} pointer, the function shall abort with printing an error message
4293 and starting the error termination.  If no error occurs and @var{STAT} is
4294 present, it shall be set to zero.  Otherwise, it shall be set to a positive
4295 value and, if not-@code{NULL}, @var{ERRMSG} shall be set to a string describing
4296 the failure.  The routine shall register the memory provided in the
4297 @code{DATA}-component of the array descriptor @var{DESC}, when that component
4298 is non-@code{NULL}, else it shall allocate sufficient memory and provide a
4299 pointer to it in the @code{DATA}-component of @var{DESC}.  The array descriptor
4300 has rank zero, when a scalar object is to be registered and the array
4301 descriptor may be invalid after the call to @code{_gfortran_caf_register}.
4302 When an array is to be allocated the descriptor persists.
4304 For @code{CAF_REGTYPE_COARRAY_STATIC} and @code{CAF_REGTYPE_COARRAY_ALLOC},
4305 the passed size is the byte size requested.  For @code{CAF_REGTYPE_LOCK_STATIC},
4306 @code{CAF_REGTYPE_LOCK_ALLOC} and @code{CAF_REGTYPE_CRITICAL} it is the array
4307 size or one for a scalar.
4309 When @code{CAF_REGTYPE_COARRAY_ALLOC_REGISTER_ONLY} is used, then only a token
4310 for an allocatable or pointer component is created.  The @code{SIZE} parameter
4311 is not used then.  On the contrary when
4312 @code{CAF_REGTYPE_COARRAY_ALLOC_ALLOCATE_ONLY} is specified, then the
4313 @var{token} needs to be registered by a previous call with regtype
4314 @code{CAF_REGTYPE_COARRAY_ALLOC_REGISTER_ONLY} and either the memory specified
4315 in the @var{desc}'s data-ptr is registered or allocate when the data-ptr is
4316 NULL.
4318 @item @emph{Syntax}:
4319 @code{void caf_register (size_t size, caf_register_t type, caf_token_t *token,
4320 gfc_descriptor_t *desc, int *stat, char *errmsg, int errmsg_len)}
4322 @item @emph{Arguments}:
4323 @multitable @columnfractions .15 .70
4324 @item @var{size} @tab For normal coarrays, the byte size of the coarray to be
4325 allocated; for lock types and event types, the number of elements.
4326 @item @var{type} @tab one of the caf_register_t types.
4327 @item @var{token} @tab intent(out) An opaque pointer identifying the coarray.
4328 @item @var{desc} @tab intent(inout) The (pseudo) array descriptor.
4329 @item @var{stat} @tab intent(out) For allocatable coarrays, stores the STAT=;
4330 may be NULL
4331 @item @var{errmsg} @tab intent(out) When an error occurs, this will be set to
4332 an error message; may be NULL
4333 @item @var{errmsg_len} @tab the buffer size of errmsg.
4334 @end multitable
4336 @item @emph{NOTES}
4337 Nonalloatable coarrays have to be registered prior use from remote images.
4338 In order to guarantee this, they have to be registered before the main
4339 program. This can be achieved by creating constructor functions. That is what
4340 GCC does such that also nonallocatable coarrays the memory is allocated and no
4341 static memory is used.  The token permits to identify the coarray; to the
4342 processor, the token is a nonaliasing pointer. The library can, for instance,
4343 store the base address of the coarray in the token, some handle or a more
4344 complicated struct.  The library may also store the array descriptor
4345 @var{DESC} when its rank is non-zero.
4347 For lock types, the value shall only used for checking the allocation
4348 status. Note that for critical blocks, the locking is only required on one
4349 image; in the locking statement, the processor shall always pass an
4350 image index of one for critical-block lock variables
4351 (@code{CAF_REGTYPE_CRITICAL}). For lock types and critical-block variables,
4352 the initial value shall be unlocked (or, respecitively, not in critical
4353 section) such as the value false; for event types, the initial state should
4354 be no event, e.g. zero.
4355 @end table
4358 @node _gfortran_caf_deregister
4359 @subsection @code{_gfortran_caf_deregister} --- Deregistering coarrays
4360 @cindex Coarray, _gfortran_caf_deregister
4362 @table @asis
4363 @item @emph{Description}:
4364 Called to free or deregister the memory of a coarray; the processor calls this
4365 function for automatic and explicit deallocation.  In case of an error, this
4366 function shall fail with an error message, unless the @var{STAT} variable is
4367 not null.  The library is only expected to free memory it allocated itself
4368 during a call to @code{_gfortran_caf_register}.
4370 @item @emph{Syntax}:
4371 @code{void caf_deregister (caf_token_t *token, caf_deregister_t type,
4372 int *stat, char *errmsg, int errmsg_len)}
4374 @item @emph{Arguments}:
4375 @multitable @columnfractions .15 .70
4376 @item @var{token} @tab the token to free.
4377 @item @var{type} @tab the type of action to take for the coarray.  A
4378 @code{CAF_DEREGTYPE_COARRAY_DEALLOCATE_ONLY} is allowed only for allocatable or
4379 pointer components of derived type coarrays.  The action only deallocates the
4380 local memory without deleting the token.
4381 @item @var{stat} @tab intent(out) Stores the STAT=; may be NULL
4382 @item @var{errmsg} @tab intent(out) When an error occurs, this will be set
4383 to an error message; may be NULL
4384 @item @var{errmsg_len} @tab the buffer size of errmsg.
4385 @end multitable
4387 @item @emph{NOTES}
4388 For nonalloatable coarrays this function is never called.  If a cleanup is
4389 required, it has to be handled via the finish, stop and error stop functions,
4390 and via destructors.
4391 @end table
4394 @node _gfortran_caf_is_present
4395 @subsection @code{_gfortran_caf_is_present} --- Query whether an allocatable or pointer component in a derived type coarray is allocated
4396 @cindex Coarray, _gfortran_caf_is_present
4398 @table @asis
4399 @item @emph{Description}:
4400 Used to query the coarray library whether an allocatable component in a derived
4401 type coarray is allocated on a remote image.
4403 @item @emph{Syntax}:
4404 @code{void _gfortran_caf_is_present (caf_token_t token, int image_index,
4405 gfc_reference_t *ref)}
4407 @item @emph{Arguments}:
4408 @multitable @columnfractions .15 .70
4409 @item @var{token} @tab An opaque pointer identifying the coarray.
4410 @item @var{image_index} @tab The ID of the remote image; must be a positive
4411 number.
4412 @item @var{ref} @tab A chain of references to address the allocatable or
4413 pointer component in the derived type coarray.  The object reference needs to be
4414 a scalar or a full array reference, respectively.
4415 @end multitable
4417 @end table
4419 @node _gfortran_caf_send
4420 @subsection @code{_gfortran_caf_send} --- Sending data from a local image to a remote image
4421 @cindex Coarray, _gfortran_caf_send
4423 @table @asis
4424 @item @emph{Description}:
4425 Called to send a scalar, an array section or a whole array from a local
4426 to a remote image identified by the image_index.
4428 @item @emph{Syntax}:
4429 @code{void _gfortran_caf_send (caf_token_t token, size_t offset,
4430 int image_index, gfc_descriptor_t *dest, caf_vector_t *dst_vector,
4431 gfc_descriptor_t *src, int dst_kind, int src_kind, bool may_require_tmp,
4432 int *stat)}
4434 @item @emph{Arguments}:
4435 @multitable @columnfractions .15 .70
4436 @item @var{token} @tab intent(in)  An opaque pointer identifying the coarray.
4437 @item @var{offset} @tab intent(in)  By which amount of bytes the actual data is
4438 shifted compared to the base address of the coarray.
4439 @item @var{image_index} @tab intent(in)  The ID of the remote image; must be a
4440 positive number.
4441 @item @var{dest} @tab intent(in)  Array descriptor for the remote image for the
4442 bounds and the size.  The @code{base_addr} shall not be accessed.
4443 @item @var{dst_vector} @tab intent(in)  If not NULL, it contains the vector
4444 subscript of the destination array; the values are relative to the dimension
4445 triplet of the dest argument.
4446 @item @var{src} @tab intent(in)  Array descriptor of the local array to be
4447 transferred to the remote image
4448 @item @var{dst_kind} @tab intent(in)  Kind of the destination argument
4449 @item @var{src_kind} @tab intent(in)  Kind of the source argument
4450 @item @var{may_require_tmp} @tab intent(in)  The variable is @code{false} when
4451 it is known at compile time that the @var{dest} and @var{src} either cannot
4452 overlap or overlap (fully or partially) such that walking @var{src} and
4453 @var{dest} in element wise element order (honoring the stride value) will not
4454 lead to wrong results.  Otherwise, the value is @code{true}.
4455 @item @var{stat} @tab intent(out) when non-NULL give the result of the
4456 operation, i.e., zero on success and non-zero on error.  When NULL and an error
4457 occurs, then an error message is printed and the program is terminated.
4458 @end multitable
4460 @item @emph{NOTES}
4461 It is permitted to have @var{image_index} equal the current image; the memory
4462 of the send-to and the send-from might (partially) overlap in that case.  The
4463 implementation has to take care that it handles this case, e.g. using
4464 @code{memmove} which handles (partially) overlapping memory. If
4465 @var{may_require_tmp} is true, the library might additionally create a
4466 temporary variable, unless additional checks show that this is not required
4467 (e.g. because walking backward is possible or because both arrays are
4468 contiguous and @code{memmove} takes care of overlap issues).
4470 Note that the assignment of a scalar to an array is permitted. In addition,
4471 the library has to handle numeric-type conversion and for strings, padding
4472 and different character kinds.
4473 @end table
4476 @node _gfortran_caf_get
4477 @subsection @code{_gfortran_caf_get} --- Getting data from a remote image
4478 @cindex Coarray, _gfortran_caf_get
4480 @table @asis
4481 @item @emph{Description}:
4482 Called to get an array section or a whole array from a remote,
4483 image identified by the image_index.
4485 @item @emph{Syntax}:
4486 @code{void _gfortran_caf_get (caf_token_t token, size_t offset,
4487 int image_index, gfc_descriptor_t *src, caf_vector_t *src_vector,
4488 gfc_descriptor_t *dest, int src_kind, int dst_kind, bool may_require_tmp,
4489 int *stat)}
4491 @item @emph{Arguments}:
4492 @multitable @columnfractions .15 .70
4493 @item @var{token} @tab intent(in)  An opaque pointer identifying the coarray.
4494 @item @var{offset} @tab intent(in)  By which amount of bytes the actual data is
4495 shifted compared to the base address of the coarray.
4496 @item @var{image_index} @tab intent(in)  The ID of the remote image; must be a
4497 positive number.
4498 @item @var{dest} @tab intent(out) Array descriptor of the local array to store
4499 the data retrieved from the remote image
4500 @item @var{src} @tab intent(in) Array descriptor for the remote image for the
4501 bounds and the size.  The @code{base_addr} shall not be accessed.
4502 @item @var{src_vector} @tab intent(in)  If not NULL, it contains the vector
4503 subscript of the source array; the values are relative to the dimension
4504 triplet of the @var{src} argument.
4505 @item @var{dst_kind} @tab intent(in)  Kind of the destination argument
4506 @item @var{src_kind} @tab intent(in)  Kind of the source argument
4507 @item @var{may_require_tmp} @tab intent(in)  The variable is @code{false} when
4508 it is known at compile time that the @var{dest} and @var{src} either cannot
4509 overlap or overlap (fully or partially) such that walking @var{src} and
4510 @var{dest} in element wise element order (honoring the stride value) will not
4511 lead to wrong results.  Otherwise, the value is @code{true}.
4512 @item @var{stat} @tab intent(out) When non-NULL give the result of the
4513 operation, i.e., zero on success and non-zero on error.  When NULL and an error
4514 occurs, then an error message is printed and the program is terminated.
4515 @end multitable
4517 @item @emph{NOTES}
4518 It is permitted to have @var{image_index} equal the current image; the memory of
4519 the send-to and the send-from might (partially) overlap in that case.  The
4520 implementation has to take care that it handles this case, e.g. using
4521 @code{memmove} which handles (partially) overlapping memory. If
4522 @var{may_require_tmp} is true, the library might additionally create a
4523 temporary variable, unless additional checks show that this is not required
4524 (e.g. because walking backward is possible or because both arrays are
4525 contiguous and @code{memmove} takes care of overlap issues).
4527 Note that the library has to handle numeric-type conversion and for strings,
4528 padding and different character kinds.
4529 @end table
4532 @node _gfortran_caf_sendget
4533 @subsection @code{_gfortran_caf_sendget} --- Sending data between remote images
4534 @cindex Coarray, _gfortran_caf_sendget
4536 @table @asis
4537 @item @emph{Description}:
4538 Called to send a scalar, an array section or a whole array from a remote image
4539 identified by the @var{src_image_index} to a remote image identified by the
4540 @var{dst_image_index}.
4542 @item @emph{Syntax}:
4543 @code{void _gfortran_caf_sendget (caf_token_t dst_token, size_t dst_offset,
4544 int dst_image_index, gfc_descriptor_t *dest, caf_vector_t *dst_vector,
4545 caf_token_t src_token, size_t src_offset, int src_image_index,
4546 gfc_descriptor_t *src, caf_vector_t *src_vector, int dst_kind, int src_kind,
4547 bool may_require_tmp, int *stat)}
4549 @item @emph{Arguments}:
4550 @multitable @columnfractions .15 .70
4551 @item @var{dst_token} @tab intent(in)  An opaque pointer identifying the
4552 destination coarray.
4553 @item @var{dst_offset} @tab intent(in)  By which amount of bytes the actual data
4554 is shifted compared to the base address of the destination coarray.
4555 @item @var{dst_image_index} @tab intent(in)  The ID of the destination remote
4556 image; must be a positive number.
4557 @item @var{dest} @tab intent(in) Array descriptor for the destination
4558 remote image for the bounds and the size.  The @code{base_addr} shall not be
4559 accessed.
4560 @item @var{dst_vector} @tab intent(int)  If not NULL, it contains the vector
4561 subscript of the destination array; the values are relative to the dimension
4562 triplet of the @var{dest} argument.
4563 @item @var{src_token} @tab intent(in)  An opaque pointer identifying the source
4564 coarray.
4565 @item @var{src_offset} @tab intent(in)  By which amount of bytes the actual data
4566 is shifted compared to the base address of the source coarray.
4567 @item @var{src_image_index} @tab intent(in)  The ID of the source remote image;
4568 must be a positive number.
4569 @item @var{src} @tab intent(in) Array descriptor of the local array to be
4570 transferred to the remote image.
4571 @item @var{src_vector} @tab intent(in) Array descriptor of the local array to
4572 be transferred to the remote image
4573 @item @var{dst_kind} @tab intent(in)  Kind of the destination argument
4574 @item @var{src_kind} @tab intent(in)  Kind of the source argument
4575 @item @var{may_require_tmp} @tab intent(in)  The variable is @code{false} when
4576 it is known at compile time that the @var{dest} and @var{src} either cannot
4577 overlap or overlap (fully or partially) such that walking @var{src} and
4578 @var{dest} in element wise element order (honoring the stride value) will not
4579 lead to wrong results.  Otherwise, the value is @code{true}.
4580 @item @var{stat} @tab intent(out) when non-NULL give the result of the
4581 operation, i.e., zero on success and non-zero on error.  When NULL and an error
4582 occurs, then an error message is printed and the program is terminated.
4583 @end multitable
4585 @item @emph{NOTES}
4586 It is permitted to have the same image index for both @var{src_image_index} and
4587 @var{dst_image_index}; the memory of the send-to and the send-from might
4588 (partially) overlap in that case.  The implementation has to take care that it
4589 handles this case, e.g. using @code{memmove} which handles (partially)
4590 overlapping memory.  If @var{may_require_tmp} is true, the library
4591 might additionally create a temporary variable, unless additional checks show
4592 that this is not required (e.g. because walking backward is possible or because
4593 both arrays are contiguous and @code{memmove} takes care of overlap issues).
4595 Note that the assignment of a scalar to an array is permitted. In addition,
4596 the library has to handle numeric-type conversion and for strings, padding and
4597 different character kinds.
4598 @end table
4600 @node _gfortran_caf_send_by_ref
4601 @subsection @code{_gfortran_caf_send_by_ref} --- Sending data from a local image to a remote image with enhanced referencing options
4602 @cindex Coarray, _gfortran_caf_send_by_ref
4604 @table @asis
4605 @item @emph{Description}:
4606 Called to send a scalar, an array section or a whole array from a local to a
4607 remote image identified by the @var{image_index}.
4609 @item @emph{Syntax}:
4610 @code{void _gfortran_caf_send_by_ref (caf_token_t token, int image_index,
4611 gfc_descriptor_t *src, caf_reference_t *refs, int dst_kind, int src_kind,
4612 bool may_require_tmp, bool dst_reallocatable, int *stat)}
4614 @item @emph{Arguments}:
4615 @multitable @columnfractions .15 .70
4616 @item @var{token} @tab intent(in)  An opaque pointer identifying the coarray.
4617 @item @var{image_index} @tab intent(in)  The ID of the remote image; must be a
4618 positive number.
4619 @item @var{src} @tab intent(in) Array descriptor of the local array to be
4620 transferred to the remote image
4621 @item @var{refs} @tab intent(in) The references on the remote array to store
4622 the data given by src.  Guaranteed to have at least one entry.
4623 @item @var{dst_kind} @tab intent(in)  Kind of the destination argument
4624 @item @var{src_kind} @tab intent(in)  Kind of the source argument
4625 @item @var{may_require_tmp} @tab intent(in)  The variable is @code{false} when
4626 it is known at compile time that the @var{dest} and @var{src} either cannot
4627 overlap or overlap (fully or partially) such that walking @var{src} and
4628 @var{dest} in element wise element order (honoring the stride value) will not
4629 lead to wrong results.  Otherwise, the value is @code{true}.
4630 @item @var{dst_reallocatable} @tab intent(in)  Set when the destination is of
4631 allocatable or pointer type and the refs will allow reallocation, i.e., the ref
4632 is a full array or component ref.
4633 @item @var{stat} @tab intent(out) When non-@code{NULL} give the result of the
4634 operation, i.e., zero on success and non-zero on error.  When @code{NULL} and
4635 an error occurs, then an error message is printed and the program is terminated.
4636 @end multitable
4638 @item @emph{NOTES}
4639 It is permitted to have @var{image_index} equal the current image; the memory of
4640 the send-to and the send-from might (partially) overlap in that case.  The
4641 implementation has to take care that it handles this case, e.g. using
4642 @code{memmove} which handles (partially) overlapping memory.  If
4643 @var{may_require_tmp} is true, the library might additionally create a
4644 temporary variable, unless additional checks show that this is not required
4645 (e.g. because walking backward is possible or because both arrays are
4646 contiguous and @code{memmove} takes care of overlap issues).
4648 Note that the assignment of a scalar to an array is permitted.  In addition,
4649 the library has to handle numeric-type conversion and for strings, padding
4650 and different character kinds.
4652 Because of the more complicated references possible some operations may be
4653 unsupported by certain libraries.  The library is expected to issue a precise
4654 error message why the operation is not permitted.
4655 @end table
4658 @node _gfortran_caf_get_by_ref
4659 @subsection @code{_gfortran_caf_get_by_ref} --- Getting data from a remote image using enhanced references
4660 @cindex Coarray, _gfortran_caf_get_by_ref
4662 @table @asis
4663 @item @emph{Description}:
4664 Called to get a scalar, an array section or a whole array from a remote image
4665 identified by the @var{image_index}.
4667 @item @emph{Syntax}:
4668 @code{void _gfortran_caf_get_by_ref (caf_token_t token, int image_index,
4669 caf_reference_t *refs, gfc_descriptor_t *dst, int dst_kind, int src_kind,
4670 bool may_require_tmp, bool dst_reallocatable, int *stat)}
4672 @item @emph{Arguments}:
4673 @multitable @columnfractions .15 .70
4674 @item @var{token} @tab intent(in)  An opaque pointer identifying the coarray.
4675 @item @var{image_index} @tab intent(in)  The ID of the remote image; must be a
4676 positive number.
4677 @item @var{refs} @tab intent(in) The references to apply to the remote structure
4678 to get the data.
4679 @item @var{dst} @tab intent(in) Array descriptor of the local array to store
4680 the data transferred from the remote image.  May be reallocated where needed
4681 and when @var{DST_REALLOCATABLE} allows it.
4682 @item @var{dst_kind} @tab intent(in)  Kind of the destination argument
4683 @item @var{src_kind} @tab intent(in)  Kind of the source argument
4684 @item @var{may_require_tmp} @tab intent(in)  The variable is @code{false} when
4685 it is known at compile time that the @var{dest} and @var{src} either cannot
4686 overlap or overlap (fully or partially) such that walking @var{src} and
4687 @var{dest} in element wise element order (honoring the stride value) will not
4688 lead to wrong results.  Otherwise, the value is @code{true}.
4689 @item @var{dst_reallocatable} @tab intent(in)  Set when @var{DST} is of
4690 allocatable or pointer type and its refs allow reallocation, i.e., the full
4691 array or a component is referenced.
4692 @item @var{stat} @tab intent(out) When non-@code{NULL} give the result of the
4693 operation, i.e., zero on success and non-zero on error.  When @code{NULL} and an
4694 error occurs, then an error message is printed and the program is terminated.
4695 @end multitable
4697 @item @emph{NOTES}
4698 It is permitted to have @code{image_index} equal the current image; the memory
4699 of the send-to and the send-from might (partially) overlap in that case.  The
4700 implementation has to take care that it handles this case, e.g. using
4701 @code{memmove} which handles (partially) overlapping memory.  If
4702 @var{may_require_tmp} is true, the library might additionally create a
4703 temporary variable, unless additional checks show that this is not required
4704 (e.g. because walking backward is possible or because both arrays are
4705 contiguous and @code{memmove} takes care of overlap issues).
4707 Note that the library has to handle numeric-type conversion and for strings,
4708 padding and different character kinds.
4710 Because of the more complicated references possible some operations may be
4711 unsupported by certain libraries.  The library is expected to issue a precise
4712 error message why the operation is not permitted.
4713 @end table
4716 @node _gfortran_caf_sendget_by_ref
4717 @subsection @code{_gfortran_caf_sendget_by_ref} --- Sending data between remote images using enhanced references on both sides
4718 @cindex Coarray, _gfortran_caf_sendget_by_ref
4720 @table @asis
4721 @item @emph{Description}:
4722 Called to send a scalar, an array section or a whole array from a remote image
4723 identified by the @var{src_image_index} to a remote image identified by the
4724 @var{dst_image_index}.
4726 @item @emph{Syntax}:
4727 @code{void _gfortran_caf_sendget_by_ref (caf_token_t dst_token,
4728 int dst_image_index, caf_reference_t *dst_refs,
4729 caf_token_t src_token, int src_image_index, caf_reference_t *src_refs,
4730 int dst_kind, int src_kind, bool may_require_tmp, int *dst_stat, int *src_stat)}
4732 @item @emph{Arguments}:
4733 @multitable @columnfractions .15 .70
4734 @item @var{dst_token} @tab intent(in)  An opaque pointer identifying the
4735 destination coarray.
4736 @item @var{dst_image_index} @tab intent(in)  The ID of the destination remote
4737 image; must be a positive number.
4738 @item @var{dst_refs} @tab intent(in) The references on the remote array to store
4739 the data given by the source.  Guaranteed to have at least one entry.
4740 @item @var{src_token} @tab intent(in)  An opaque pointer identifying the source
4741 coarray.
4742 @item @var{src_image_index} @tab intent(in)  The ID of the source remote image;
4743 must be a positive number.
4744 @item @var{src_refs} @tab intent(in) The references to apply to the remote
4745 structure to get the data.
4746 @item @var{dst_kind} @tab intent(in)  Kind of the destination argument
4747 @item @var{src_kind} @tab intent(in)  Kind of the source argument
4748 @item @var{may_require_tmp} @tab intent(in)  The variable is @code{false} when
4749 it is known at compile time that the @var{dest} and @var{src} either cannot
4750 overlap or overlap (fully or partially) such that walking @var{src} and
4751 @var{dest} in element wise element order (honoring the stride value) will not
4752 lead to wrong results.  Otherwise, the value is @code{true}.
4753 @item @var{dst_stat} @tab intent(out) when non-@code{NULL} give the result of
4754 the send-operation, i.e., zero on success and non-zero on error.  When
4755 @code{NULL} and an error occurs, then an error message is printed and the
4756 program is terminated.
4757 @item @var{src_stat} @tab intent(out) When non-@code{NULL} give the result of
4758 the get-operation, i.e., zero on success and non-zero on error.  When
4759 @code{NULL} and an error occurs, then an error message is printed and the
4760 program is terminated.
4761 @end multitable
4763 @item @emph{NOTES}
4764 It is permitted to have the same image index for both @var{src_image_index} and
4765 @var{dst_image_index}; the memory of the send-to and the send-from might
4766 (partially) overlap in that case.  The implementation has to take care that it
4767 handles this case, e.g. using @code{memmove} which handles (partially)
4768 overlapping memory.  If @var{may_require_tmp} is true, the library
4769 might additionally create a temporary variable, unless additional checks show
4770 that this is not required (e.g. because walking backward is possible or because
4771 both arrays are contiguous and @code{memmove} takes care of overlap issues).
4773 Note that the assignment of a scalar to an array is permitted.  In addition,
4774 the library has to handle numeric-type conversion and for strings, padding and
4775 different character kinds.
4777 Because of the more complicated references possible some operations may be
4778 unsupported by certain libraries.  The library is expected to issue a precise
4779 error message why the operation is not permitted.
4780 @end table
4783 @node _gfortran_caf_lock
4784 @subsection @code{_gfortran_caf_lock} --- Locking a lock variable
4785 @cindex Coarray, _gfortran_caf_lock
4787 @table @asis
4788 @item @emph{Description}:
4789 Acquire a lock on the given image on a scalar locking variable or for the
4790 given array element for an array-valued variable.  If the @var{aquired_lock}
4791 is @code{NULL}, the function returns after having obtained the lock.  If it is
4792 non-@code{NULL}, then @var{acquired_lock} is assigned the value true (one) when
4793 the lock could be obtained and false (zero) otherwise.  Locking a lock variable
4794 which has already been locked by the same image is an error.
4796 @item @emph{Syntax}:
4797 @code{void _gfortran_caf_lock (caf_token_t token, size_t index, int image_index,
4798 int *aquired_lock, int *stat, char *errmsg, int errmsg_len)}
4800 @item @emph{Arguments}:
4801 @multitable @columnfractions .15 .70
4802 @item @var{token} @tab intent(in)  An opaque pointer identifying the coarray.
4803 @item @var{index} @tab intent(in)  Array index; first array index is 0.  For
4804 scalars, it is always 0.
4805 @item @var{image_index} @tab intent(in)  The ID of the remote image; must be a
4806 positive number.
4807 @item @var{aquired_lock} @tab intent(out) If not NULL, it returns whether lock
4808 could be obtained.
4809 @item @var{stat} @tab intent(out) Stores the STAT=; may be NULL.
4810 @item @var{errmsg} @tab intent(out) When an error occurs, this will be set to
4811 an error message; may be NULL.
4812 @item @var{errmsg_len} @tab intent(in)  the buffer size of errmsg
4813 @end multitable
4815 @item @emph{NOTES}
4816 This function is also called for critical blocks; for those, the array index
4817 is always zero and the image index is one.  Libraries are permitted to use other
4818 images for critical-block locking variables.
4819 @end table
4821 @node _gfortran_caf_unlock
4822 @subsection @code{_gfortran_caf_lock} --- Unlocking a lock variable
4823 @cindex Coarray, _gfortran_caf_unlock
4825 @table @asis
4826 @item @emph{Description}:
4827 Release a lock on the given image on a scalar locking variable or for the
4828 given array element for an array-valued variable. Unlocking a lock variable
4829 which is unlocked or has been locked by a different image is an error.
4831 @item @emph{Syntax}:
4832 @code{void _gfortran_caf_unlock (caf_token_t token, size_t index, int image_index,
4833 int *stat, char *errmsg, int errmsg_len)}
4835 @item @emph{Arguments}:
4836 @multitable @columnfractions .15 .70
4837 @item @var{token} @tab intent(in)  An opaque pointer identifying the coarray.
4838 @item @var{index} @tab intent(in)  Array index; first array index is 0.  For
4839 scalars, it is always 0.
4840 @item @var{image_index} @tab intent(in)  The ID of the remote image; must be a
4841 positive number.
4842 @item @var{stat} @tab intent(out) For allocatable coarrays, stores the STAT=;
4843 may be NULL.
4844 @item @var{errmsg} @tab intent(out) When an error occurs, this will be set to
4845 an error message; may be NULL.
4846 @item @var{errmsg_len} @tab intent(in)  the buffer size of errmsg
4847 @end multitable
4849 @item @emph{NOTES}
4850 This function is also called for critical block; for those, the array index
4851 is always zero and the image index is one.  Libraries are permitted to use other
4852 images for critical-block locking variables.
4853 @end table
4855 @node _gfortran_caf_event_post
4856 @subsection @code{_gfortran_caf_event_post} --- Post an event
4857 @cindex Coarray, _gfortran_caf_event_post
4859 @table @asis
4860 @item @emph{Description}:
4861 Increment the event count of the specified event variable.
4863 @item @emph{Syntax}:
4864 @code{void _gfortran_caf_event_post (caf_token_t token, size_t index,
4865 int image_index, int *stat, char *errmsg, int errmsg_len)}
4867 @item @emph{Arguments}:
4868 @multitable @columnfractions .15 .70
4869 @item @var{token} @tab intent(in)  An opaque pointer identifying the coarray.
4870 @item @var{index} @tab intent(in)  Array index; first array index is 0.  For
4871 scalars, it is always 0.
4872 @item @var{image_index} @tab intent(in)  The ID of the remote image; must be a
4873 positive number; zero indicates the current image, when accessed noncoindexed.
4874 @item @var{stat} @tab intent(out)  Stores the STAT=; may be NULL.
4875 @item @var{errmsg} @tab intent(out)  When an error occurs, this will be set to
4876 an error message; may be NULL.
4877 @item @var{errmsg_len} @tab intent(in)  the buffer size of errmsg
4878 @end multitable
4880 @item @emph{NOTES}
4881 This acts like an atomic add of one to the remote image's event variable.
4882 The statement is an image-control statement but does not imply sync memory.
4883 Still, all preceeding push communications of this image to the specified
4884 remote image have to be completed before @code{event_wait} on the remote
4885 image returns.
4886 @end table
4890 @node _gfortran_caf_event_wait
4891 @subsection @code{_gfortran_caf_event_wait} --- Wait that an event occurred
4892 @cindex Coarray, _gfortran_caf_event_wait
4894 @table @asis
4895 @item @emph{Description}:
4896 Wait until the event count has reached at least the specified
4897 @var{until_count}; if so, atomically decrement the event variable by this
4898 amount and return.
4900 @item @emph{Syntax}:
4901 @code{void _gfortran_caf_event_wait (caf_token_t token, size_t index,
4902 int until_count, int *stat, char *errmsg, int errmsg_len)}
4904 @item @emph{Arguments}:
4905 @multitable @columnfractions .15 .70
4906 @item @var{token} @tab intent(in)  An opaque pointer identifying the coarray.
4907 @item @var{index} @tab intent(in)  Array index; first array index is 0.  For
4908 scalars, it is always 0.
4909 @item @var{until_count} @tab intent(in)  The number of events which have to be
4910 available before the function returns.
4911 @item @var{stat} @tab intent(out)  Stores the STAT=; may be NULL.
4912 @item @var{errmsg} @tab intent(out)  When an error occurs, this will be set to
4913 an error message; may be NULL.
4914 @item @var{errmsg_len} @tab intent(in)  the buffer size of errmsg
4915 @end multitable
4917 @item @emph{NOTES}
4918 This function only operates on a local coarray. It acts like a loop checking
4919 atomically the value of the event variable, breaking if the value is greater
4920 or equal the requested number of counts. Before the function returns, the
4921 event variable has to be decremented by the requested @var{until_count} value.
4922 A possible implementation would be a busy loop for a certain number of spins
4923 (possibly depending on the number of threads relative to the number of available
4924 cores) followed by another waiting strategy such as a sleeping wait (possibly
4925 with an increasing number of sleep time) or, if possible, a futex wait.
4927 The statement is an image-control statement but does not imply sync memory.
4928 Still, all preceeding push communications of this image to the specified
4929 remote image have to be completed before @code{event_wait} on the remote
4930 image returns.
4931 @end table
4935 @node _gfortran_caf_event_query
4936 @subsection @code{_gfortran_caf_event_query} --- Query event count
4937 @cindex Coarray, _gfortran_caf_event_query
4939 @table @asis
4940 @item @emph{Description}:
4941 Return the event count of the specified event variable.
4943 @item @emph{Syntax}:
4944 @code{void _gfortran_caf_event_query (caf_token_t token, size_t index,
4945 int image_index, int *count, int *stat)}
4947 @item @emph{Arguments}:
4948 @multitable @columnfractions .15 .70
4949 @item @var{token} @tab intent(in)  An opaque pointer identifying the coarray.
4950 @item @var{index} @tab intent(in)  Array index; first array index is 0.  For
4951 scalars, it is always 0.
4952 @item @var{image_index} @tab intent(in)  The ID of the remote image; must be a
4953 positive number; zero indicates the current image when accessed noncoindexed.
4954 @item @var{count} @tab intent(out)  The number of events currently posted to
4955 the event variable.
4956 @item @var{stat} @tab intent(out)  Stores the STAT=; may be NULL.
4957 @end multitable
4959 @item @emph{NOTES}
4960 The typical use is to check the local event variable to only call
4961 @code{event_wait} when the data is available. However, a coindexed variable
4962 is permitted; there is no ordering or synchronization implied.  It acts like
4963 an atomic fetch of the value of the event variable.
4964 @end table
4968 @node _gfortran_caf_sync_all
4969 @subsection @code{_gfortran_caf_sync_all} --- All-image barrier
4970 @cindex Coarray, _gfortran_caf_sync_all
4972 @table @asis
4973 @item @emph{Description}:
4974 Synchronization of all images in the current team; the program only continues
4975 on a given image after this function has been called on all images of the
4976 current team.  Additionally, it ensures that all pending data transfers of
4977 previous segment have completed.
4979 @item @emph{Syntax}:
4980 @code{void _gfortran_caf_sync_all (int *stat, char *errmsg, int errmsg_len)}
4982 @item @emph{Arguments}:
4983 @multitable @columnfractions .15 .70
4984 @item @var{stat} @tab intent(out)  Stores the status STAT= and may be NULL.
4985 @item @var{errmsg} @tab intent(out)  When an error occurs, this will be set to
4986 an error message; may be NULL.
4987 @item @var{errmsg_len} @tab intent(in)  the buffer size of errmsg
4988 @end multitable
4989 @end table
4993 @node _gfortran_caf_sync_images
4994 @subsection @code{_gfortran_caf_sync_images} --- Barrier for selected images
4995 @cindex Coarray, _gfortran_caf_sync_images
4997 @table @asis
4998 @item @emph{Description}:
4999 Synchronization between the specified images; the program only continues on a
5000 given image after this function has been called on all images specified for
5001 that image. Note that one image can wait for all other images in the current
5002 team (e.g. via @code{sync images(*)}) while those only wait for that specific
5003 image.  Additionally, @code{sync images} ensures that all pending data
5004 transfers of previous segments have completed.
5006 @item @emph{Syntax}:
5007 @code{void _gfortran_caf_sync_images (int count, int images[], int *stat,
5008 char *errmsg, int errmsg_len)}
5010 @item @emph{Arguments}:
5011 @multitable @columnfractions .15 .70
5012 @item @var{count} @tab intent(in)  The number of images which are provided in
5013 the next argument.  For a zero-sized array, the value is zero.  For
5014 @code{sync images (*)}, the value is @math{-1}.
5015 @item @var{images} @tab intent(in)  An array with the images provided by the
5016 user.  If @var{count} is zero, a NULL pointer is passed.
5017 @item @var{stat} @tab intent(out)  Stores the status STAT= and may be NULL.
5018 @item @var{errmsg} @tab intent(out)  When an error occurs, this will be set to
5019 an error message; may be NULL.
5020 @item @var{errmsg_len} @tab intent(in)  the buffer size of errmsg
5021 @end multitable
5022 @end table
5026 @node _gfortran_caf_sync_memory
5027 @subsection @code{_gfortran_caf_sync_memory} --- Wait for completion of segment-memory operations
5028 @cindex Coarray, _gfortran_caf_sync_memory
5030 @table @asis
5031 @item @emph{Description}:
5032 Acts as optimization barrier between different segments. It also ensures that
5033 all pending memory operations of this image have been completed.
5035 @item @emph{Syntax}:
5036 @code{void _gfortran_caf_sync_memory (int *stat, char *errmsg, int errmsg_len)}
5038 @item @emph{Arguments}:
5039 @multitable @columnfractions .15 .70
5040 @item @var{stat} @tab intent(out)  Stores the status STAT= and may be NULL.
5041 @item @var{errmsg} @tab intent(out)  When an error occurs, this will be set to
5042 an error message; may be NULL.
5043 @item @var{errmsg_len} @tab intent(in)  the buffer size of errmsg
5044 @end multitable
5046 @item @emph{NOTE} A simple implementation could be
5047 @code{__asm__ __volatile__ ("":::"memory")} to prevent code movements.
5048 @end table
5052 @node _gfortran_caf_error_stop
5053 @subsection @code{_gfortran_caf_error_stop} --- Error termination with exit code
5054 @cindex Coarray, _gfortran_caf_error_stop
5056 @table @asis
5057 @item @emph{Description}:
5058 Invoked for an @code{ERROR STOP} statement which has an integer argument.  The
5059 function should terminate the program with the specified exit code.
5062 @item @emph{Syntax}:
5063 @code{void _gfortran_caf_error_stop (int32_t error)}
5065 @item @emph{Arguments}:
5066 @multitable @columnfractions .15 .70
5067 @item @var{error} @tab intent(in)  The exit status to be used.
5068 @end multitable
5069 @end table
5073 @node _gfortran_caf_error_stop_str
5074 @subsection @code{_gfortran_caf_error_stop_str} --- Error termination with string
5075 @cindex Coarray, _gfortran_caf_error_stop_str
5077 @table @asis
5078 @item @emph{Description}:
5079 Invoked for an @code{ERROR STOP} statement which has a string as argument.  The
5080 function should terminate the program with a nonzero-exit code.
5082 @item @emph{Syntax}:
5083 @code{void _gfortran_caf_error_stop (const char *string, int32_t len)}
5085 @item @emph{Arguments}:
5086 @multitable @columnfractions .15 .70
5087 @item @var{string} @tab intent(in)  the error message (not zero terminated)
5088 @item @var{len} @tab intent(in)  the length of the string
5089 @end multitable
5090 @end table
5094 @node _gfortran_caf_fail_image
5095 @subsection @code{_gfortran_caf_fail_image} --- Mark the image failed and end its execution
5096 @cindex Coarray, _gfortran_caf_fail_image
5098 @table @asis
5099 @item @emph{Description}:
5100 Invoked for an @code{FAIL IMAGE} statement.  The function should terminate the
5101 current image.
5103 @item @emph{Syntax}:
5104 @code{void _gfortran_caf_fail_image ()}
5106 @item @emph{NOTES}
5107 This function follows TS18508.
5108 @end table
5112 @node _gfortran_caf_atomic_define
5113 @subsection @code{_gfortran_caf_atomic_define} --- Atomic variable assignment
5114 @cindex Coarray, _gfortran_caf_atomic_define
5116 @table @asis
5117 @item @emph{Description}:
5118 Assign atomically a value to an integer or logical variable.
5120 @item @emph{Syntax}:
5121 @code{void _gfortran_caf_atomic_define (caf_token_t token, size_t offset,
5122 int image_index, void *value, int *stat, int type, int kind)}
5124 @item @emph{Arguments}:
5125 @multitable @columnfractions .15 .70
5126 @item @var{token} @tab intent(in)  An opaque pointer identifying the coarray.
5127 @item @var{offset} @tab intent(in)  By which amount of bytes the actual data is
5128 shifted compared to the base address of the coarray.
5129 @item @var{image_index} @tab intent(in)  The ID of the remote image; must be a
5130 positive number; zero indicates the current image when used noncoindexed.
5131 @item @var{value} @tab intent(in)  the value to be assigned, passed by reference
5132 @item @var{stat} @tab intent(out)  Stores the status STAT= and may be NULL.
5133 @item @var{type} @tab intent(in)  The data type, i.e. @code{BT_INTEGER} (1) or
5134 @code{BT_LOGICAL} (2).
5135 @item @var{kind} @tab intent(in)  The kind value (only 4; always @code{int})
5136 @end multitable
5137 @end table
5141 @node _gfortran_caf_atomic_ref
5142 @subsection @code{_gfortran_caf_atomic_ref} --- Atomic variable reference
5143 @cindex Coarray, _gfortran_caf_atomic_ref
5145 @table @asis
5146 @item @emph{Description}:
5147 Reference atomically a value of a kind-4 integer or logical variable.
5149 @item @emph{Syntax}:
5150 @code{void _gfortran_caf_atomic_ref (caf_token_t token, size_t offset,
5151 int image_index, void *value, int *stat, int type, int kind)}
5153 @item @emph{Arguments}:
5154 @multitable @columnfractions .15 .70
5155 @item @var{token} @tab intent(in)  An opaque pointer identifying the coarray.
5156 @item @var{offset} @tab intent(in)  By which amount of bytes the actual data is
5157 shifted compared to the base address of the coarray.
5158 @item @var{image_index} @tab intent(in)  The ID of the remote image; must be a
5159 positive number; zero indicates the current image when used noncoindexed.
5160 @item @var{value} @tab intent(out)  The variable assigned the atomically
5161 referenced variable.
5162 @item @var{stat} @tab intent(out) Stores the status STAT= and may be NULL.
5163 @item @var{type} @tab the data type, i.e. @code{BT_INTEGER} (1) or
5164 @code{BT_LOGICAL} (2).
5165 @item @var{kind} @tab The kind value (only 4; always @code{int})
5166 @end multitable
5167 @end table
5171 @node _gfortran_caf_atomic_cas
5172 @subsection @code{_gfortran_caf_atomic_cas} --- Atomic compare and swap
5173 @cindex Coarray, _gfortran_caf_atomic_cas
5175 @table @asis
5176 @item @emph{Description}:
5177 Atomic compare and swap of a kind-4 integer or logical variable. Assigns
5178 atomically the specified value to the atomic variable, if the latter has
5179 the value specified by the passed condition value.
5181 @item @emph{Syntax}:
5182 @code{void _gfortran_caf_atomic_cas (caf_token_t token, size_t offset,
5183 int image_index, void *old, void *compare, void *new_val, int *stat,
5184 int type, int kind)}
5186 @item @emph{Arguments}:
5187 @multitable @columnfractions .15 .70
5188 @item @var{token} @tab intent(in)  An opaque pointer identifying the coarray.
5189 @item @var{offset} @tab intent(in)  By which amount of bytes the actual data is
5190 shifted compared to the base address of the coarray.
5191 @item @var{image_index} @tab intent(in)  The ID of the remote image; must be a
5192 positive number; zero indicates the current image when used noncoindexed.
5193 @item @var{old} @tab intent(out)  The value which the atomic variable had
5194 just before the cas operation.
5195 @item @var{compare} @tab intent(in)  The value used for comparision.
5196 @item @var{new_val} @tab intent(in)  The new value for the atomic variable,
5197 assigned to the atomic variable, if @code{compare} equals the value of the
5198 atomic variable.
5199 @item @var{stat} @tab intent(out)  Stores the status STAT= and may be NULL.
5200 @item @var{type} @tab intent(in)  the data type, i.e. @code{BT_INTEGER} (1) or
5201 @code{BT_LOGICAL} (2).
5202 @item @var{kind} @tab intent(in)  The kind value (only 4; always @code{int})
5203 @end multitable
5204 @end table
5208 @node _gfortran_caf_atomic_op
5209 @subsection @code{_gfortran_caf_atomic_op} --- Atomic operation
5210 @cindex Coarray, _gfortran_caf_atomic_op
5212 @table @asis
5213 @item @emph{Description}:
5214 Apply an operation atomically to an atomic integer or logical variable.
5215 After the operation, @var{old} contains the value just before the operation,
5216 which, respectively, adds (GFC_CAF_ATOMIC_ADD) atomically the @code{value} to
5217 the atomic integer variable or does a bitwise AND, OR or exclusive OR
5218 between the atomic variable and @var{value}; the result is then stored in the
5219 atomic variable.
5221 @item @emph{Syntax}:
5222 @code{void _gfortran_caf_atomic_op (int op, caf_token_t token, size_t offset,
5223 int image_index, void *value, void *old, int *stat, int type, int kind)}
5225 @item @emph{Arguments}:
5226 @multitable @columnfractions .15 .70
5227 @item @var{op} @tab intent(in)  the operation to be performed; possible values
5228 @code{GFC_CAF_ATOMIC_ADD} (1), @code{GFC_CAF_ATOMIC_AND} (2),
5229 @code{GFC_CAF_ATOMIC_OR} (3), @code{GFC_CAF_ATOMIC_XOR} (4).
5230 @item @var{token} @tab intent(in)  An opaque pointer identifying the coarray.
5231 @item @var{offset} @tab intent(in)  By which amount of bytes the actual data is
5232 shifted compared to the base address of the coarray.
5233 @item @var{image_index} @tab intent(in)  The ID of the remote image; must be a
5234 positive number; zero indicates the current image when used noncoindexed.
5235 @item @var{old} @tab intent(out)  The value which the atomic variable had
5236 just before the atomic operation.
5237 @item @var{val} @tab intent(in)  The new value for the atomic variable,
5238 assigned to the atomic variable, if @code{compare} equals the value of the
5239 atomic variable.
5240 @item @var{stat} @tab intent(out)  Stores the status STAT= and may be NULL.
5241 @item @var{type} @tab intent(in)  the data type, i.e. @code{BT_INTEGER} (1) or
5242 @code{BT_LOGICAL} (2)
5243 @item @var{kind} @tab intent(in)  the kind value (only 4; always @code{int})
5244 @end multitable
5245 @end table
5250 @node _gfortran_caf_co_broadcast
5251 @subsection @code{_gfortran_caf_co_broadcast} --- Sending data to all images
5252 @cindex Coarray, _gfortran_caf_co_broadcast
5254 @table @asis
5255 @item @emph{Description}:
5256 Distribute a value from a given image to all other images in the team. Has to
5257 be called collectively.
5259 @item @emph{Syntax}:
5260 @code{void _gfortran_caf_co_broadcast (gfc_descriptor_t *a,
5261 int source_image, int *stat, char *errmsg, int errmsg_len)}
5263 @item @emph{Arguments}:
5264 @multitable @columnfractions .15 .70
5265 @item @var{a} @tab intent(inout)  An array descriptor with the data to be
5266 broadcasted (on @var{source_image}) or to be received (other images).
5267 @item @var{source_image} @tab intent(in)  The ID of the image from which the
5268 data should be broadcasted.
5269 @item @var{stat} @tab intent(out)  Stores the status STAT= and may be NULL.
5270 @item @var{errmsg} @tab intent(out)  When an error occurs, this will be set to
5271 an error message; may be NULL.
5272 @item @var{errmsg_len} @tab intent(in)  the buffer size of errmsg.
5273 @end multitable
5274 @end table
5278 @node _gfortran_caf_co_max
5279 @subsection @code{_gfortran_caf_co_max} --- Collective maximum reduction
5280 @cindex Coarray, _gfortran_caf_co_max
5282 @table @asis
5283 @item @emph{Description}:
5284 Calculates for each array element of the variable @var{a} the maximum
5285 value for that element in the current team; if @var{result_image} has the
5286 value 0, the result shall be stored on all images, otherwise, only on the
5287 specified image. This function operates on numeric values and character
5288 strings.
5290 @item @emph{Syntax}:
5291 @code{void _gfortran_caf_co_max (gfc_descriptor_t *a, int result_image,
5292 int *stat, char *errmsg, int a_len, int errmsg_len)}
5294 @item @emph{Arguments}:
5295 @multitable @columnfractions .15 .70
5296 @item @var{a} @tab intent(inout)  An array descriptor for the data to be
5297 processed.  On the destination image(s) the result overwrites the old content.
5298 @item @var{result_image} @tab intent(in)  The ID of the image to which the
5299 reduced value should be copied to; if zero, it has to be copied to all images.
5300 @item @var{stat} @tab intent(out)  Stores the status STAT= and may be NULL.
5301 @item @var{errmsg} @tab intent(out)  When an error occurs, this will be set to
5302 an error message; may be NULL.
5303 @item @var{a_len} @tab intent(in)  the string length of argument @var{a}
5304 @item @var{errmsg_len} @tab intent(in)  the buffer size of errmsg
5305 @end multitable
5307 @item @emph{NOTES}
5308 If @var{result_image} is nonzero, the data in the array descriptor @var{a} on
5309 all images except of the specified one become undefined; hence, the library may
5310 make use of this.
5311 @end table
5315 @node _gfortran_caf_co_min
5316 @subsection @code{_gfortran_caf_co_min} --- Collective minimum reduction
5317 @cindex Coarray, _gfortran_caf_co_min
5319 @table @asis
5320 @item @emph{Description}:
5321 Calculates for each array element of the variable @var{a} the minimum
5322 value for that element in the current team; if @var{result_image} has the
5323 value 0, the result shall be stored on all images, otherwise, only on the
5324 specified image. This function operates on numeric values and character
5325 strings.
5327 @item @emph{Syntax}:
5328 @code{void _gfortran_caf_co_min (gfc_descriptor_t *a, int result_image,
5329 int *stat, char *errmsg, int a_len, int errmsg_len)}
5331 @item @emph{Arguments}:
5332 @multitable @columnfractions .15 .70
5333 @item @var{a} @tab intent(inout)  An array descriptor for the data to be
5334 processed.  On the destination image(s) the result overwrites the old content.
5335 @item @var{result_image} @tab intent(in)  The ID of the image to which the
5336 reduced value should be copied to; if zero, it has to be copied to all images.
5337 @item @var{stat} @tab intent(out)  Stores the status STAT= and may be NULL.
5338 @item @var{errmsg} @tab intent(out)  When an error occurs, this will be set to
5339 an error message; may be NULL.
5340 @item @var{a_len} @tab intent(in)  the string length of argument @var{a}
5341 @item @var{errmsg_len} @tab intent(in)  the buffer size of errmsg
5342 @end multitable
5344 @item @emph{NOTES}
5345 If @var{result_image} is nonzero, the data in the array descriptor @var{a} on
5346 all images except of the specified one become undefined; hence, the library may
5347 make use of this.
5348 @end table
5352 @node _gfortran_caf_co_sum
5353 @subsection @code{_gfortran_caf_co_sum} --- Collective summing reduction
5354 @cindex Coarray, _gfortran_caf_co_sum
5356 @table @asis
5357 @item @emph{Description}:
5358 Calculates for each array element of the variable @var{a} the sum of all
5359 values for that element in the current team; if @var{result_image} has the
5360 value 0, the result shall be stored on all images, otherwise, only on the
5361 specified image.  This function operates on numeric values only.
5363 @item @emph{Syntax}:
5364 @code{void _gfortran_caf_co_sum (gfc_descriptor_t *a, int result_image,
5365 int *stat, char *errmsg, int errmsg_len)}
5367 @item @emph{Arguments}:
5368 @multitable @columnfractions .15 .70
5369 @item @var{a} @tab intent(inout)  An array descriptor with the data to be
5370 processed.  On the destination image(s) the result overwrites the old content.
5371 @item @var{result_image} @tab intent(in)  The ID of the image to which the
5372 reduced value should be copied to; if zero, it has to be copied to all images.
5373 @item @var{stat} @tab intent(out)  Stores the status STAT= and may be NULL.
5374 @item @var{errmsg} @tab intent(out)  When an error occurs, this will be set to
5375 an error message; may be NULL.
5376 @item @var{errmsg_len} @tab intent(in)  the buffer size of errmsg
5377 @end multitable
5379 @item @emph{NOTES}
5380 If @var{result_image} is nonzero, the data in the array descriptor @var{a} on
5381 all images except of the specified one become undefined; hence, the library may
5382 make use of this.
5383 @end table
5387 @node _gfortran_caf_co_reduce
5388 @subsection @code{_gfortran_caf_co_reduce} --- Generic collective reduction
5389 @cindex Coarray, _gfortran_caf_co_reduce
5391 @table @asis
5392 @item @emph{Description}:
5393 Calculates for each array element of the variable @var{a} the reduction
5394 value for that element in the current team; if @var{result_image} has the
5395 value 0, the result shall be stored on all images, otherwise, only on the
5396 specified image.  The @var{opr} is a pure function doing a mathematically
5397 commutative and associative operation.
5399 The @var{opr_flags} denote the following; the values are bitwise ored.
5400 @code{GFC_CAF_BYREF} (1) if the result should be returned
5401 by reference; @code{GFC_CAF_HIDDENLEN} (2) whether the result and argument
5402 string lengths shall be specified as hidden arguments;
5403 @code{GFC_CAF_ARG_VALUE} (4) whether the arguments shall be passed by value,
5404 @code{GFC_CAF_ARG_DESC} (8) whether the arguments shall be passed by descriptor.
5407 @item @emph{Syntax}:
5408 @code{void _gfortran_caf_co_reduce (gfc_descriptor_t *a,
5409 void * (*opr) (void *, void *), int opr_flags, int result_image,
5410 int *stat, char *errmsg, int a_len, int errmsg_len)}
5412 @item @emph{Arguments}:
5413 @multitable @columnfractions .15 .70
5414 @item @var{a} @tab intent(inout)  An array descriptor with the data to be
5415 processed.  On the destination image(s) the result overwrites the old content.
5416 @item @var{opr} @tab intent(in)  Function pointer to the reduction function
5417 @item @var{opr_flags} @tab intent(in)  Flags regarding the reduction function
5418 @item @var{result_image} @tab intent(in)  The ID of the image to which the
5419 reduced value should be copied to; if zero, it has to be copied to all images.
5420 @item @var{stat} @tab intent(out)  Stores the status STAT= and may be NULL.
5421 @item @var{errmsg} @tab intent(out)  When an error occurs, this will be set to
5422 an error message; may be NULL.
5423 @item @var{a_len} @tab intent(in)  the string length of argument @var{a}
5424 @item @var{errmsg_len} @tab intent(in)  the buffer size of errmsg
5425 @end multitable
5427 @item @emph{NOTES}
5428 If @var{result_image} is nonzero, the data in the array descriptor @var{a} on
5429 all images except of the specified one become undefined; hence, the library may
5430 make use of this.
5432 For character arguments, the result is passed as first argument, followed
5433 by the result string length, next come the two string arguments, followed
5434 by the two hidden string length arguments.  With C binding, there are no hidden
5435 arguments and by-reference passing and either only a single character is passed
5436 or an array descriptor.
5437 @end table
5440 @c Intrinsic Procedures
5441 @c ---------------------------------------------------------------------
5443 @include intrinsic.texi
5446 @tex
5447 \blankpart
5448 @end tex
5450 @c ---------------------------------------------------------------------
5451 @c Contributing
5452 @c ---------------------------------------------------------------------
5454 @node Contributing
5455 @unnumbered Contributing
5456 @cindex Contributing
5458 Free software is only possible if people contribute to efforts
5459 to create it.
5460 We're always in need of more people helping out with ideas
5461 and comments, writing documentation and contributing code.
5463 If you want to contribute to GNU Fortran,
5464 have a look at the long lists of projects you can take on.
5465 Some of these projects are small,
5466 some of them are large;
5467 some are completely orthogonal to the rest of what is
5468 happening on GNU Fortran,
5469 but others are ``mainstream'' projects in need of enthusiastic hackers.
5470 All of these projects are important!
5471 We will eventually get around to the things here,
5472 but they are also things doable by someone who is willing and able.
5474 @menu
5475 * Contributors::
5476 * Projects::
5477 * Proposed Extensions::
5478 @end menu
5481 @node Contributors
5482 @section Contributors to GNU Fortran
5483 @cindex Contributors
5484 @cindex Credits
5485 @cindex Authors
5487 Most of the parser was hand-crafted by @emph{Andy Vaught}, who is
5488 also the initiator of the whole project.  Thanks Andy!
5489 Most of the interface with GCC was written by @emph{Paul Brook}.
5491 The following individuals have contributed code and/or
5492 ideas and significant help to the GNU Fortran project
5493 (in alphabetical order):
5495 @itemize @minus
5496 @item Janne Blomqvist
5497 @item Steven Bosscher
5498 @item Paul Brook
5499 @item Tobias Burnus
5500 @item Fran@,{c}ois-Xavier Coudert
5501 @item Bud Davis
5502 @item Jerry DeLisle
5503 @item Erik Edelmann
5504 @item Bernhard Fischer
5505 @item Daniel Franke
5506 @item Richard Guenther
5507 @item Richard Henderson
5508 @item Katherine Holcomb
5509 @item Jakub Jelinek
5510 @item Niels Kristian Bech Jensen
5511 @item Steven Johnson
5512 @item Steven G. Kargl
5513 @item Thomas Koenig
5514 @item Asher Langton
5515 @item H. J. Lu
5516 @item Toon Moene
5517 @item Brooks Moses
5518 @item Andrew Pinski
5519 @item Tim Prince
5520 @item Christopher D. Rickett
5521 @item Richard Sandiford
5522 @item Tobias Schl@"uter
5523 @item Roger Sayle
5524 @item Paul Thomas
5525 @item Andy Vaught
5526 @item Feng Wang
5527 @item Janus Weil
5528 @item Daniel Kraft
5529 @end itemize
5531 The following people have contributed bug reports,
5532 smaller or larger patches,
5533 and much needed feedback and encouragement for the
5534 GNU Fortran project: 
5536 @itemize @minus
5537 @item Bill Clodius
5538 @item Dominique d'Humi@`eres
5539 @item Kate Hedstrom
5540 @item Erik Schnetter
5541 @item Joost VandeVondele
5542 @end itemize
5544 Many other individuals have helped debug,
5545 test and improve the GNU Fortran compiler over the past few years,
5546 and we welcome you to do the same!
5547 If you already have done so,
5548 and you would like to see your name listed in the
5549 list above, please contact us.
5552 @node Projects
5553 @section Projects
5555 @table @emph
5557 @item Help build the test suite
5558 Solicit more code for donation to the test suite: the more extensive the
5559 testsuite, the smaller the risk of breaking things in the future! We can
5560 keep code private on request.
5562 @item Bug hunting/squishing
5563 Find bugs and write more test cases! Test cases are especially very
5564 welcome, because it allows us to concentrate on fixing bugs instead of
5565 isolating them.  Going through the bugzilla database at
5566 @url{https://gcc.gnu.org/@/bugzilla/} to reduce testcases posted there and
5567 add more information (for example, for which version does the testcase
5568 work, for which versions does it fail?) is also very helpful.
5570 @end table
5573 @node Proposed Extensions
5574 @section Proposed Extensions
5576 Here's a list of proposed extensions for the GNU Fortran compiler, in no particular
5577 order.  Most of these are necessary to be fully compatible with
5578 existing Fortran compilers, but they are not part of the official
5579 J3 Fortran 95 standard.
5581 @subsection Compiler extensions:
5582 @itemize @bullet
5583 @item
5584 User-specified alignment rules for structures.
5586 @item
5587 Automatically extend single precision constants to double.
5589 @item
5590 Compile code that conserves memory by dynamically allocating common and
5591 module storage either on stack or heap.
5593 @item
5594 Compile flag to generate code for array conformance checking (suggest -CC).
5596 @item
5597 User control of symbol names (underscores, etc).
5599 @item
5600 Compile setting for maximum size of stack frame size before spilling
5601 parts to static or heap.
5603 @item
5604 Flag to force local variables into static space.
5606 @item
5607 Flag to force local variables onto stack.
5608 @end itemize
5611 @subsection Environment Options
5612 @itemize @bullet
5613 @item
5614 Pluggable library modules for random numbers, linear algebra.
5615 LA should use BLAS calling conventions.
5617 @item
5618 Environment variables controlling actions on arithmetic exceptions like
5619 overflow, underflow, precision loss---Generate NaN, abort, default.
5620 action.
5622 @item
5623 Set precision for fp units that support it (i387).
5625 @item
5626 Variable for setting fp rounding mode.
5628 @item
5629 Variable to fill uninitialized variables with a user-defined bit
5630 pattern.
5632 @item
5633 Environment variable controlling filename that is opened for that unit
5634 number.
5636 @item
5637 Environment variable to clear/trash memory being freed.
5639 @item
5640 Environment variable to control tracing of allocations and frees.
5642 @item
5643 Environment variable to display allocated memory at normal program end.
5645 @item
5646 Environment variable for filename for * IO-unit.
5648 @item
5649 Environment variable for temporary file directory.
5651 @item
5652 Environment variable forcing standard output to be line buffered (Unix).
5654 @end itemize
5657 @c ---------------------------------------------------------------------
5658 @c GNU General Public License
5659 @c ---------------------------------------------------------------------
5661 @include gpl_v3.texi
5665 @c ---------------------------------------------------------------------
5666 @c GNU Free Documentation License
5667 @c ---------------------------------------------------------------------
5669 @include fdl.texi
5673 @c ---------------------------------------------------------------------
5674 @c Funding Free Software
5675 @c ---------------------------------------------------------------------
5677 @include funding.texi
5679 @c ---------------------------------------------------------------------
5680 @c Indices
5681 @c ---------------------------------------------------------------------
5683 @node Option Index
5684 @unnumbered Option Index
5685 @command{gfortran}'s command line options are indexed here without any
5686 initial @samp{-} or @samp{--}.  Where an option has both positive and
5687 negative forms (such as -foption and -fno-option), relevant entries in
5688 the manual are indexed under the most appropriate form; it may sometimes
5689 be useful to look up both forms.
5690 @printindex op
5692 @node Keyword Index
5693 @unnumbered Keyword Index
5694 @printindex cp
5696 @bye