PR 78534 Change character length from int to size_t
[official-gcc.git] / gcc / fortran / gfortran.texi
blob1a36dd7b80d473bb5c22df9a033018010a2cf013
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})
1150 @end itemize
1153 @c ---------------------------------------------------------------------
1154 @c Compiler Characteristics
1155 @c ---------------------------------------------------------------------
1157 @node Compiler Characteristics
1158 @chapter Compiler Characteristics
1160 This chapter describes certain characteristics of the GNU Fortran
1161 compiler, that are not specified by the Fortran standard, but which
1162 might in some way or another become visible to the programmer.
1164 @menu
1165 * KIND Type Parameters::
1166 * Internal representation of LOGICAL variables::
1167 * Thread-safety of the runtime library::
1168 * Data consistency and durability::
1169 * Files opened without an explicit ACTION= specifier::
1170 * File operations on symbolic links::
1171 @end menu
1174 @node KIND Type Parameters
1175 @section KIND Type Parameters
1176 @cindex kind
1178 The @code{KIND} type parameters supported by GNU Fortran for the primitive
1179 data types are:
1181 @table @code
1183 @item INTEGER
1184 1, 2, 4, 8*, 16*, default: 4**
1186 @item LOGICAL
1187 1, 2, 4, 8*, 16*, default: 4**
1189 @item REAL
1190 4, 8, 10*, 16*, default: 4***
1192 @item COMPLEX
1193 4, 8, 10*, 16*, default: 4***
1195 @item DOUBLE PRECISION
1196 4, 8, 10*, 16*, default: 8***
1198 @item CHARACTER
1199 1, 4, default: 1
1201 @end table
1203 @noindent
1204 * not available on all systems @*
1205 ** unless @option{-fdefault-integer-8} is used @*
1206 *** unless @option{-fdefault-real-8} is used (see @ref{Fortran Dialect Options})
1208 @noindent
1209 The @code{KIND} value matches the storage size in bytes, except for
1210 @code{COMPLEX} where the storage size is twice as much (or both real and
1211 imaginary part are a real value of the given size).  It is recommended to use
1212 the @ref{SELECTED_CHAR_KIND}, @ref{SELECTED_INT_KIND} and
1213 @ref{SELECTED_REAL_KIND} intrinsics or the @code{INT8}, @code{INT16},
1214 @code{INT32}, @code{INT64}, @code{REAL32}, @code{REAL64}, and @code{REAL128}
1215 parameters of the @code{ISO_FORTRAN_ENV} module instead of the concrete values.
1216 The available kind parameters can be found in the constant arrays
1217 @code{CHARACTER_KINDS}, @code{INTEGER_KINDS}, @code{LOGICAL_KINDS} and
1218 @code{REAL_KINDS} in the @ref{ISO_FORTRAN_ENV} module.  For C interoperability,
1219 the kind parameters of the @ref{ISO_C_BINDING} module should be used.
1222 @node Internal representation of LOGICAL variables
1223 @section Internal representation of LOGICAL variables
1224 @cindex logical, variable representation
1226 The Fortran standard does not specify how variables of @code{LOGICAL}
1227 type are represented, beyond requiring that @code{LOGICAL} variables
1228 of default kind have the same storage size as default @code{INTEGER}
1229 and @code{REAL} variables.  The GNU Fortran internal representation is
1230 as follows.
1232 A @code{LOGICAL(KIND=N)} variable is represented as an
1233 @code{INTEGER(KIND=N)} variable, however, with only two permissible
1234 values: @code{1} for @code{.TRUE.} and @code{0} for
1235 @code{.FALSE.}.  Any other integer value results in undefined behavior.
1237 See also @ref{Argument passing conventions} and @ref{Interoperability with C}.
1240 @node Thread-safety of the runtime library
1241 @section Thread-safety of the runtime library
1242 @cindex thread-safety, threads
1244 GNU Fortran can be used in programs with multiple threads, e.g.@: by
1245 using OpenMP, by calling OS thread handling functions via the
1246 @code{ISO_C_BINDING} facility, or by GNU Fortran compiled library code
1247 being called from a multi-threaded program.
1249 The GNU Fortran runtime library, (@code{libgfortran}), supports being
1250 called concurrently from multiple threads with the following
1251 exceptions. 
1253 During library initialization, the C @code{getenv} function is used,
1254 which need not be thread-safe.  Similarly, the @code{getenv}
1255 function is used to implement the @code{GET_ENVIRONMENT_VARIABLE} and
1256 @code{GETENV} intrinsics.  It is the responsibility of the user to
1257 ensure that the environment is not being updated concurrently when any
1258 of these actions are taking place.
1260 The @code{EXECUTE_COMMAND_LINE} and @code{SYSTEM} intrinsics are
1261 implemented with the @code{system} function, which need not be
1262 thread-safe.  It is the responsibility of the user to ensure that
1263 @code{system} is not called concurrently.
1265 For platforms not supporting thread-safe POSIX functions, further
1266 functionality might not be thread-safe.  For details, please consult
1267 the documentation for your operating system.
1269 The GNU Fortran runtime library uses various C library functions that
1270 depend on the locale, such as @code{strtod} and @code{snprintf}.  In
1271 order to work correctly in locale-aware programs that set the locale
1272 using @code{setlocale}, the locale is reset to the default ``C''
1273 locale while executing a formatted @code{READ} or @code{WRITE}
1274 statement.  On targets supporting the POSIX 2008 per-thread locale
1275 functions (e.g. @code{newlocale}, @code{uselocale},
1276 @code{freelocale}), these are used and thus the global locale set
1277 using @code{setlocale} or the per-thread locales in other threads are
1278 not affected.  However, on targets lacking this functionality, the
1279 global LC_NUMERIC locale is set to ``C'' during the formatted I/O.
1280 Thus, on such targets it's not safe to call @code{setlocale}
1281 concurrently from another thread while a Fortran formatted I/O
1282 operation is in progress.  Also, other threads doing something
1283 dependent on the LC_NUMERIC locale might not work correctly if a
1284 formatted I/O operation is in progress in another thread.
1286 @node Data consistency and durability
1287 @section Data consistency and durability
1288 @cindex consistency, durability
1290 This section contains a brief overview of data and metadata
1291 consistency and durability issues when doing I/O.
1293 With respect to durability, GNU Fortran makes no effort to ensure that
1294 data is committed to stable storage. If this is required, the GNU
1295 Fortran programmer can use the intrinsic @code{FNUM} to retrieve the
1296 low level file descriptor corresponding to an open Fortran unit. Then,
1297 using e.g. the @code{ISO_C_BINDING} feature, one can call the
1298 underlying system call to flush dirty data to stable storage, such as
1299 @code{fsync} on POSIX, @code{_commit} on MingW, or @code{fcntl(fd,
1300 F_FULLSYNC, 0)} on Mac OS X. The following example shows how to call
1301 fsync:
1303 @smallexample
1304   ! Declare the interface for POSIX fsync function
1305   interface
1306     function fsync (fd) bind(c,name="fsync")
1307     use iso_c_binding, only: c_int
1308       integer(c_int), value :: fd
1309       integer(c_int) :: fsync
1310     end function fsync
1311   end interface
1313   ! Variable declaration
1314   integer :: ret
1316   ! Opening unit 10
1317   open (10,file="foo")
1319   ! ...
1320   ! Perform I/O on unit 10
1321   ! ...
1323   ! Flush and sync
1324   flush(10)
1325   ret = fsync(fnum(10))
1327   ! Handle possible error
1328   if (ret /= 0) stop "Error calling FSYNC"
1329 @end smallexample
1331 With respect to consistency, for regular files GNU Fortran uses
1332 buffered I/O in order to improve performance. This buffer is flushed
1333 automatically when full and in some other situations, e.g. when
1334 closing a unit. It can also be explicitly flushed with the
1335 @code{FLUSH} statement. Also, the buffering can be turned off with the
1336 @code{GFORTRAN_UNBUFFERED_ALL} and
1337 @code{GFORTRAN_UNBUFFERED_PRECONNECTED} environment variables. Special
1338 files, such as terminals and pipes, are always unbuffered. Sometimes,
1339 however, further things may need to be done in order to allow other
1340 processes to see data that GNU Fortran has written, as follows.
1342 The Windows platform supports a relaxed metadata consistency model,
1343 where file metadata is written to the directory lazily. This means
1344 that, for instance, the @code{dir} command can show a stale size for a
1345 file. One can force a directory metadata update by closing the unit,
1346 or by calling @code{_commit} on the file descriptor. Note, though,
1347 that @code{_commit} will force all dirty data to stable storage, which
1348 is often a very slow operation.
1350 The Network File System (NFS) implements a relaxed consistency model
1351 called open-to-close consistency. Closing a file forces dirty data and
1352 metadata to be flushed to the server, and opening a file forces the
1353 client to contact the server in order to revalidate cached
1354 data. @code{fsync} will also force a flush of dirty data and metadata
1355 to the server. Similar to @code{open} and @code{close}, acquiring and
1356 releasing @code{fcntl} file locks, if the server supports them, will
1357 also force cache validation and flushing dirty data and metadata.
1360 @node Files opened without an explicit ACTION= specifier
1361 @section Files opened without an explicit ACTION= specifier
1362 @cindex open, action
1364 The Fortran standard says that if an @code{OPEN} statement is executed
1365 without an explicit @code{ACTION=} specifier, the default value is
1366 processor dependent.  GNU Fortran behaves as follows:
1368 @enumerate
1369 @item Attempt to open the file with @code{ACTION='READWRITE'}
1370 @item If that fails, try to open with @code{ACTION='READ'}
1371 @item If that fails, try to open with @code{ACTION='WRITE'}
1372 @item If that fails, generate an error
1373 @end enumerate
1376 @node File operations on symbolic links
1377 @section File operations on symbolic links
1378 @cindex file, symbolic link
1380 This section documents the behavior of GNU Fortran for file operations on
1381 symbolic links, on systems that support them. 
1383 @itemize
1385 @item Results of INQUIRE statements of the ``inquire by file'' form will
1386 relate to the target of the symbolic link. For example,
1387 @code{INQUIRE(FILE="foo",EXIST=ex)} will set @var{ex} to @var{.true.} if
1388 @var{foo} is a symbolic link pointing to an existing file, and @var{.false.}
1389 if @var{foo} points to an non-existing file (``dangling'' symbolic link).
1391 @item Using the @code{OPEN} statement with a @code{STATUS="NEW"} specifier
1392 on a symbolic link will result in an error condition, whether the symbolic
1393 link points to an existing target or is dangling.
1395 @item If a symbolic link was connected, using the @code{CLOSE} statement
1396 with a @code{STATUS="DELETE"} specifier will cause the symbolic link itself
1397 to be deleted, not its target.
1399 @end itemize
1403 @c ---------------------------------------------------------------------
1404 @c Extensions
1405 @c ---------------------------------------------------------------------
1407 @c Maybe this chapter should be merged with the 'Standards' section,
1408 @c whenever that is written :-)
1410 @node Extensions
1411 @chapter Extensions
1412 @cindex extensions
1414 The two sections below detail the extensions to standard Fortran that are
1415 implemented in GNU Fortran, as well as some of the popular or
1416 historically important extensions that are not (or not yet) implemented.
1417 For the latter case, we explain the alternatives available to GNU Fortran
1418 users, including replacement by standard-conforming code or GNU
1419 extensions.
1421 @menu
1422 * Extensions implemented in GNU Fortran::
1423 * Extensions not implemented in GNU Fortran::
1424 @end menu
1427 @node Extensions implemented in GNU Fortran
1428 @section Extensions implemented in GNU Fortran
1429 @cindex extensions, implemented
1431 GNU Fortran implements a number of extensions over standard
1432 Fortran.  This chapter contains information on their syntax and
1433 meaning.  There are currently two categories of GNU Fortran
1434 extensions, those that provide functionality beyond that provided
1435 by any standard, and those that are supported by GNU Fortran
1436 purely for backward compatibility with legacy compilers.  By default,
1437 @option{-std=gnu} allows the compiler to accept both types of
1438 extensions, but to warn about the use of the latter.  Specifying
1439 either @option{-std=f95}, @option{-std=f2003} or @option{-std=f2008}
1440 disables both types of extensions, and @option{-std=legacy} allows both
1441 without warning.  The special compile flag @option{-fdec} enables additional
1442 compatibility extensions along with those enabled by @option{-std=legacy}.
1444 @menu
1445 * Old-style kind specifications::
1446 * Old-style variable initialization::
1447 * Extensions to namelist::
1448 * X format descriptor without count field::
1449 * Commas in FORMAT specifications::
1450 * Missing period in FORMAT specifications::
1451 * I/O item lists::
1452 * @code{Q} exponent-letter::
1453 * BOZ literal constants::
1454 * Real array indices::
1455 * Unary operators::
1456 * Implicitly convert LOGICAL and INTEGER values::
1457 * Hollerith constants support::
1458 * Cray pointers::
1459 * CONVERT specifier::
1460 * OpenMP::
1461 * OpenACC::
1462 * Argument list functions::
1463 * Read/Write after EOF marker::
1464 * STRUCTURE and RECORD::
1465 * UNION and MAP::
1466 * Type variants for integer intrinsics::
1467 * AUTOMATIC and STATIC attributes::
1468 * Extended math intrinsics::
1469 * Form feed as whitespace::
1470 * TYPE as an alias for PRINT::
1471 * %LOC as an rvalue::
1472 * .XOR. operator::
1473 * Bitwise logical operators::
1474 * Extended I/O specifiers::
1475 * Legacy PARAMETER statements::
1476 * Default exponents::
1477 @end menu
1479 @node Old-style kind specifications
1480 @subsection Old-style kind specifications
1481 @cindex kind, old-style
1483 GNU Fortran allows old-style kind specifications in declarations.  These
1484 look like:
1485 @smallexample
1486       TYPESPEC*size x,y,z
1487 @end smallexample
1488 @noindent
1489 where @code{TYPESPEC} is a basic type (@code{INTEGER}, @code{REAL},
1490 etc.), and where @code{size} is a byte count corresponding to the
1491 storage size of a valid kind for that type.  (For @code{COMPLEX}
1492 variables, @code{size} is the total size of the real and imaginary
1493 parts.)  The statement then declares @code{x}, @code{y} and @code{z} to
1494 be of type @code{TYPESPEC} with the appropriate kind.  This is
1495 equivalent to the standard-conforming declaration
1496 @smallexample
1497       TYPESPEC(k) x,y,z
1498 @end smallexample
1499 @noindent
1500 where @code{k} is the kind parameter suitable for the intended precision.  As
1501 kind parameters are implementation-dependent, use the @code{KIND},
1502 @code{SELECTED_INT_KIND} and @code{SELECTED_REAL_KIND} intrinsics to retrieve
1503 the correct value, for instance @code{REAL*8 x} can be replaced by:
1504 @smallexample
1505 INTEGER, PARAMETER :: dbl = KIND(1.0d0)
1506 REAL(KIND=dbl) :: x
1507 @end smallexample
1509 @node Old-style variable initialization
1510 @subsection Old-style variable initialization
1512 GNU Fortran allows old-style initialization of variables of the
1513 form:
1514 @smallexample
1515       INTEGER i/1/,j/2/
1516       REAL x(2,2) /3*0.,1./
1517 @end smallexample
1518 The syntax for the initializers is as for the @code{DATA} statement, but
1519 unlike in a @code{DATA} statement, an initializer only applies to the
1520 variable immediately preceding the initialization.  In other words,
1521 something like @code{INTEGER I,J/2,3/} is not valid.  This style of
1522 initialization is only allowed in declarations without double colons
1523 (@code{::}); the double colons were introduced in Fortran 90, which also
1524 introduced a standard syntax for initializing variables in type
1525 declarations.
1527 Examples of standard-conforming code equivalent to the above example
1528 are:
1529 @smallexample
1530 ! Fortran 90
1531       INTEGER :: i = 1, j = 2
1532       REAL :: x(2,2) = RESHAPE((/0.,0.,0.,1./),SHAPE(x))
1533 ! Fortran 77
1534       INTEGER i, j
1535       REAL x(2,2)
1536       DATA i/1/, j/2/, x/3*0.,1./
1537 @end smallexample
1539 Note that variables which are explicitly initialized in declarations
1540 or in @code{DATA} statements automatically acquire the @code{SAVE}
1541 attribute.
1543 @node Extensions to namelist
1544 @subsection Extensions to namelist
1545 @cindex Namelist
1547 GNU Fortran fully supports the Fortran 95 standard for namelist I/O
1548 including array qualifiers, substrings and fully qualified derived types.
1549 The output from a namelist write is compatible with namelist read.  The
1550 output has all names in upper case and indentation to column 1 after the
1551 namelist name.  Two extensions are permitted:
1553 Old-style use of @samp{$} instead of @samp{&}
1554 @smallexample
1555 $MYNML
1556  X(:)%Y(2) = 1.0 2.0 3.0
1557  CH(1:4) = "abcd"
1558 $END
1559 @end smallexample
1561 It should be noted that the default terminator is @samp{/} rather than
1562 @samp{&END}.
1564 Querying of the namelist when inputting from stdin.  After at least
1565 one space, entering @samp{?} sends to stdout the namelist name and the names of
1566 the variables in the namelist:
1567 @smallexample
1570 &mynml
1572  x%y
1573  ch
1574 &end
1575 @end smallexample
1577 Entering @samp{=?} outputs the namelist to stdout, as if
1578 @code{WRITE(*,NML = mynml)} had been called:
1579 @smallexample
1582 &MYNML
1583  X(1)%Y=  0.000000    ,  1.000000    ,  0.000000    ,
1584  X(2)%Y=  0.000000    ,  2.000000    ,  0.000000    ,
1585  X(3)%Y=  0.000000    ,  3.000000    ,  0.000000    ,
1586  CH=abcd,  /
1587 @end smallexample
1589 To aid this dialog, when input is from stdin, errors send their
1590 messages to stderr and execution continues, even if @code{IOSTAT} is set.
1592 @code{PRINT} namelist is permitted.  This causes an error if
1593 @option{-std=f95} is used.
1594 @smallexample
1595 PROGRAM test_print
1596   REAL, dimension (4)  ::  x = (/1.0, 2.0, 3.0, 4.0/)
1597   NAMELIST /mynml/ x
1598   PRINT mynml
1599 END PROGRAM test_print
1600 @end smallexample
1602 Expanded namelist reads are permitted.  This causes an error if 
1603 @option{-std=f95} is used.  In the following example, the first element
1604 of the array will be given the value 0.00 and the two succeeding
1605 elements will be given the values 1.00 and 2.00.
1606 @smallexample
1607 &MYNML
1608   X(1,1) = 0.00 , 1.00 , 2.00
1610 @end smallexample
1612 When writing a namelist, if no @code{DELIM=} is specified, by default a
1613 double quote is used to delimit character strings. If -std=F95, F2003,
1614 or F2008, etc, the delim status is set to 'none'.  Defaulting to
1615 quotes ensures that namelists with character strings can be subsequently
1616 read back in accurately.
1618 @node X format descriptor without count field
1619 @subsection @code{X} format descriptor without count field
1621 To support legacy codes, GNU Fortran permits the count field of the
1622 @code{X} edit descriptor in @code{FORMAT} statements to be omitted.
1623 When omitted, the count is implicitly assumed to be one.
1625 @smallexample
1626        PRINT 10, 2, 3
1627 10     FORMAT (I1, X, I1)
1628 @end smallexample
1630 @node Commas in FORMAT specifications
1631 @subsection Commas in @code{FORMAT} specifications
1633 To support legacy codes, GNU Fortran allows the comma separator
1634 to be omitted immediately before and after character string edit
1635 descriptors in @code{FORMAT} statements.
1637 @smallexample
1638        PRINT 10, 2, 3
1639 10     FORMAT ('FOO='I1' BAR='I2)
1640 @end smallexample
1643 @node Missing period in FORMAT specifications
1644 @subsection Missing period in @code{FORMAT} specifications
1646 To support legacy codes, GNU Fortran allows missing periods in format
1647 specifications if and only if @option{-std=legacy} is given on the
1648 command line.  This is considered non-conforming code and is
1649 discouraged.
1651 @smallexample
1652        REAL :: value
1653        READ(*,10) value
1654 10     FORMAT ('F4')
1655 @end smallexample
1657 @node I/O item lists
1658 @subsection I/O item lists
1659 @cindex I/O item lists
1661 To support legacy codes, GNU Fortran allows the input item list
1662 of the @code{READ} statement, and the output item lists of the
1663 @code{WRITE} and @code{PRINT} statements, to start with a comma.
1665 @node @code{Q} exponent-letter
1666 @subsection @code{Q} exponent-letter
1667 @cindex @code{Q} exponent-letter
1669 GNU Fortran accepts real literal constants with an exponent-letter
1670 of @code{Q}, for example, @code{1.23Q45}.  The constant is interpreted
1671 as a @code{REAL(16)} entity on targets that support this type.  If
1672 the target does not support @code{REAL(16)} but has a @code{REAL(10)}
1673 type, then the real-literal-constant will be interpreted as a
1674 @code{REAL(10)} entity.  In the absence of @code{REAL(16)} and
1675 @code{REAL(10)}, an error will occur.
1677 @node BOZ literal constants
1678 @subsection BOZ literal constants
1679 @cindex BOZ literal constants
1681 Besides decimal constants, Fortran also supports binary (@code{b}),
1682 octal (@code{o}) and hexadecimal (@code{z}) integer constants.  The
1683 syntax is: @samp{prefix quote digits quote}, were the prefix is
1684 either @code{b}, @code{o} or @code{z}, quote is either @code{'} or
1685 @code{"} and the digits are for binary @code{0} or @code{1}, for
1686 octal between @code{0} and @code{7}, and for hexadecimal between
1687 @code{0} and @code{F}.  (Example: @code{b'01011101'}.)
1689 Up to Fortran 95, BOZ literals were only allowed to initialize
1690 integer variables in DATA statements.  Since Fortran 2003 BOZ literals
1691 are also allowed as argument of @code{REAL}, @code{DBLE}, @code{INT}
1692 and @code{CMPLX}; the result is the same as if the integer BOZ
1693 literal had been converted by @code{TRANSFER} to, respectively,
1694 @code{real}, @code{double precision}, @code{integer} or @code{complex}.
1695 As GNU Fortran extension the intrinsic procedures @code{FLOAT},
1696 @code{DFLOAT}, @code{COMPLEX} and @code{DCMPLX} are treated alike.
1698 As an extension, GNU Fortran allows hexadecimal BOZ literal constants to
1699 be specified using the @code{X} prefix, in addition to the standard
1700 @code{Z} prefix.  The BOZ literal can also be specified by adding a
1701 suffix to the string, for example, @code{Z'ABC'} and @code{'ABC'Z} are
1702 equivalent.
1704 Furthermore, GNU Fortran allows using BOZ literal constants outside
1705 DATA statements and the four intrinsic functions allowed by Fortran 2003.
1706 In DATA statements, in direct assignments, where the right-hand side
1707 only contains a BOZ literal constant, and for old-style initializers of
1708 the form @code{integer i /o'0173'/}, the constant is transferred
1709 as if @code{TRANSFER} had been used; for @code{COMPLEX} numbers, only
1710 the real part is initialized unless @code{CMPLX} is used.  In all other
1711 cases, the BOZ literal constant is converted to an @code{INTEGER} value with
1712 the largest decimal representation.  This value is then converted
1713 numerically to the type and kind of the variable in question.
1714 (For instance, @code{real :: r = b'0000001' + 1} initializes @code{r}
1715 with @code{2.0}.) As different compilers implement the extension
1716 differently, one should be careful when doing bitwise initialization
1717 of non-integer variables.
1719 Note that initializing an @code{INTEGER} variable with a statement such
1720 as @code{DATA i/Z'FFFFFFFF'/} will give an integer overflow error rather
1721 than the desired result of @math{-1} when @code{i} is a 32-bit integer
1722 on a system that supports 64-bit integers.  The @samp{-fno-range-check}
1723 option can be used as a workaround for legacy code that initializes
1724 integers in this manner.
1726 @node Real array indices
1727 @subsection Real array indices
1728 @cindex array, indices of type real
1730 As an extension, GNU Fortran allows the use of @code{REAL} expressions
1731 or variables as array indices.
1733 @node Unary operators
1734 @subsection Unary operators
1735 @cindex operators, unary
1737 As an extension, GNU Fortran allows unary plus and unary minus operators
1738 to appear as the second operand of binary arithmetic operators without
1739 the need for parenthesis.
1741 @smallexample
1742        X = Y * -Z
1743 @end smallexample
1745 @node Implicitly convert LOGICAL and INTEGER values
1746 @subsection Implicitly convert @code{LOGICAL} and @code{INTEGER} values
1747 @cindex conversion, to integer
1748 @cindex conversion, to logical
1750 As an extension for backwards compatibility with other compilers, GNU
1751 Fortran allows the implicit conversion of @code{LOGICAL} values to
1752 @code{INTEGER} values and vice versa.  When converting from a
1753 @code{LOGICAL} to an @code{INTEGER}, @code{.FALSE.} is interpreted as
1754 zero, and @code{.TRUE.} is interpreted as one.  When converting from
1755 @code{INTEGER} to @code{LOGICAL}, the value zero is interpreted as
1756 @code{.FALSE.} and any nonzero value is interpreted as @code{.TRUE.}.
1758 @smallexample
1759         LOGICAL :: l
1760         l = 1
1761 @end smallexample
1762 @smallexample
1763         INTEGER :: i
1764         i = .TRUE.
1765 @end smallexample
1767 However, there is no implicit conversion of @code{INTEGER} values in
1768 @code{if}-statements, nor of @code{LOGICAL} or @code{INTEGER} values
1769 in I/O operations.
1771 @node Hollerith constants support
1772 @subsection Hollerith constants support
1773 @cindex Hollerith constants
1775 GNU Fortran supports Hollerith constants in assignments, function
1776 arguments, and @code{DATA} and @code{ASSIGN} statements.  A Hollerith
1777 constant is written as a string of characters preceded by an integer
1778 constant indicating the character count, and the letter @code{H} or
1779 @code{h}, and stored in bytewise fashion in a numeric (@code{INTEGER},
1780 @code{REAL}, or @code{complex}) or @code{LOGICAL} variable.  The
1781 constant will be padded or truncated to fit the size of the variable in
1782 which it is stored.
1784 Examples of valid uses of Hollerith constants:
1785 @smallexample
1786       complex*16 x(2)
1787       data x /16Habcdefghijklmnop, 16Hqrstuvwxyz012345/
1788       x(1) = 16HABCDEFGHIJKLMNOP
1789       call foo (4h abc)
1790 @end smallexample
1792 Invalid Hollerith constants examples:
1793 @smallexample
1794       integer*4 a
1795       a = 8H12345678 ! Valid, but the Hollerith constant will be truncated.
1796       a = 0H         ! At least one character is needed.
1797 @end smallexample
1799 In general, Hollerith constants were used to provide a rudimentary
1800 facility for handling character strings in early Fortran compilers,
1801 prior to the introduction of @code{CHARACTER} variables in Fortran 77;
1802 in those cases, the standard-compliant equivalent is to convert the
1803 program to use proper character strings.  On occasion, there may be a
1804 case where the intent is specifically to initialize a numeric variable
1805 with a given byte sequence.  In these cases, the same result can be
1806 obtained by using the @code{TRANSFER} statement, as in this example.
1807 @smallexample
1808       INTEGER(KIND=4) :: a
1809       a = TRANSFER ("abcd", a)     ! equivalent to: a = 4Habcd
1810 @end smallexample
1813 @node Cray pointers
1814 @subsection Cray pointers
1815 @cindex pointer, Cray
1817 Cray pointers are part of a non-standard extension that provides a
1818 C-like pointer in Fortran.  This is accomplished through a pair of
1819 variables: an integer "pointer" that holds a memory address, and a
1820 "pointee" that is used to dereference the pointer.
1822 Pointer/pointee pairs are declared in statements of the form:
1823 @smallexample
1824         pointer ( <pointer> , <pointee> )
1825 @end smallexample
1827 @smallexample
1828         pointer ( <pointer1> , <pointee1> ), ( <pointer2> , <pointee2> ), ...
1829 @end smallexample
1830 The pointer is an integer that is intended to hold a memory address.
1831 The pointee may be an array or scalar.  A pointee can be an assumed
1832 size array---that is, the last dimension may be left unspecified by
1833 using a @code{*} in place of a value---but a pointee cannot be an
1834 assumed shape array.  No space is allocated for the pointee.
1836 The pointee may have its type declared before or after the pointer
1837 statement, and its array specification (if any) may be declared
1838 before, during, or after the pointer statement.  The pointer may be
1839 declared as an integer prior to the pointer statement.  However, some
1840 machines have default integer sizes that are different than the size
1841 of a pointer, and so the following code is not portable:
1842 @smallexample
1843         integer ipt
1844         pointer (ipt, iarr)
1845 @end smallexample
1846 If a pointer is declared with a kind that is too small, the compiler
1847 will issue a warning; the resulting binary will probably not work
1848 correctly, because the memory addresses stored in the pointers may be
1849 truncated.  It is safer to omit the first line of the above example;
1850 if explicit declaration of ipt's type is omitted, then the compiler
1851 will ensure that ipt is an integer variable large enough to hold a
1852 pointer.
1854 Pointer arithmetic is valid with Cray pointers, but it is not the same
1855 as C pointer arithmetic.  Cray pointers are just ordinary integers, so
1856 the user is responsible for determining how many bytes to add to a
1857 pointer in order to increment it.  Consider the following example:
1858 @smallexample
1859         real target(10)
1860         real pointee(10)
1861         pointer (ipt, pointee)
1862         ipt = loc (target)
1863         ipt = ipt + 1       
1864 @end smallexample
1865 The last statement does not set @code{ipt} to the address of
1866 @code{target(1)}, as it would in C pointer arithmetic.  Adding @code{1}
1867 to @code{ipt} just adds one byte to the address stored in @code{ipt}.
1869 Any expression involving the pointee will be translated to use the
1870 value stored in the pointer as the base address.
1872 To get the address of elements, this extension provides an intrinsic
1873 function @code{LOC()}.  The @code{LOC()} function is equivalent to the
1874 @code{&} operator in C, except the address is cast to an integer type:
1875 @smallexample
1876         real ar(10)
1877         pointer(ipt, arpte(10))
1878         real arpte
1879         ipt = loc(ar)  ! Makes arpte is an alias for ar
1880         arpte(1) = 1.0 ! Sets ar(1) to 1.0
1881 @end smallexample
1882 The pointer can also be set by a call to the @code{MALLOC} intrinsic
1883 (see @ref{MALLOC}).
1885 Cray pointees often are used to alias an existing variable.  For
1886 example:
1887 @smallexample
1888         integer target(10)
1889         integer iarr(10)
1890         pointer (ipt, iarr)
1891         ipt = loc(target)
1892 @end smallexample
1893 As long as @code{ipt} remains unchanged, @code{iarr} is now an alias for
1894 @code{target}.  The optimizer, however, will not detect this aliasing, so
1895 it is unsafe to use @code{iarr} and @code{target} simultaneously.  Using
1896 a pointee in any way that violates the Fortran aliasing rules or
1897 assumptions is illegal.  It is the user's responsibility to avoid doing
1898 this; the compiler works under the assumption that no such aliasing
1899 occurs.
1901 Cray pointers will work correctly when there is no aliasing (i.e., when
1902 they are used to access a dynamically allocated block of memory), and
1903 also in any routine where a pointee is used, but any variable with which
1904 it shares storage is not used.  Code that violates these rules may not
1905 run as the user intends.  This is not a bug in the optimizer; any code
1906 that violates the aliasing rules is illegal.  (Note that this is not
1907 unique to GNU Fortran; any Fortran compiler that supports Cray pointers
1908 will ``incorrectly'' optimize code with illegal aliasing.)
1910 There are a number of restrictions on the attributes that can be applied
1911 to Cray pointers and pointees.  Pointees may not have the
1912 @code{ALLOCATABLE}, @code{INTENT}, @code{OPTIONAL}, @code{DUMMY},
1913 @code{TARGET}, @code{INTRINSIC}, or @code{POINTER} attributes.  Pointers
1914 may not have the @code{DIMENSION}, @code{POINTER}, @code{TARGET},
1915 @code{ALLOCATABLE}, @code{EXTERNAL}, or @code{INTRINSIC} attributes, nor
1916 may they be function results.  Pointees may not occur in more than one
1917 pointer statement.  A pointee cannot be a pointer.  Pointees cannot occur
1918 in equivalence, common, or data statements.
1920 A Cray pointer may also point to a function or a subroutine.  For
1921 example, the following excerpt is valid:
1922 @smallexample
1923   implicit none
1924   external sub
1925   pointer (subptr,subpte)
1926   external subpte
1927   subptr = loc(sub)
1928   call subpte()
1929   [...]
1930   subroutine sub
1931   [...]
1932   end subroutine sub
1933 @end smallexample
1935 A pointer may be modified during the course of a program, and this
1936 will change the location to which the pointee refers.  However, when
1937 pointees are passed as arguments, they are treated as ordinary
1938 variables in the invoked function.  Subsequent changes to the pointer
1939 will not change the base address of the array that was passed.
1941 @node CONVERT specifier
1942 @subsection @code{CONVERT} specifier
1943 @cindex @code{CONVERT} specifier
1945 GNU Fortran allows the conversion of unformatted data between little-
1946 and big-endian representation to facilitate moving of data
1947 between different systems.  The conversion can be indicated with
1948 the @code{CONVERT} specifier on the @code{OPEN} statement.
1949 @xref{GFORTRAN_CONVERT_UNIT}, for an alternative way of specifying
1950 the data format via an environment variable.
1952 Valid values for @code{CONVERT} are:
1953 @itemize @w{}
1954 @item @code{CONVERT='NATIVE'} Use the native format.  This is the default.
1955 @item @code{CONVERT='SWAP'} Swap between little- and big-endian.
1956 @item @code{CONVERT='LITTLE_ENDIAN'} Use the little-endian representation
1957 for unformatted files.
1958 @item @code{CONVERT='BIG_ENDIAN'} Use the big-endian representation for
1959 unformatted files.
1960 @end itemize
1962 Using the option could look like this:
1963 @smallexample
1964   open(file='big.dat',form='unformatted',access='sequential', &
1965        convert='big_endian')
1966 @end smallexample
1968 The value of the conversion can be queried by using
1969 @code{INQUIRE(CONVERT=ch)}.  The values returned are
1970 @code{'BIG_ENDIAN'} and @code{'LITTLE_ENDIAN'}.
1972 @code{CONVERT} works between big- and little-endian for
1973 @code{INTEGER} values of all supported kinds and for @code{REAL}
1974 on IEEE systems of kinds 4 and 8.  Conversion between different
1975 ``extended double'' types on different architectures such as
1976 m68k and x86_64, which GNU Fortran
1977 supports as @code{REAL(KIND=10)} and @code{REAL(KIND=16)}, will
1978 probably not work.
1980 @emph{Note that the values specified via the GFORTRAN_CONVERT_UNIT
1981 environment variable will override the CONVERT specifier in the
1982 open statement}.  This is to give control over data formats to
1983 users who do not have the source code of their program available.
1985 Using anything but the native representation for unformatted data
1986 carries a significant speed overhead.  If speed in this area matters
1987 to you, it is best if you use this only for data that needs to be
1988 portable.
1990 @node OpenMP
1991 @subsection OpenMP
1992 @cindex OpenMP
1994 OpenMP (Open Multi-Processing) is an application programming
1995 interface (API) that supports multi-platform shared memory 
1996 multiprocessing programming in C/C++ and Fortran on many 
1997 architectures, including Unix and Microsoft Windows platforms.
1998 It consists of a set of compiler directives, library routines,
1999 and environment variables that influence run-time behavior.
2001 GNU Fortran strives to be compatible to the 
2002 @uref{http://openmp.org/wp/openmp-specifications/,
2003 OpenMP Application Program Interface v4.5}.
2005 To enable the processing of the OpenMP directive @code{!$omp} in
2006 free-form source code; the @code{c$omp}, @code{*$omp} and @code{!$omp}
2007 directives in fixed form; the @code{!$} conditional compilation sentinels
2008 in free form; and the @code{c$}, @code{*$} and @code{!$} sentinels
2009 in fixed form, @command{gfortran} needs to be invoked with the
2010 @option{-fopenmp}.  This also arranges for automatic linking of the
2011 GNU Offloading and Multi Processing Runtime Library
2012 @ref{Top,,libgomp,libgomp,GNU Offloading and Multi Processing Runtime
2013 Library}.
2015 The OpenMP Fortran runtime library routines are provided both in a
2016 form of a Fortran 90 module named @code{omp_lib} and in a form of
2017 a Fortran @code{include} file named @file{omp_lib.h}.
2019 An example of a parallelized loop taken from Appendix A.1 of
2020 the OpenMP Application Program Interface v2.5:
2021 @smallexample
2022 SUBROUTINE A1(N, A, B)
2023   INTEGER I, N
2024   REAL B(N), A(N)
2025 !$OMP PARALLEL DO !I is private by default
2026   DO I=2,N
2027     B(I) = (A(I) + A(I-1)) / 2.0
2028   ENDDO
2029 !$OMP END PARALLEL DO
2030 END SUBROUTINE A1
2031 @end smallexample
2033 Please note:
2034 @itemize
2035 @item
2036 @option{-fopenmp} implies @option{-frecursive}, i.e., all local arrays
2037 will be allocated on the stack.  When porting existing code to OpenMP,
2038 this may lead to surprising results, especially to segmentation faults
2039 if the stacksize is limited.
2041 @item
2042 On glibc-based systems, OpenMP enabled applications cannot be statically
2043 linked due to limitations of the underlying pthreads-implementation.  It
2044 might be possible to get a working solution if 
2045 @command{-Wl,--whole-archive -lpthread -Wl,--no-whole-archive} is added
2046 to the command line.  However, this is not supported by @command{gcc} and
2047 thus not recommended.
2048 @end itemize
2050 @node OpenACC
2051 @subsection OpenACC
2052 @cindex OpenACC
2054 OpenACC is an application programming interface (API) that supports
2055 offloading of code to accelerator devices.  It consists of a set of
2056 compiler directives, library routines, and environment variables that
2057 influence run-time behavior.
2059 GNU Fortran strives to be compatible to the
2060 @uref{http://www.openacc.org/, OpenACC Application Programming
2061 Interface v2.0}.
2063 To enable the processing of the OpenACC directive @code{!$acc} in
2064 free-form source code; the @code{c$acc}, @code{*$acc} and @code{!$acc}
2065 directives in fixed form; the @code{!$} conditional compilation
2066 sentinels in free form; and the @code{c$}, @code{*$} and @code{!$}
2067 sentinels in fixed form, @command{gfortran} needs to be invoked with
2068 the @option{-fopenacc}.  This also arranges for automatic linking of
2069 the GNU Offloading and Multi Processing Runtime Library
2070 @ref{Top,,libgomp,libgomp,GNU Offloading and Multi Processing Runtime
2071 Library}.
2073 The OpenACC Fortran runtime library routines are provided both in a
2074 form of a Fortran 90 module named @code{openacc} and in a form of a
2075 Fortran @code{include} file named @file{openacc_lib.h}.
2077 Note that this is an experimental feature, incomplete, and subject to
2078 change in future versions of GCC.  See
2079 @uref{https://gcc.gnu.org/wiki/OpenACC} for more information.
2081 @node Argument list functions
2082 @subsection Argument list functions @code{%VAL}, @code{%REF} and @code{%LOC}
2083 @cindex argument list functions
2084 @cindex @code{%VAL}
2085 @cindex @code{%REF}
2086 @cindex @code{%LOC}
2088 GNU Fortran supports argument list functions @code{%VAL}, @code{%REF} 
2089 and @code{%LOC} statements, for backward compatibility with g77. 
2090 It is recommended that these should be used only for code that is 
2091 accessing facilities outside of GNU Fortran, such as operating system 
2092 or windowing facilities.  It is best to constrain such uses to isolated 
2093 portions of a program--portions that deal specifically and exclusively 
2094 with low-level, system-dependent facilities.  Such portions might well 
2095 provide a portable interface for use by the program as a whole, but are 
2096 themselves not portable, and should be thoroughly tested each time they 
2097 are rebuilt using a new compiler or version of a compiler.
2099 @code{%VAL} passes a scalar argument by value, @code{%REF} passes it by 
2100 reference and @code{%LOC} passes its memory location.  Since gfortran 
2101 already passes scalar arguments by reference, @code{%REF} is in effect 
2102 a do-nothing.  @code{%LOC} has the same effect as a Fortran pointer.
2104 An example of passing an argument by value to a C subroutine foo.:
2105 @smallexample
2107 C prototype      void foo_ (float x);
2109       external foo
2110       real*4 x
2111       x = 3.14159
2112       call foo (%VAL (x))
2113       end
2114 @end smallexample
2116 For details refer to the g77 manual
2117 @uref{https://gcc.gnu.org/@/onlinedocs/@/gcc-3.4.6/@/g77/@/index.html#Top}.
2119 Also, @code{c_by_val.f} and its partner @code{c_by_val.c} of the
2120 GNU Fortran testsuite are worth a look.
2122 @node Read/Write after EOF marker
2123 @subsection Read/Write after EOF marker
2124 @cindex @code{EOF}
2125 @cindex @code{BACKSPACE}
2126 @cindex @code{REWIND}
2128 Some legacy codes rely on allowing @code{READ} or @code{WRITE} after the
2129 EOF file marker in order to find the end of a file. GNU Fortran normally
2130 rejects these codes with a run-time error message and suggests the user
2131 consider @code{BACKSPACE} or @code{REWIND} to properly position
2132 the file before the EOF marker.  As an extension, the run-time error may
2133 be disabled using -std=legacy.
2136 @node STRUCTURE and RECORD
2137 @subsection @code{STRUCTURE} and @code{RECORD}
2138 @cindex @code{STRUCTURE}
2139 @cindex @code{RECORD}
2141 Record structures are a pre-Fortran-90 vendor extension to create
2142 user-defined aggregate data types.  Support for record structures in GNU
2143 Fortran can be enabled with the @option{-fdec-structure} compile flag.
2144 If you have a choice, you should instead use Fortran 90's ``derived types'',
2145 which have a different syntax.
2147 In many cases, record structures can easily be converted to derived types.
2148 To convert, replace @code{STRUCTURE /}@var{structure-name}@code{/}
2149 by @code{TYPE} @var{type-name}.  Additionally, replace
2150 @code{RECORD /}@var{structure-name}@code{/} by
2151 @code{TYPE(}@var{type-name}@code{)}. Finally, in the component access,
2152 replace the period (@code{.}) by the percent sign (@code{%}).
2154 Here is an example of code using the non portable record structure syntax:
2156 @example
2157 ! Declaring a structure named ``item'' and containing three fields:
2158 ! an integer ID, an description string and a floating-point price.
2159 STRUCTURE /item/
2160   INTEGER id
2161   CHARACTER(LEN=200) description
2162   REAL price
2163 END STRUCTURE
2165 ! Define two variables, an single record of type ``item''
2166 ! named ``pear'', and an array of items named ``store_catalog''
2167 RECORD /item/ pear, store_catalog(100)
2169 ! We can directly access the fields of both variables
2170 pear.id = 92316
2171 pear.description = "juicy D'Anjou pear"
2172 pear.price = 0.15
2173 store_catalog(7).id = 7831
2174 store_catalog(7).description = "milk bottle"
2175 store_catalog(7).price = 1.2
2177 ! We can also manipulate the whole structure
2178 store_catalog(12) = pear
2179 print *, store_catalog(12)
2180 @end example
2182 @noindent
2183 This code can easily be rewritten in the Fortran 90 syntax as following:
2185 @example
2186 ! ``STRUCTURE /name/ ... END STRUCTURE'' becomes
2187 ! ``TYPE name ... END TYPE''
2188 TYPE item
2189   INTEGER id
2190   CHARACTER(LEN=200) description
2191   REAL price
2192 END TYPE
2194 ! ``RECORD /name/ variable'' becomes ``TYPE(name) variable''
2195 TYPE(item) pear, store_catalog(100)
2197 ! Instead of using a dot (.) to access fields of a record, the
2198 ! standard syntax uses a percent sign (%)
2199 pear%id = 92316
2200 pear%description = "juicy D'Anjou pear"
2201 pear%price = 0.15
2202 store_catalog(7)%id = 7831
2203 store_catalog(7)%description = "milk bottle"
2204 store_catalog(7)%price = 1.2
2206 ! Assignments of a whole variable do not change
2207 store_catalog(12) = pear
2208 print *, store_catalog(12)
2209 @end example
2211 @noindent
2212 GNU Fortran implements STRUCTURES like derived types with the following
2213 rules and exceptions:
2215 @itemize @bullet
2216 @item Structures act like derived types with the @code{SEQUENCE} attribute.
2217 Otherwise they may contain no specifiers.
2219 @item Structures may share names with other symbols. For example, the following
2220 is invalid for derived types, but valid for structures:
2222 @smallexample
2223 structure /header/
2224   ! ...
2225 end structure
2226 record /header/ header
2227 @end smallexample
2229 @item Structure types may be declared nested within another parent structure.
2230 The syntax is:
2231 @smallexample
2232 structure /type-name/
2233     ...
2234     structure [/<type-name>/] <field-list>
2236 @end smallexample
2238 The type name may be ommitted, in which case the structure type itself is
2239 anonymous, and other structures of the same type cannot be instantiated. The
2240 following shows some examples:
2242 @example
2243 structure /appointment/
2244   ! nested structure definition: app_time is an array of two 'time'
2245   structure /time/ app_time (2) 
2246     integer(1) hour, minute
2247   end structure
2248   character(10) memo
2249 end structure
2251 ! The 'time' structure is still usable
2252 record /time/ now
2253 now = time(5, 30)
2257 structure /appointment/
2258   ! anonymous nested structure definition
2259   structure start, end
2260     integer(1) hour, minute
2261   end structure
2262   character(10) memo
2263 end structure
2264 @end example
2266 @item Structures may contain @code{UNION} blocks. For more detail see the
2267 section on @ref{UNION and MAP}.
2269 @item Structures support old-style initialization of components, like
2270 those described in @ref{Old-style variable initialization}. For array
2271 initializers, an initializer may contain a repeat specification of the form
2272 @code{<literal-integer> * <constant-initializer>}. The value of the integer
2273 indicates the number of times to repeat the constant initializer when expanding
2274 the initializer list.
2275 @end itemize
2277 @node UNION and MAP
2278 @subsection @code{UNION} and @code{MAP}
2279 @cindex @code{UNION}
2280 @cindex @code{MAP}
2282 Unions are an old vendor extension which were commonly used with the
2283 non-standard @ref{STRUCTURE and RECORD} extensions. Use of @code{UNION} and
2284 @code{MAP} is automatically enabled with @option{-fdec-structure}.
2286 A @code{UNION} declaration occurs within a structure; within the definition of
2287 each union is a number of @code{MAP} blocks. Each @code{MAP} shares storage
2288 with its sibling maps (in the same union), and the size of the union is the
2289 size of the largest map within it, just as with unions in C. The major
2290 difference is that component references do not indicate which union or map the
2291 component is in (the compiler gets to figure that out).
2293 Here is a small example:
2294 @smallexample
2295 structure /myunion/
2296 union
2297   map
2298     character(2) w0, w1, w2
2299   end map
2300   map
2301     character(6) long
2302   end map
2303 end union
2304 end structure
2306 record /myunion/ rec
2307 ! After this assignment...
2308 rec.long = 'hello!'
2310 ! The following is true:
2311 ! rec.w0 === 'he'
2312 ! rec.w1 === 'll'
2313 ! rec.w2 === 'o!'
2314 @end smallexample
2316 The two maps share memory, and the size of the union is ultimately six bytes:
2318 @example
2319 0    1    2    3    4   5   6     Byte offset
2320 -------------------------------
2321 |    |    |    |    |    |    |
2322 -------------------------------
2324 ^    W0   ^    W1   ^    W2   ^
2325  \-------/ \-------/ \-------/
2327 ^             LONG            ^
2328  \---------------------------/
2329 @end example
2331 Following is an example mirroring the layout of an Intel x86_64 register:
2333 @example
2334 structure /reg/
2335   union ! U0                ! rax
2336     map
2337       character(16) rx
2338     end map
2339     map
2340       character(8) rh         ! rah
2341       union ! U1
2342         map
2343           character(8) rl     ! ral
2344         end map
2345         map
2346           character(8) ex     ! eax
2347         end map
2348         map
2349           character(4) eh     ! eah
2350           union ! U2
2351             map
2352               character(4) el ! eal
2353             end map
2354             map
2355               character(4) x  ! ax
2356             end map
2357             map
2358               character(2) h  ! ah
2359               character(2) l  ! al
2360             end map
2361           end union
2362         end map
2363       end union
2364     end map
2365   end union
2366 end structure
2367 record /reg/ a
2369 ! After this assignment...
2370 a.rx     =     'AAAAAAAA.BBB.C.D'
2372 ! The following is true:
2373 a.rx === 'AAAAAAAA.BBB.C.D'
2374 a.rh === 'AAAAAAAA'
2375 a.rl ===         '.BBB.C.D'
2376 a.ex ===         '.BBB.C.D'
2377 a.eh ===         '.BBB'
2378 a.el ===             '.C.D'
2379 a.x  ===             '.C.D'
2380 a.h  ===             '.C'
2381 a.l  ===               '.D'
2382 @end example
2384 @node Type variants for integer intrinsics
2385 @subsection Type variants for integer intrinsics
2386 @cindex intrinsics, integer
2388 Similar to the D/C prefixes to real functions to specify the input/output
2389 types, GNU Fortran offers B/I/J/K prefixes to integer functions for
2390 compatibility with DEC programs. The types implied by each are:
2392 @example
2393 @code{B} - @code{INTEGER(kind=1)}
2394 @code{I} - @code{INTEGER(kind=2)}
2395 @code{J} - @code{INTEGER(kind=4)}
2396 @code{K} - @code{INTEGER(kind=8)}
2397 @end example
2399 GNU Fortran supports these with the flag @option{-fdec-intrinsic-ints}.
2400 Intrinsics for which prefixed versions are available and in what form are noted
2401 in @ref{Intrinsic Procedures}. The complete list of supported intrinsics is
2402 here:
2404 @multitable @columnfractions .2 .2 .2 .2 .2
2406 @headitem Intrinsic @tab B @tab I @tab J @tab K
2408 @item @code{@ref{ABS}}
2409   @tab @code{BABS} @tab @code{IIABS} @tab @code{JIABS} @tab @code{KIABS}
2410 @item @code{@ref{BTEST}}
2411   @tab @code{BBTEST} @tab @code{BITEST} @tab @code{BJTEST} @tab @code{BKTEST}
2412 @item @code{@ref{IAND}}
2413   @tab @code{BIAND} @tab @code{IIAND} @tab @code{JIAND} @tab @code{KIAND}
2414 @item @code{@ref{IBCLR}}
2415   @tab @code{BBCLR} @tab @code{IIBCLR} @tab @code{JIBCLR} @tab @code{KIBCLR}
2416 @item @code{@ref{IBITS}}
2417   @tab @code{BBITS} @tab @code{IIBITS} @tab @code{JIBITS} @tab @code{KIBITS}
2418 @item @code{@ref{IBSET}}
2419   @tab @code{BBSET} @tab @code{IIBSET} @tab @code{JIBSET} @tab @code{KIBSET}
2420 @item @code{@ref{IEOR}}
2421   @tab @code{BIEOR} @tab @code{IIEOR} @tab @code{JIEOR} @tab @code{KIEOR}
2422 @item @code{@ref{IOR}}
2423   @tab @code{BIOR} @tab @code{IIOR} @tab @code{JIOR} @tab @code{KIOR}
2424 @item @code{@ref{ISHFT}}
2425   @tab @code{BSHFT} @tab @code{IISHFT} @tab @code{JISHFT} @tab @code{KISHFT}
2426 @item @code{@ref{ISHFTC}}
2427   @tab @code{BSHFTC} @tab @code{IISHFTC} @tab @code{JISHFTC} @tab @code{KISHFTC}
2428 @item @code{@ref{MOD}}
2429   @tab @code{BMOD} @tab @code{IMOD} @tab @code{JMOD} @tab @code{KMOD}
2430 @item @code{@ref{NOT}}
2431   @tab @code{BNOT} @tab @code{INOT} @tab @code{JNOT} @tab @code{KNOT}
2432 @item @code{@ref{REAL}}
2433   @tab @code{--} @tab @code{FLOATI} @tab @code{FLOATJ} @tab @code{FLOATK}
2434 @end multitable
2436 @node AUTOMATIC and STATIC attributes
2437 @subsection @code{AUTOMATIC} and @code{STATIC} attributes
2438 @cindex variable attributes
2439 @cindex @code{AUTOMATIC}
2440 @cindex @code{STATIC}
2442 With @option{-fdec-static} GNU Fortran supports the DEC extended attributes
2443 @code{STATIC} and @code{AUTOMATIC} to provide explicit specification of entity
2444 storage.  These follow the syntax of the Fortran standard @code{SAVE} attribute.
2446 @code{STATIC} is exactly equivalent to @code{SAVE}, and specifies that
2447 an entity should be allocated in static memory.  As an example, @code{STATIC}
2448 local variables will retain their values across multiple calls to a function.
2450 Entities marked @code{AUTOMATIC} will be stack automatic whenever possible.
2451 @code{AUTOMATIC} is the default for local variables smaller than
2452 @option{-fmax-stack-var-size}, unless @option{-fno-automatic} is given.  This
2453 attribute overrides @option{-fno-automatic}, @option{-fmax-stack-var-size}, and
2454 blanket @code{SAVE} statements.
2457 Examples:
2459 @example
2460 subroutine f
2461   integer, automatic :: i  ! automatic variable
2462   integer x, y             ! static variables
2463   save
2464   ...
2465 endsubroutine
2466 @end example
2467 @example
2468 subroutine f
2469   integer a, b, c, x, y, z
2470   static :: x
2471   save y
2472   automatic z, c
2473   ! a, b, c, and z are automatic
2474   ! x and y are static
2475 endsubroutine
2476 @end example
2477 @example
2478 ! Compiled with -fno-automatic
2479 subroutine f
2480   integer a, b, c, d
2481   automatic :: a
2482   ! a is automatic; b, c, and d are static
2483 endsubroutine
2484 @end example
2486 @node Extended math intrinsics
2487 @subsection Extended math intrinsics
2488 @cindex intrinsics, math
2489 @cindex intrinsics, trigonometric functions
2491 GNU Fortran supports an extended list of mathematical intrinsics with the
2492 compile flag @option{-fdec-math} for compatability with legacy code.
2493 These intrinsics are described fully in @ref{Intrinsic Procedures} where it is
2494 noted that they are extensions and should be avoided whenever possible.
2496 Specifically, @option{-fdec-math} enables the @ref{COTAN} intrinsic, and
2497 trigonometric intrinsics which accept or produce values in degrees instead of
2498 radians.  Here is a summary of the new intrinsics:
2500 @multitable @columnfractions .5 .5
2501 @headitem Radians @tab Degrees
2502 @item @code{@ref{ACOS}}   @tab @code{@ref{ACOSD}}*
2503 @item @code{@ref{ASIN}}   @tab @code{@ref{ASIND}}*
2504 @item @code{@ref{ATAN}}   @tab @code{@ref{ATAND}}*
2505 @item @code{@ref{ATAN2}}  @tab @code{@ref{ATAN2D}}*
2506 @item @code{@ref{COS}}    @tab @code{@ref{COSD}}*
2507 @item @code{@ref{COTAN}}* @tab @code{@ref{COTAND}}*
2508 @item @code{@ref{SIN}}    @tab @code{@ref{SIND}}*
2509 @item @code{@ref{TAN}}    @tab @code{@ref{TAND}}*
2510 @end multitable
2512 * Enabled with @option{-fdec-math}.
2514 For advanced users, it may be important to know the implementation of these
2515 functions. They are simply wrappers around the standard radian functions, which
2516 have more accurate builtin versions. These functions convert their arguments
2517 (or results) to degrees (or radians) by taking the value modulus 360 (or 2*pi)
2518 and then multiplying it by a constant radian-to-degree (or degree-to-radian)
2519 factor, as appropriate. The factor is computed at compile-time as 180/pi (or
2520 pi/180).
2522 @node Form feed as whitespace
2523 @subsection Form feed as whitespace
2524 @cindex form feed whitespace
2526 Historically, legacy compilers allowed insertion of form feed characters ('\f',
2527 ASCII 0xC) at the beginning of lines for formatted output to line printers,
2528 though the Fortran standard does not mention this. GNU Fortran supports the
2529 interpretation of form feed characters in source as whitespace for
2530 compatibility.
2532 @node TYPE as an alias for PRINT
2533 @subsection TYPE as an alias for PRINT
2534 @cindex type alias print
2535 For compatibility, GNU Fortran will interpret @code{TYPE} statements as
2536 @code{PRINT} statements with the flag @option{-fdec}.  With this flag asserted,
2537 the following two examples are equivalent:
2539 @smallexample
2540 TYPE *, 'hello world'
2541 @end smallexample
2543 @smallexample
2544 PRINT *, 'hello world'
2545 @end smallexample
2547 @node %LOC as an rvalue
2548 @subsection %LOC as an rvalue
2549 @cindex LOC
2550 Normally @code{%LOC} is allowed only in parameter lists.  However the intrinsic
2551 function @code{LOC} does the same thing, and is usable as the right-hand-side of
2552 assignments. For compatibility, GNU Fortran supports the use of @code{%LOC} as
2553 an alias for the builtin @code{LOC} with @option{-std=legacy}.  With this
2554 feature enabled the following two examples are equivalent:
2556 @smallexample
2557 integer :: i, l
2558 l = %loc(i)
2559 call sub(l)
2560 @end smallexample
2562 @smallexample
2563 integer :: i
2564 call sub(%loc(i))
2565 @end smallexample
2567 @node .XOR. operator
2568 @subsection .XOR. operator
2569 @cindex operators, xor
2571 GNU Fortran supports @code{.XOR.} as a logical operator with @code{-std=legacy}
2572 for compatibility with legacy code. @code{.XOR.} is equivalent to
2573 @code{.NEQV.}. That is, the output is true if and only if the inputs differ.
2575 @node Bitwise logical operators
2576 @subsection Bitwise logical operators
2577 @cindex logical, bitwise
2579 With @option{-fdec}, GNU Fortran relaxes the type constraints on
2580 logical operators to allow integer operands, and performs the corresponding
2581 bitwise operation instead.  This flag is for compatibility only, and should be
2582 avoided in new code.  Consider:
2584 @smallexample
2585   INTEGER :: i, j
2586   i = z'33'
2587   j = z'cc'
2588   print *, i .AND. j
2589 @end smallexample
2591 In this example, compiled with @option{-fdec}, GNU Fortran will
2592 replace the @code{.AND.} operation with a call to the intrinsic
2593 @code{@ref{IAND}} function, yielding the bitwise-and of @code{i} and @code{j}.
2595 Note that this conversion will occur if at least one operand is of integral
2596 type.  As a result, a logical operand will be converted to an integer when the
2597 other operand is an integer in a logical operation.  In this case,
2598 @code{.TRUE.} is converted to @code{1} and @code{.FALSE.} to @code{0}.
2600 Here is the mapping of logical operator to bitwise intrinsic used with
2601 @option{-fdec}:
2603 @multitable @columnfractions .25 .25 .5
2604 @headitem Operator @tab Intrinsic @tab Bitwise operation
2605 @item @code{.NOT.} @tab @code{@ref{NOT}} @tab complement
2606 @item @code{.AND.} @tab @code{@ref{IAND}} @tab intersection
2607 @item @code{.OR.} @tab @code{@ref{IOR}} @tab union
2608 @item @code{.NEQV.} @tab @code{@ref{IEOR}} @tab exclusive or
2609 @item @code{.EQV.} @tab @code{@ref{NOT}(@ref{IEOR})} @tab complement of exclusive or
2610 @end multitable
2612 @node Extended I/O specifiers
2613 @subsection Extended I/O specifiers
2614 @cindex @code{CARRIAGECONTROL}
2615 @cindex @code{READONLY}
2616 @cindex @code{SHARE}
2617 @cindex @code{SHARED}
2618 @cindex @code{NOSHARED}
2619 @cindex I/O specifiers
2621 GNU Fortran supports the additional legacy I/O specifiers
2622 @code{CARRIAGECONTROL}, @code{READONLY}, and @code{SHARE} with the
2623 compile flag @option{-fdec}, for compatibility.
2625 @table @code
2626 @item CARRIAGECONTROL
2627 The @code{CARRIAGECONTROL} specifier allows a user to control line
2628 termination settings between output records for an I/O unit. The specifier has
2629 no meaning for readonly files. When @code{CARRAIGECONTROL} is specified upon
2630 opening a unit for formatted writing, the exact @code{CARRIAGECONTROL} setting
2631 determines what characters to write between output records. The syntax is:
2633 @smallexample
2634 OPEN(..., CARRIAGECONTROL=cc)
2635 @end smallexample
2637 Where @emph{cc} is a character expression that evaluates to one of the
2638 following values:
2640 @multitable @columnfractions .2 .8
2641 @item @code{'LIST'} @tab One line feed between records (default)
2642 @item @code{'FORTRAN'} @tab Legacy interpretation of the first character (see below)
2643 @item @code{'NONE'} @tab No separator between records
2644 @end multitable
2646 With @code{CARRIAGECONTROL='FORTRAN'}, when a record is written, the first
2647 character of the input record is not written, and instead determines the output
2648 record separator as follows:
2650 @multitable @columnfractions .3 .3 .4
2651 @headitem Leading character @tab Meaning @tab Output separating character(s)
2652 @item @code{'+'} @tab Overprinting @tab Carriage return only
2653 @item @code{'-'} @tab New line @tab Line feed and carriage return
2654 @item @code{'0'} @tab Skip line @tab Two line feeds and carriage return
2655 @item @code{'1'} @tab New page @tab Form feed and carriage return
2656 @item @code{'$'} @tab Prompting @tab Line feed (no carriage return)
2657 @item @code{CHAR(0)} @tab Overprinting (no advance) @tab None
2658 @end multitable
2660 @item READONLY
2661 The @code{READONLY} specifier may be given upon opening a unit, and is
2662 equivalent to specifying @code{ACTION='READ'}, except that the file may not be
2663 deleted on close (i.e. @code{CLOSE} with @code{STATUS="DELETE"}). The syntax
2666 @smallexample
2667 @code{OPEN(..., READONLY)}
2668 @end smallexample
2670 @item SHARE
2671 The @code{SHARE} specifier allows system-level locking on a unit upon opening
2672 it for controlled access from multiple processes/threads. The @code{SHARE}
2673 specifier has several forms:
2675 @smallexample
2676 OPEN(..., SHARE=sh)
2677 OPEN(..., SHARED)
2678 OPEN(..., NOSHARED)
2679 @end smallexample
2681 Where @emph{sh} in the first form is a character expression that evaluates to
2682 a value as seen in the table below. The latter two forms are aliases
2683 for particular values of @emph{sh}:
2685 @multitable @columnfractions .3 .3 .4
2686 @headitem Explicit form @tab Short form @tab Meaning
2687 @item @code{SHARE='DENYRW'} @tab @code{NOSHARED} @tab Exclusive (write) lock
2688 @item @code{SHARE='DENYNONE'} @tab @code{SHARED} @tab Shared (read) lock
2689 @end multitable
2691 In general only one process may hold an exclusive (write) lock for a given file
2692 at a time, whereas many processes may hold shared (read) locks for the same
2693 file.
2695 The behavior of locking may vary with your operating system. On POSIX systems,
2696 locking is implemented with @code{fcntl}. Consult your corresponding operating
2697 system's manual pages for further details. Locking via @code{SHARE=} is not
2698 supported on other systems.
2700 @end table
2702 @node Legacy PARAMETER statements
2703 @subsection Legacy PARAMETER statements
2704 @cindex PARAMETER
2706 For compatibility, GNU Fortran supports legacy PARAMETER statements without
2707 parentheses with @option{-std=legacy}.  A warning is emitted if used with
2708 @option{-std=gnu}, and an error is acknowledged with a real Fortran standard
2709 flag (@option{-std=f95}, etc...).  These statements take the following form:
2711 @smallexample
2712 implicit real (E)
2713 parameter e = 2.718282
2714 real c
2715 parameter c = 3.0e8
2716 @end smallexample
2718 @node Default exponents
2719 @subsection Default exponents
2720 @cindex exponent
2722 For compatibility, GNU Fortran supports a default exponent of zero in real
2723 constants with @option{-fdec}.  For example, @code{9e} would be
2724 interpreted as @code{9e0}, rather than an error.
2727 @node Extensions not implemented in GNU Fortran
2728 @section Extensions not implemented in GNU Fortran
2729 @cindex extensions, not implemented
2731 The long history of the Fortran language, its wide use and broad
2732 userbase, the large number of different compiler vendors and the lack of
2733 some features crucial to users in the first standards have lead to the
2734 existence of a number of important extensions to the language.  While
2735 some of the most useful or popular extensions are supported by the GNU
2736 Fortran compiler, not all existing extensions are supported.  This section
2737 aims at listing these extensions and offering advice on how best make
2738 code that uses them running with the GNU Fortran compiler.
2740 @c More can be found here:
2741 @c   -- https://gcc.gnu.org/onlinedocs/gcc-3.4.6/g77/Missing-Features.html
2742 @c   -- the list of Fortran and libgfortran bugs closed as WONTFIX:
2743 @c      http://tinyurl.com/2u4h5y
2745 @menu
2746 * ENCODE and DECODE statements::
2747 * Variable FORMAT expressions::
2748 @c * Q edit descriptor::
2749 @c * TYPE and ACCEPT I/O Statements::
2750 @c * DEFAULTFILE, DISPOSE and RECORDTYPE I/O specifiers::
2751 @c * Omitted arguments in procedure call::
2752 * Alternate complex function syntax::
2753 * Volatile COMMON blocks::
2754 * OPEN( ... NAME=)::
2755 @end menu
2757 @node ENCODE and DECODE statements
2758 @subsection @code{ENCODE} and @code{DECODE} statements
2759 @cindex @code{ENCODE}
2760 @cindex @code{DECODE}
2762 GNU Fortran does not support the @code{ENCODE} and @code{DECODE}
2763 statements.  These statements are best replaced by @code{READ} and
2764 @code{WRITE} statements involving internal files (@code{CHARACTER}
2765 variables and arrays), which have been part of the Fortran standard since
2766 Fortran 77.  For example, replace a code fragment like
2768 @smallexample
2769       INTEGER*1 LINE(80)
2770       REAL A, B, C
2771 c     ... Code that sets LINE
2772       DECODE (80, 9000, LINE) A, B, C
2773  9000 FORMAT (1X, 3(F10.5))
2774 @end smallexample
2776 @noindent
2777 with the following:
2779 @smallexample
2780       CHARACTER(LEN=80) LINE
2781       REAL A, B, C
2782 c     ... Code that sets LINE
2783       READ (UNIT=LINE, FMT=9000) A, B, C
2784  9000 FORMAT (1X, 3(F10.5))
2785 @end smallexample
2787 Similarly, replace a code fragment like
2789 @smallexample
2790       INTEGER*1 LINE(80)
2791       REAL A, B, C
2792 c     ... Code that sets A, B and C
2793       ENCODE (80, 9000, LINE) A, B, C
2794  9000 FORMAT (1X, 'OUTPUT IS ', 3(F10.5))
2795 @end smallexample
2797 @noindent
2798 with the following:
2800 @smallexample
2801       CHARACTER(LEN=80) LINE
2802       REAL A, B, C
2803 c     ... Code that sets A, B and C
2804       WRITE (UNIT=LINE, FMT=9000) A, B, C
2805  9000 FORMAT (1X, 'OUTPUT IS ', 3(F10.5))
2806 @end smallexample
2809 @node Variable FORMAT expressions
2810 @subsection Variable @code{FORMAT} expressions
2811 @cindex @code{FORMAT}
2813 A variable @code{FORMAT} expression is format statement which includes
2814 angle brackets enclosing a Fortran expression: @code{FORMAT(I<N>)}.  GNU
2815 Fortran does not support this legacy extension.  The effect of variable
2816 format expressions can be reproduced by using the more powerful (and
2817 standard) combination of internal output and string formats.  For example,
2818 replace a code fragment like this:
2820 @smallexample
2821       WRITE(6,20) INT1
2822  20   FORMAT(I<N+1>)
2823 @end smallexample
2825 @noindent
2826 with the following:
2828 @smallexample
2829 c     Variable declaration
2830       CHARACTER(LEN=20) FMT
2831 c     
2832 c     Other code here...
2834       WRITE(FMT,'("(I", I0, ")")') N+1
2835       WRITE(6,FMT) INT1
2836 @end smallexample
2838 @noindent
2839 or with:
2841 @smallexample
2842 c     Variable declaration
2843       CHARACTER(LEN=20) FMT
2844 c     
2845 c     Other code here...
2847       WRITE(FMT,*) N+1
2848       WRITE(6,"(I" // ADJUSTL(FMT) // ")") INT1
2849 @end smallexample
2852 @node Alternate complex function syntax
2853 @subsection Alternate complex function syntax
2854 @cindex Complex function
2856 Some Fortran compilers, including @command{g77}, let the user declare
2857 complex functions with the syntax @code{COMPLEX FUNCTION name*16()}, as
2858 well as @code{COMPLEX*16 FUNCTION name()}.  Both are non-standard, legacy
2859 extensions.  @command{gfortran} accepts the latter form, which is more
2860 common, but not the former.
2863 @node Volatile COMMON blocks
2864 @subsection Volatile @code{COMMON} blocks
2865 @cindex @code{VOLATILE}
2866 @cindex @code{COMMON}
2868 Some Fortran compilers, including @command{g77}, let the user declare
2869 @code{COMMON} with the @code{VOLATILE} attribute. This is
2870 invalid standard Fortran syntax and is not supported by
2871 @command{gfortran}.  Note that @command{gfortran} accepts
2872 @code{VOLATILE} variables in @code{COMMON} blocks since revision 4.3.
2875 @node OPEN( ... NAME=)
2876 @subsection @code{OPEN( ... NAME=)}
2877 @cindex @code{NAM}
2879 Some Fortran compilers, including @command{g77}, let the user declare
2880 @code{OPEN( ... NAME=)}. This is
2881 invalid standard Fortran syntax and is not supported by
2882 @command{gfortran}.  @code{OPEN( ... NAME=)} should be replaced
2883 with @code{OPEN( ... FILE=)}.
2887 @c ---------------------------------------------------------------------
2888 @c ---------------------------------------------------------------------
2889 @c Mixed-Language Programming
2890 @c ---------------------------------------------------------------------
2892 @node Mixed-Language Programming
2893 @chapter Mixed-Language Programming
2894 @cindex Interoperability
2895 @cindex Mixed-language programming
2897 @menu
2898 * Interoperability with C::
2899 * GNU Fortran Compiler Directives::
2900 * Non-Fortran Main Program::
2901 * Naming and argument-passing conventions::
2902 @end menu
2904 This chapter is about mixed-language interoperability, but also applies
2905 if one links Fortran code compiled by different compilers.  In most cases,
2906 use of the C Binding features of the Fortran 2003 standard is sufficient,
2907 and their use is highly recommended.
2910 @node Interoperability with C
2911 @section Interoperability with C
2913 @menu
2914 * Intrinsic Types::
2915 * Derived Types and struct::
2916 * Interoperable Global Variables::
2917 * Interoperable Subroutines and Functions::
2918 * Working with Pointers::
2919 * Further Interoperability of Fortran with C::
2920 @end menu
2922 Since Fortran 2003 (ISO/IEC 1539-1:2004(E)) there is a
2923 standardized way to generate procedure and derived-type
2924 declarations and global variables which are interoperable with C
2925 (ISO/IEC 9899:1999).  The @code{bind(C)} attribute has been added
2926 to inform the compiler that a symbol shall be interoperable with C;
2927 also, some constraints are added.  Note, however, that not
2928 all C features have a Fortran equivalent or vice versa.  For instance,
2929 neither C's unsigned integers nor C's functions with variable number
2930 of arguments have an equivalent in Fortran.
2932 Note that array dimensions are reversely ordered in C and that arrays in
2933 C always start with index 0 while in Fortran they start by default with
2934 1.  Thus, an array declaration @code{A(n,m)} in Fortran matches
2935 @code{A[m][n]} in C and accessing the element @code{A(i,j)} matches
2936 @code{A[j-1][i-1]}.  The element following @code{A(i,j)} (C: @code{A[j-1][i-1]};
2937 assuming @math{i < n}) in memory is @code{A(i+1,j)} (C: @code{A[j-1][i]}).
2939 @node Intrinsic Types
2940 @subsection Intrinsic Types
2942 In order to ensure that exactly the same variable type and kind is used
2943 in C and Fortran, the named constants shall be used which are defined in the
2944 @code{ISO_C_BINDING} intrinsic module.  That module contains named constants
2945 for kind parameters and character named constants for the escape sequences
2946 in C.  For a list of the constants, see @ref{ISO_C_BINDING}.
2948 For logical types, please note that the Fortran standard only guarantees
2949 interoperability between C99's @code{_Bool} and Fortran's @code{C_Bool}-kind
2950 logicals and C99 defines that @code{true} has the value 1 and @code{false}
2951 the value 0.  Using any other integer value with GNU Fortran's @code{LOGICAL}
2952 (with any kind parameter) gives an undefined result.  (Passing other integer
2953 values than 0 and 1 to GCC's @code{_Bool} is also undefined, unless the
2954 integer is explicitly or implicitly casted to @code{_Bool}.)
2958 @node Derived Types and struct
2959 @subsection Derived Types and struct
2961 For compatibility of derived types with @code{struct}, one needs to use
2962 the @code{BIND(C)} attribute in the type declaration.  For instance, the
2963 following type declaration
2965 @smallexample
2966  USE ISO_C_BINDING
2967  TYPE, BIND(C) :: myType
2968    INTEGER(C_INT) :: i1, i2
2969    INTEGER(C_SIGNED_CHAR) :: i3
2970    REAL(C_DOUBLE) :: d1
2971    COMPLEX(C_FLOAT_COMPLEX) :: c1
2972    CHARACTER(KIND=C_CHAR) :: str(5)
2973  END TYPE
2974 @end smallexample
2976 matches the following @code{struct} declaration in C
2978 @smallexample
2979  struct @{
2980    int i1, i2;
2981    /* Note: "char" might be signed or unsigned.  */
2982    signed char i3;
2983    double d1;
2984    float _Complex c1;
2985    char str[5];
2986  @} myType;
2987 @end smallexample
2989 Derived types with the C binding attribute shall not have the @code{sequence}
2990 attribute, type parameters, the @code{extends} attribute, nor type-bound
2991 procedures.  Every component must be of interoperable type and kind and may not
2992 have the @code{pointer} or @code{allocatable} attribute.  The names of the
2993 components are irrelevant for interoperability.
2995 As there exist no direct Fortran equivalents, neither unions nor structs
2996 with bit field or variable-length array members are interoperable.
2998 @node Interoperable Global Variables
2999 @subsection Interoperable Global Variables
3001 Variables can be made accessible from C using the C binding attribute,
3002 optionally together with specifying a binding name.  Those variables
3003 have to be declared in the declaration part of a @code{MODULE},
3004 be of interoperable type, and have neither the @code{pointer} nor
3005 the @code{allocatable} attribute.
3007 @smallexample
3008   MODULE m
3009     USE myType_module
3010     USE ISO_C_BINDING
3011     integer(C_INT), bind(C, name="_MyProject_flags") :: global_flag
3012     type(myType), bind(C) :: tp
3013   END MODULE
3014 @end smallexample
3016 Here, @code{_MyProject_flags} is the case-sensitive name of the variable
3017 as seen from C programs while @code{global_flag} is the case-insensitive
3018 name as seen from Fortran.  If no binding name is specified, as for
3019 @var{tp}, the C binding name is the (lowercase) Fortran binding name.
3020 If a binding name is specified, only a single variable may be after the
3021 double colon.  Note of warning: You cannot use a global variable to
3022 access @var{errno} of the C library as the C standard allows it to be
3023 a macro.  Use the @code{IERRNO} intrinsic (GNU extension) instead.
3025 @node Interoperable Subroutines and Functions
3026 @subsection Interoperable Subroutines and Functions
3028 Subroutines and functions have to have the @code{BIND(C)} attribute to
3029 be compatible with C.  The dummy argument declaration is relatively
3030 straightforward.  However, one needs to be careful because C uses
3031 call-by-value by default while Fortran behaves usually similar to
3032 call-by-reference.  Furthermore, strings and pointers are handled
3033 differently.  Note that in Fortran 2003 and 2008 only explicit size
3034 and assumed-size arrays are supported but not assumed-shape or
3035 deferred-shape (i.e. allocatable or pointer) arrays.  However, those
3036 are allowed since the Technical Specification 29113, see
3037 @ref{Further Interoperability of Fortran with C}
3039 To pass a variable by value, use the @code{VALUE} attribute.
3040 Thus, the following C prototype
3042 @smallexample
3043 @code{int func(int i, int *j)}
3044 @end smallexample
3046 matches the Fortran declaration
3048 @smallexample
3049   integer(c_int) function func(i,j)
3050     use iso_c_binding, only: c_int
3051     integer(c_int), VALUE :: i
3052     integer(c_int) :: j
3053 @end smallexample
3055 Note that pointer arguments also frequently need the @code{VALUE} attribute,
3056 see @ref{Working with Pointers}.
3058 Strings are handled quite differently in C and Fortran.  In C a string
3059 is a @code{NUL}-terminated array of characters while in Fortran each string
3060 has a length associated with it and is thus not terminated (by e.g.
3061 @code{NUL}).  For example, if one wants to use the following C function,
3063 @smallexample
3064   #include <stdio.h>
3065   void print_C(char *string) /* equivalent: char string[]  */
3066   @{
3067      printf("%s\n", string);
3068   @}
3069 @end smallexample
3071 to print ``Hello World'' from Fortran, one can call it using
3073 @smallexample
3074   use iso_c_binding, only: C_CHAR, C_NULL_CHAR
3075   interface
3076     subroutine print_c(string) bind(C, name="print_C")
3077       use iso_c_binding, only: c_char
3078       character(kind=c_char) :: string(*)
3079     end subroutine print_c
3080   end interface
3081   call print_c(C_CHAR_"Hello World"//C_NULL_CHAR)
3082 @end smallexample
3084 As the example shows, one needs to ensure that the
3085 string is @code{NUL} terminated.  Additionally, the dummy argument
3086 @var{string} of @code{print_C} is a length-one assumed-size
3087 array; using @code{character(len=*)} is not allowed.  The example
3088 above uses @code{c_char_"Hello World"} to ensure the string
3089 literal has the right type; typically the default character
3090 kind and @code{c_char} are the same and thus @code{"Hello World"}
3091 is equivalent.  However, the standard does not guarantee this.
3093 The use of strings is now further illustrated using the C library
3094 function @code{strncpy}, whose prototype is
3096 @smallexample
3097   char *strncpy(char *restrict s1, const char *restrict s2, size_t n);
3098 @end smallexample
3100 The function @code{strncpy} copies at most @var{n} characters from
3101 string @var{s2} to @var{s1} and returns @var{s1}.  In the following
3102 example, we ignore the return value:
3104 @smallexample
3105   use iso_c_binding
3106   implicit none
3107   character(len=30) :: str,str2
3108   interface
3109     ! Ignore the return value of strncpy -> subroutine
3110     ! "restrict" is always assumed if we do not pass a pointer
3111     subroutine strncpy(dest, src, n) bind(C)
3112       import
3113       character(kind=c_char),  intent(out) :: dest(*)
3114       character(kind=c_char),  intent(in)  :: src(*)
3115       integer(c_size_t), value, intent(in) :: n
3116     end subroutine strncpy
3117   end interface
3118   str = repeat('X',30) ! Initialize whole string with 'X'
3119   call strncpy(str, c_char_"Hello World"//C_NULL_CHAR, &
3120                len(c_char_"Hello World",kind=c_size_t))
3121   print '(a)', str ! prints: "Hello WorldXXXXXXXXXXXXXXXXXXX"
3122   end
3123 @end smallexample
3125 The intrinsic procedures are described in @ref{Intrinsic Procedures}.
3127 @node Working with Pointers
3128 @subsection Working with Pointers
3130 C pointers are represented in Fortran via the special opaque derived type
3131 @code{type(c_ptr)} (with private components).  Thus one needs to
3132 use intrinsic conversion procedures to convert from or to C pointers.
3134 For some applications, using an assumed type (@code{TYPE(*)}) can be an
3135 alternative to a C pointer; see
3136 @ref{Further Interoperability of Fortran with C}.
3138 For example,
3140 @smallexample
3141   use iso_c_binding
3142   type(c_ptr) :: cptr1, cptr2
3143   integer, target :: array(7), scalar
3144   integer, pointer :: pa(:), ps
3145   cptr1 = c_loc(array(1)) ! The programmer needs to ensure that the
3146                           ! array is contiguous if required by the C
3147                           ! procedure
3148   cptr2 = c_loc(scalar)
3149   call c_f_pointer(cptr2, ps)
3150   call c_f_pointer(cptr2, pa, shape=[7])
3151 @end smallexample
3153 When converting C to Fortran arrays, the one-dimensional @code{SHAPE} argument
3154 has to be passed.
3156 If a pointer is a dummy-argument of an interoperable procedure, it usually
3157 has to be declared using the @code{VALUE} attribute.  @code{void*}
3158 matches @code{TYPE(C_PTR), VALUE}, while @code{TYPE(C_PTR)} alone
3159 matches @code{void**}.
3161 Procedure pointers are handled analogously to pointers; the C type is
3162 @code{TYPE(C_FUNPTR)} and the intrinsic conversion procedures are
3163 @code{C_F_PROCPOINTER} and @code{C_FUNLOC}.
3165 Let us consider two examples of actually passing a procedure pointer from
3166 C to Fortran and vice versa.  Note that these examples are also very
3167 similar to passing ordinary pointers between both languages. First,
3168 consider this code in C:
3170 @smallexample
3171 /* Procedure implemented in Fortran.  */
3172 void get_values (void (*)(double));
3174 /* Call-back routine we want called from Fortran.  */
3175 void
3176 print_it (double x)
3178   printf ("Number is %f.\n", x);
3181 /* Call Fortran routine and pass call-back to it.  */
3182 void
3183 foobar ()
3185   get_values (&print_it);
3187 @end smallexample
3189 A matching implementation for @code{get_values} in Fortran, that correctly
3190 receives the procedure pointer from C and is able to call it, is given
3191 in the following @code{MODULE}:
3193 @smallexample
3194 MODULE m
3195   IMPLICIT NONE
3197   ! Define interface of call-back routine.
3198   ABSTRACT INTERFACE
3199     SUBROUTINE callback (x)
3200       USE, INTRINSIC :: ISO_C_BINDING
3201       REAL(KIND=C_DOUBLE), INTENT(IN), VALUE :: x
3202     END SUBROUTINE callback
3203   END INTERFACE
3205 CONTAINS
3207   ! Define C-bound procedure.
3208   SUBROUTINE get_values (cproc) BIND(C)
3209     USE, INTRINSIC :: ISO_C_BINDING
3210     TYPE(C_FUNPTR), INTENT(IN), VALUE :: cproc
3212     PROCEDURE(callback), POINTER :: proc
3214     ! Convert C to Fortran procedure pointer.
3215     CALL C_F_PROCPOINTER (cproc, proc)
3217     ! Call it.
3218     CALL proc (1.0_C_DOUBLE)
3219     CALL proc (-42.0_C_DOUBLE)
3220     CALL proc (18.12_C_DOUBLE)
3221   END SUBROUTINE get_values
3223 END MODULE m
3224 @end smallexample
3226 Next, we want to call a C routine that expects a procedure pointer argument
3227 and pass it a Fortran procedure (which clearly must be interoperable!).
3228 Again, the C function may be:
3230 @smallexample
3232 call_it (int (*func)(int), int arg)
3234   return func (arg);
3236 @end smallexample
3238 It can be used as in the following Fortran code:
3240 @smallexample
3241 MODULE m
3242   USE, INTRINSIC :: ISO_C_BINDING
3243   IMPLICIT NONE
3245   ! Define interface of C function.
3246   INTERFACE
3247     INTEGER(KIND=C_INT) FUNCTION call_it (func, arg) BIND(C)
3248       USE, INTRINSIC :: ISO_C_BINDING
3249       TYPE(C_FUNPTR), INTENT(IN), VALUE :: func
3250       INTEGER(KIND=C_INT), INTENT(IN), VALUE :: arg
3251     END FUNCTION call_it
3252   END INTERFACE
3254 CONTAINS
3256   ! Define procedure passed to C function.
3257   ! It must be interoperable!
3258   INTEGER(KIND=C_INT) FUNCTION double_it (arg) BIND(C)
3259     INTEGER(KIND=C_INT), INTENT(IN), VALUE :: arg
3260     double_it = arg + arg
3261   END FUNCTION double_it
3263   ! Call C function.
3264   SUBROUTINE foobar ()
3265     TYPE(C_FUNPTR) :: cproc
3266     INTEGER(KIND=C_INT) :: i
3268     ! Get C procedure pointer.
3269     cproc = C_FUNLOC (double_it)
3271     ! Use it.
3272     DO i = 1_C_INT, 10_C_INT
3273       PRINT *, call_it (cproc, i)
3274     END DO
3275   END SUBROUTINE foobar
3277 END MODULE m
3278 @end smallexample
3280 @node Further Interoperability of Fortran with C
3281 @subsection Further Interoperability of Fortran with C
3283 The Technical Specification ISO/IEC TS 29113:2012 on further
3284 interoperability of Fortran with C extends the interoperability support
3285 of Fortran 2003 and Fortran 2008. Besides removing some restrictions
3286 and constraints, it adds assumed-type (@code{TYPE(*)}) and assumed-rank
3287 (@code{dimension}) variables and allows for interoperability of
3288 assumed-shape, assumed-rank and deferred-shape arrays, including
3289 allocatables and pointers.
3291 Note: Currently, GNU Fortran does not support the array descriptor
3292 (dope vector) as specified in the Technical Specification, but uses
3293 an array descriptor with different fields. The Chasm Language
3294 Interoperability Tools, @url{http://chasm-interop.sourceforge.net/},
3295 provide an interface to GNU Fortran's array descriptor.
3297 The Technical Specification adds the following new features, which
3298 are supported by GNU Fortran:
3300 @itemize @bullet
3302 @item The @code{ASYNCHRONOUS} attribute has been clarified and
3303 extended to allow its use with asynchronous communication in
3304 user-provided libraries such as in implementations of the
3305 Message Passing Interface specification.
3307 @item Many constraints have been relaxed, in particular for
3308 the @code{C_LOC} and @code{C_F_POINTER} intrinsics.
3310 @item The @code{OPTIONAL} attribute is now allowed for dummy
3311 arguments; an absent argument matches a @code{NULL} pointer.
3313 @item Assumed types (@code{TYPE(*)}) have been added, which may
3314 only be used for dummy arguments.  They are unlimited polymorphic
3315 but contrary to @code{CLASS(*)} they do not contain any type
3316 information, similar to C's @code{void *} pointers.  Expressions
3317 of any type and kind can be passed; thus, it can be used as
3318 replacement for @code{TYPE(C_PTR)}, avoiding the use of
3319 @code{C_LOC} in the caller.
3321 Note, however, that @code{TYPE(*)} only accepts scalar arguments,
3322 unless the @code{DIMENSION} is explicitly specified.  As
3323 @code{DIMENSION(*)} only supports array (including array elements) but
3324 no scalars, it is not a full replacement for @code{C_LOC}.  On the
3325 other hand, assumed-type assumed-rank dummy arguments
3326 (@code{TYPE(*), DIMENSION(..)}) allow for both scalars and arrays, but
3327 require special code on the callee side to handle the array descriptor.
3329 @item Assumed-rank arrays (@code{DIMENSION(..)}) as dummy argument
3330 allow that scalars and arrays of any rank can be passed as actual
3331 argument. As the Technical Specification does not provide for direct
3332 means to operate with them, they have to be used either from the C side
3333 or be converted using @code{C_LOC} and @code{C_F_POINTER} to scalars
3334 or arrays of a specific rank. The rank can be determined using the
3335 @code{RANK} intrinisic.
3336 @end itemize
3339 Currently unimplemented:
3341 @itemize @bullet
3343 @item GNU Fortran always uses an array descriptor, which does not
3344 match the one of the Technical Specification. The
3345 @code{ISO_Fortran_binding.h} header file and the C functions it
3346 specifies are not available.
3348 @item Using assumed-shape, assumed-rank and deferred-shape arrays in
3349 @code{BIND(C)} procedures is not fully supported. In particular,
3350 C interoperable strings of other length than one are not supported
3351 as this requires the new array descriptor.
3352 @end itemize
3355 @node GNU Fortran Compiler Directives
3356 @section GNU Fortran Compiler Directives
3358 The Fortran standard describes how a conforming program shall
3359 behave; however, the exact implementation is not standardized.  In order
3360 to allow the user to choose specific implementation details, compiler
3361 directives can be used to set attributes of variables and procedures
3362 which are not part of the standard.  Whether a given attribute is
3363 supported and its exact effects depend on both the operating system and
3364 on the processor; see
3365 @ref{Top,,C Extensions,gcc,Using the GNU Compiler Collection (GCC)}
3366 for details.
3368 For procedures and procedure pointers, the following attributes can
3369 be used to change the calling convention:
3371 @itemize
3372 @item @code{CDECL} -- standard C calling convention
3373 @item @code{STDCALL} -- convention where the called procedure pops the stack
3374 @item @code{FASTCALL} -- part of the arguments are passed via registers
3375 instead using the stack
3376 @end itemize
3378 Besides changing the calling convention, the attributes also influence
3379 the decoration of the symbol name, e.g., by a leading underscore or by
3380 a trailing at-sign followed by the number of bytes on the stack.  When
3381 assigning a procedure to a procedure pointer, both should use the same
3382 calling convention.
3384 On some systems, procedures and global variables (module variables and
3385 @code{COMMON} blocks) need special handling to be accessible when they
3386 are in a shared library.  The following attributes are available:
3388 @itemize
3389 @item @code{DLLEXPORT} -- provide a global pointer to a pointer in the DLL
3390 @item @code{DLLIMPORT} -- reference the function or variable using a
3391 global pointer
3392 @end itemize
3394 For dummy arguments, the @code{NO_ARG_CHECK} attribute can be used; in
3395 other compilers, it is also known as @code{IGNORE_TKR}.  For dummy arguments
3396 with this attribute actual arguments of any type and kind (similar to
3397 @code{TYPE(*)}), scalars and arrays of any rank (no equivalent
3398 in Fortran standard) are accepted.  As with @code{TYPE(*)}, the argument
3399 is unlimited polymorphic and no type information is available.
3400 Additionally, the argument may only be passed to dummy arguments
3401 with the @code{NO_ARG_CHECK} attribute and as argument to the
3402 @code{PRESENT} intrinsic function and to @code{C_LOC} of the
3403 @code{ISO_C_BINDING} module.
3405 Variables with @code{NO_ARG_CHECK} attribute shall be of assumed-type
3406 (@code{TYPE(*)}; recommended) or of type @code{INTEGER}, @code{LOGICAL},
3407 @code{REAL} or @code{COMPLEX}. They shall not have the @code{ALLOCATE},
3408 @code{CODIMENSION}, @code{INTENT(OUT)}, @code{POINTER} or @code{VALUE}
3409 attribute; furthermore, they shall be either scalar or of assumed-size
3410 (@code{dimension(*)}). As @code{TYPE(*)}, the @code{NO_ARG_CHECK} attribute
3411 requires an explicit interface.
3413 @itemize
3414 @item @code{NO_ARG_CHECK} -- disable the type, kind and rank checking
3415 @end itemize
3418 The attributes are specified using the syntax
3420 @code{!GCC$ ATTRIBUTES} @var{attribute-list} @code{::} @var{variable-list}
3422 where in free-form source code only whitespace is allowed before @code{!GCC$}
3423 and in fixed-form source code @code{!GCC$}, @code{cGCC$} or @code{*GCC$} shall
3424 start in the first column.
3426 For procedures, the compiler directives shall be placed into the body
3427 of the procedure; for variables and procedure pointers, they shall be in
3428 the same declaration part as the variable or procedure pointer.
3432 @node Non-Fortran Main Program
3433 @section Non-Fortran Main Program
3435 @menu
3436 * _gfortran_set_args:: Save command-line arguments
3437 * _gfortran_set_options:: Set library option flags
3438 * _gfortran_set_convert:: Set endian conversion
3439 * _gfortran_set_record_marker:: Set length of record markers
3440 * _gfortran_set_fpe:: Set when a Floating Point Exception should be raised
3441 * _gfortran_set_max_subrecord_length:: Set subrecord length
3442 @end menu
3444 Even if you are doing mixed-language programming, it is very
3445 likely that you do not need to know or use the information in this
3446 section.  Since it is about the internal structure of GNU Fortran,
3447 it may also change in GCC minor releases.
3449 When you compile a @code{PROGRAM} with GNU Fortran, a function
3450 with the name @code{main} (in the symbol table of the object file)
3451 is generated, which initializes the libgfortran library and then
3452 calls the actual program which uses the name @code{MAIN__}, for
3453 historic reasons.  If you link GNU Fortran compiled procedures
3454 to, e.g., a C or C++ program or to a Fortran program compiled by
3455 a different compiler, the libgfortran library is not initialized
3456 and thus a few intrinsic procedures do not work properly, e.g.
3457 those for obtaining the command-line arguments.
3459 Therefore, if your @code{PROGRAM} is not compiled with
3460 GNU Fortran and the GNU Fortran compiled procedures require
3461 intrinsics relying on the library initialization, you need to
3462 initialize the library yourself.  Using the default options,
3463 gfortran calls @code{_gfortran_set_args} and
3464 @code{_gfortran_set_options}.  The initialization of the former
3465 is needed if the called procedures access the command line
3466 (and for backtracing); the latter sets some flags based on the
3467 standard chosen or to enable backtracing.  In typical programs,
3468 it is not necessary to call any initialization function.
3470 If your @code{PROGRAM} is compiled with GNU Fortran, you shall
3471 not call any of the following functions.  The libgfortran
3472 initialization functions are shown in C syntax but using C
3473 bindings they are also accessible from Fortran.
3476 @node _gfortran_set_args
3477 @subsection @code{_gfortran_set_args} --- Save command-line arguments
3478 @fnindex _gfortran_set_args
3479 @cindex libgfortran initialization, set_args
3481 @table @asis
3482 @item @emph{Description}:
3483 @code{_gfortran_set_args} saves the command-line arguments; this
3484 initialization is required if any of the command-line intrinsics
3485 is called.  Additionally, it shall be called if backtracing is
3486 enabled (see @code{_gfortran_set_options}).
3488 @item @emph{Syntax}:
3489 @code{void _gfortran_set_args (int argc, char *argv[])}
3491 @item @emph{Arguments}:
3492 @multitable @columnfractions .15 .70
3493 @item @var{argc} @tab number of command line argument strings
3494 @item @var{argv} @tab the command-line argument strings; argv[0]
3495 is the pathname of the executable itself.
3496 @end multitable
3498 @item @emph{Example}:
3499 @smallexample
3500 int main (int argc, char *argv[])
3502   /* Initialize libgfortran.  */
3503   _gfortran_set_args (argc, argv);
3504   return 0;
3506 @end smallexample
3507 @end table
3510 @node _gfortran_set_options
3511 @subsection @code{_gfortran_set_options} --- Set library option flags
3512 @fnindex _gfortran_set_options
3513 @cindex libgfortran initialization, set_options
3515 @table @asis
3516 @item @emph{Description}:
3517 @code{_gfortran_set_options} sets several flags related to the Fortran
3518 standard to be used, whether backtracing should be enabled
3519 and whether range checks should be performed.  The syntax allows for
3520 upward compatibility since the number of passed flags is specified; for
3521 non-passed flags, the default value is used.  See also
3522 @pxref{Code Gen Options}.  Please note that not all flags are actually
3523 used.
3525 @item @emph{Syntax}:
3526 @code{void _gfortran_set_options (int num, int options[])}
3528 @item @emph{Arguments}:
3529 @multitable @columnfractions .15 .70
3530 @item @var{num} @tab number of options passed
3531 @item @var{argv} @tab The list of flag values
3532 @end multitable
3534 @item @emph{option flag list}:
3535 @multitable @columnfractions .15 .70
3536 @item @var{option}[0] @tab Allowed standard; can give run-time errors
3537 if e.g. an input-output edit descriptor is invalid in a given standard.
3538 Possible values are (bitwise or-ed) @code{GFC_STD_F77} (1),
3539 @code{GFC_STD_F95_OBS} (2), @code{GFC_STD_F95_DEL} (4), @code{GFC_STD_F95}
3540 (8), @code{GFC_STD_F2003} (16), @code{GFC_STD_GNU} (32),
3541 @code{GFC_STD_LEGACY} (64), @code{GFC_STD_F2008} (128),
3542 @code{GFC_STD_F2008_OBS} (256) and GFC_STD_F2008_TS (512). Default:
3543 @code{GFC_STD_F95_OBS | GFC_STD_F95_DEL | GFC_STD_F95 | GFC_STD_F2003
3544 | GFC_STD_F2008 | GFC_STD_F2008_TS | GFC_STD_F2008_OBS | GFC_STD_F77
3545 | GFC_STD_GNU | GFC_STD_LEGACY}.
3546 @item @var{option}[1] @tab Standard-warning flag; prints a warning to
3547 standard error.  Default: @code{GFC_STD_F95_DEL | GFC_STD_LEGACY}.
3548 @item @var{option}[2] @tab If non zero, enable pedantic checking.
3549 Default: off.
3550 @item @var{option}[3] @tab Unused.
3551 @item @var{option}[4] @tab If non zero, enable backtracing on run-time
3552 errors.  Default: off. (Default in the compiler: on.)
3553 Note: Installs a signal handler and requires command-line
3554 initialization using @code{_gfortran_set_args}.
3555 @item @var{option}[5] @tab If non zero, supports signed zeros.
3556 Default: enabled.
3557 @item @var{option}[6] @tab Enables run-time checking.  Possible values
3558 are (bitwise or-ed): GFC_RTCHECK_BOUNDS (1), GFC_RTCHECK_ARRAY_TEMPS (2),
3559 GFC_RTCHECK_RECURSION (4), GFC_RTCHECK_DO (16), GFC_RTCHECK_POINTER (32).
3560 Default: disabled.
3561 @item @var{option}[7] @tab Unused.
3562 @item @var{option}[8] @tab Show a warning when invoking @code{STOP} and
3563 @code{ERROR STOP} if a floating-point exception occurred. Possible values
3564 are (bitwise or-ed) @code{GFC_FPE_INVALID} (1), @code{GFC_FPE_DENORMAL} (2),
3565 @code{GFC_FPE_ZERO} (4), @code{GFC_FPE_OVERFLOW} (8),
3566 @code{GFC_FPE_UNDERFLOW} (16), @code{GFC_FPE_INEXACT} (32). Default: None (0).
3567 (Default in the compiler: @code{GFC_FPE_INVALID | GFC_FPE_DENORMAL |
3568 GFC_FPE_ZERO | GFC_FPE_OVERFLOW | GFC_FPE_UNDERFLOW}.)
3569 @end multitable
3571 @item @emph{Example}:
3572 @smallexample
3573   /* Use gfortran 4.9 default options.  */
3574   static int options[] = @{68, 511, 0, 0, 1, 1, 0, 0, 31@};
3575   _gfortran_set_options (9, &options);
3576 @end smallexample
3577 @end table
3580 @node _gfortran_set_convert
3581 @subsection @code{_gfortran_set_convert} --- Set endian conversion
3582 @fnindex _gfortran_set_convert
3583 @cindex libgfortran initialization, set_convert
3585 @table @asis
3586 @item @emph{Description}:
3587 @code{_gfortran_set_convert} set the representation of data for
3588 unformatted files.
3590 @item @emph{Syntax}:
3591 @code{void _gfortran_set_convert (int conv)}
3593 @item @emph{Arguments}:
3594 @multitable @columnfractions .15 .70
3595 @item @var{conv} @tab Endian conversion, possible values:
3596 GFC_CONVERT_NATIVE (0, default), GFC_CONVERT_SWAP (1),
3597 GFC_CONVERT_BIG (2), GFC_CONVERT_LITTLE (3).
3598 @end multitable
3600 @item @emph{Example}:
3601 @smallexample
3602 int main (int argc, char *argv[])
3604   /* Initialize libgfortran.  */
3605   _gfortran_set_args (argc, argv);
3606   _gfortran_set_convert (1);
3607   return 0;
3609 @end smallexample
3610 @end table
3613 @node _gfortran_set_record_marker
3614 @subsection @code{_gfortran_set_record_marker} --- Set length of record markers
3615 @fnindex _gfortran_set_record_marker
3616 @cindex libgfortran initialization, set_record_marker
3618 @table @asis
3619 @item @emph{Description}:
3620 @code{_gfortran_set_record_marker} sets the length of record markers
3621 for unformatted files.
3623 @item @emph{Syntax}:
3624 @code{void _gfortran_set_record_marker (int val)}
3626 @item @emph{Arguments}:
3627 @multitable @columnfractions .15 .70
3628 @item @var{val} @tab Length of the record marker; valid values
3629 are 4 and 8.  Default is 4.
3630 @end multitable
3632 @item @emph{Example}:
3633 @smallexample
3634 int main (int argc, char *argv[])
3636   /* Initialize libgfortran.  */
3637   _gfortran_set_args (argc, argv);
3638   _gfortran_set_record_marker (8);
3639   return 0;
3641 @end smallexample
3642 @end table
3645 @node _gfortran_set_fpe
3646 @subsection @code{_gfortran_set_fpe} --- Enable floating point exception traps
3647 @fnindex _gfortran_set_fpe
3648 @cindex libgfortran initialization, set_fpe
3650 @table @asis
3651 @item @emph{Description}:
3652 @code{_gfortran_set_fpe} enables floating point exception traps for
3653 the specified exceptions.  On most systems, this will result in a
3654 SIGFPE signal being sent and the program being aborted.
3656 @item @emph{Syntax}:
3657 @code{void _gfortran_set_fpe (int val)}
3659 @item @emph{Arguments}:
3660 @multitable @columnfractions .15 .70
3661 @item @var{option}[0] @tab IEEE exceptions.  Possible values are
3662 (bitwise or-ed) zero (0, default) no trapping,
3663 @code{GFC_FPE_INVALID} (1), @code{GFC_FPE_DENORMAL} (2),
3664 @code{GFC_FPE_ZERO} (4), @code{GFC_FPE_OVERFLOW} (8),
3665 @code{GFC_FPE_UNDERFLOW} (16), and @code{GFC_FPE_INEXACT} (32).
3666 @end multitable
3668 @item @emph{Example}:
3669 @smallexample
3670 int main (int argc, char *argv[])
3672   /* Initialize libgfortran.  */
3673   _gfortran_set_args (argc, argv);
3674   /* FPE for invalid operations such as SQRT(-1.0).  */
3675   _gfortran_set_fpe (1);
3676   return 0;
3678 @end smallexample
3679 @end table
3682 @node _gfortran_set_max_subrecord_length
3683 @subsection @code{_gfortran_set_max_subrecord_length} --- Set subrecord length
3684 @fnindex _gfortran_set_max_subrecord_length
3685 @cindex libgfortran initialization, set_max_subrecord_length
3687 @table @asis
3688 @item @emph{Description}:
3689 @code{_gfortran_set_max_subrecord_length} set the maximum length
3690 for a subrecord.  This option only makes sense for testing and
3691 debugging of unformatted I/O.
3693 @item @emph{Syntax}:
3694 @code{void _gfortran_set_max_subrecord_length (int val)}
3696 @item @emph{Arguments}:
3697 @multitable @columnfractions .15 .70
3698 @item @var{val} @tab the maximum length for a subrecord;
3699 the maximum permitted value is 2147483639, which is also
3700 the default.
3701 @end multitable
3703 @item @emph{Example}:
3704 @smallexample
3705 int main (int argc, char *argv[])
3707   /* Initialize libgfortran.  */
3708   _gfortran_set_args (argc, argv);
3709   _gfortran_set_max_subrecord_length (8);
3710   return 0;
3712 @end smallexample
3713 @end table
3716 @node Naming and argument-passing conventions
3717 @section Naming and argument-passing conventions
3719 This section gives an overview about the naming convention of procedures
3720 and global variables and about the argument passing conventions used by
3721 GNU Fortran.  If a C binding has been specified, the naming convention
3722 and some of the argument-passing conventions change.  If possible,
3723 mixed-language and mixed-compiler projects should use the better defined
3724 C binding for interoperability.  See @pxref{Interoperability with C}.
3726 @menu
3727 * Naming conventions::
3728 * Argument passing conventions::
3729 @end menu
3732 @node Naming conventions
3733 @subsection Naming conventions
3735 According the Fortran standard, valid Fortran names consist of a letter
3736 between @code{A} to @code{Z}, @code{a} to @code{z}, digits @code{0},
3737 @code{1} to @code{9} and underscores (@code{_}) with the restriction
3738 that names may only start with a letter.  As vendor extension, the
3739 dollar sign (@code{$}) is additionally permitted with the option
3740 @option{-fdollar-ok}, but not as first character and only if the
3741 target system supports it.
3743 By default, the procedure name is the lower-cased Fortran name with an
3744 appended underscore (@code{_}); using @option{-fno-underscoring} no
3745 underscore is appended while @code{-fsecond-underscore} appends two
3746 underscores.  Depending on the target system and the calling convention,
3747 the procedure might be additionally dressed; for instance, on 32bit
3748 Windows with @code{stdcall}, an at-sign @code{@@} followed by an integer
3749 number is appended.  For the changing the calling convention, see
3750 @pxref{GNU Fortran Compiler Directives}.
3752 For common blocks, the same convention is used, i.e. by default an
3753 underscore is appended to the lower-cased Fortran name.  Blank commons
3754 have the name @code{__BLNK__}.
3756 For procedures and variables declared in the specification space of a
3757 module, the name is formed by @code{__}, followed by the lower-cased
3758 module name, @code{_MOD_}, and the lower-cased Fortran name.  Note that
3759 no underscore is appended.
3762 @node Argument passing conventions
3763 @subsection Argument passing conventions
3765 Subroutines do not return a value (matching C99's @code{void}) while
3766 functions either return a value as specified in the platform ABI or
3767 the result variable is passed as hidden argument to the function and
3768 no result is returned.  A hidden result variable is used when the
3769 result variable is an array or of type @code{CHARACTER}.
3771 Arguments are passed according to the platform ABI. In particular,
3772 complex arguments might not be compatible to a struct with two real
3773 components for the real and imaginary part. The argument passing
3774 matches the one of C99's @code{_Complex}.  Functions with scalar
3775 complex result variables return their value and do not use a
3776 by-reference argument.  Note that with the @option{-ff2c} option,
3777 the argument passing is modified and no longer completely matches
3778 the platform ABI.  Some other Fortran compilers use @code{f2c}
3779 semantic by default; this might cause problems with
3780 interoperablility.
3782 GNU Fortran passes most arguments by reference, i.e. by passing a
3783 pointer to the data.  Note that the compiler might use a temporary
3784 variable into which the actual argument has been copied, if required
3785 semantically (copy-in/copy-out).
3787 For arguments with @code{ALLOCATABLE} and @code{POINTER}
3788 attribute (including procedure pointers), a pointer to the pointer
3789 is passed such that the pointer address can be modified in the
3790 procedure.
3792 For dummy arguments with the @code{VALUE} attribute: Scalar arguments
3793 of the type @code{INTEGER}, @code{LOGICAL}, @code{REAL} and
3794 @code{COMPLEX} are passed by value according to the platform ABI.
3795 (As vendor extension and not recommended, using @code{%VAL()} in the
3796 call to a procedure has the same effect.) For @code{TYPE(C_PTR)} and
3797 procedure pointers, the pointer itself is passed such that it can be
3798 modified without affecting the caller.
3799 @c FIXME: Document how VALUE is handled for CHARACTER, TYPE,
3800 @c CLASS and arrays, i.e. whether the copy-in is done in the caller
3801 @c or in the callee.
3803 For Boolean (@code{LOGICAL}) arguments, please note that GCC expects
3804 only the integer value 0 and 1.  If a GNU Fortran @code{LOGICAL}
3805 variable contains another integer value, the result is undefined.
3806 As some other Fortran compilers use @math{-1} for @code{.TRUE.},
3807 extra care has to be taken -- such as passing the value as
3808 @code{INTEGER}.  (The same value restriction also applies to other
3809 front ends of GCC, e.g. to GCC's C99 compiler for @code{_Bool}
3810 or GCC's Ada compiler for @code{Boolean}.)
3812 For arguments of @code{CHARACTER} type, the character length is passed
3813 as a hidden argument at the end of the argument list.  For
3814 deferred-length strings, the value is passed by reference, otherwise
3815 by value.  The character length has the C type @code{size_t} (or
3816 @code{INTEGER(kind=C_SIZE_T)} in Fortran).  Note that this is
3817 different to older versions of the GNU Fortran compiler, where the
3818 type of the hidden character length argument was a C @code{int}.  In
3819 order to retain compatibility with older versions, one can e.g. for
3820 the following Fortran procedure
3822 @smallexample
3823 subroutine fstrlen (s, a)
3824    character(len=*) :: s
3825    integer :: a
3826    print*, len(s)
3827 end subroutine fstrlen
3828 @end smallexample
3830 define the corresponding C prototype as follows:
3832 @smallexample
3833 #if __GNUC__ > 6
3834 typedef size_t fortran_charlen_t;
3835 #else
3836 typedef int fortran_charlen_t;
3837 #endif
3839 void fstrlen_ (char*, int*, fortran_charlen_t);
3840 @end smallexample
3842 In order to avoid such compiler-specific details, for new code it is
3843 instead recommended to use the ISO_C_BINDING feature.
3845 Note with C binding, @code{CHARACTER(len=1)} result variables are
3846 returned according to the platform ABI and no hidden length argument
3847 is used for dummy arguments; with @code{VALUE}, those variables are
3848 passed by value.
3850 For @code{OPTIONAL} dummy arguments, an absent argument is denoted
3851 by a NULL pointer, except for scalar dummy arguments of type
3852 @code{INTEGER}, @code{LOGICAL}, @code{REAL} and @code{COMPLEX}
3853 which have the @code{VALUE} attribute.  For those, a hidden Boolean
3854 argument (@code{logical(kind=C_bool),value}) is used to indicate
3855 whether the argument is present.
3857 Arguments which are assumed-shape, assumed-rank or deferred-rank
3858 arrays or, with @option{-fcoarray=lib}, allocatable scalar coarrays use
3859 an array descriptor.  All other arrays pass the address of the
3860 first element of the array.  With @option{-fcoarray=lib}, the token
3861 and the offset belonging to nonallocatable coarrays dummy arguments
3862 are passed as hidden argument along the character length hidden
3863 arguments.  The token is an oparque pointer identifying the coarray
3864 and the offset is a passed-by-value integer of kind @code{C_PTRDIFF_T},
3865 denoting the byte offset between the base address of the coarray and
3866 the passed scalar or first element of the passed array.
3868 The arguments are passed in the following order
3869 @itemize @bullet
3870 @item Result variable, when the function result is passed by reference
3871 @item Character length of the function result, if it is a of type
3872 @code{CHARACTER} and no C binding is used
3873 @item The arguments in the order in which they appear in the Fortran
3874 declaration
3875 @item The the present status for optional arguments with value attribute,
3876 which are internally passed by value
3877 @item The character length and/or coarray token and offset for the first
3878 argument which is a @code{CHARACTER} or a nonallocatable coarray dummy
3879 argument, followed by the hidden arguments of the next dummy argument
3880 of such a type
3881 @end itemize
3884 @c ---------------------------------------------------------------------
3885 @c Coarray Programming
3886 @c ---------------------------------------------------------------------
3888 @node Coarray Programming
3889 @chapter Coarray Programming
3890 @cindex Coarrays
3892 @menu
3893 * Type and enum ABI Documentation::
3894 * Function ABI Documentation::
3895 @end menu
3898 @node Type and enum ABI Documentation
3899 @section Type and enum ABI Documentation
3901 @menu
3902 * caf_token_t::
3903 * caf_register_t::
3904 * caf_deregister_t::
3905 * caf_reference_t::
3906 @end menu
3908 @node caf_token_t
3909 @subsection @code{caf_token_t}
3911 Typedef of type @code{void *} on the compiler side. Can be any data
3912 type on the library side.
3914 @node caf_register_t
3915 @subsection @code{caf_register_t}
3917 Indicates which kind of coarray variable should be registered.
3919 @verbatim
3920 typedef enum caf_register_t {
3921   CAF_REGTYPE_COARRAY_STATIC,
3922   CAF_REGTYPE_COARRAY_ALLOC,
3923   CAF_REGTYPE_LOCK_STATIC,
3924   CAF_REGTYPE_LOCK_ALLOC,
3925   CAF_REGTYPE_CRITICAL,
3926   CAF_REGTYPE_EVENT_STATIC,
3927   CAF_REGTYPE_EVENT_ALLOC,
3928   CAF_REGTYPE_COARRAY_ALLOC_REGISTER_ONLY,
3929   CAF_REGTYPE_COARRAY_ALLOC_ALLOCATE_ONLY
3931 caf_register_t;
3932 @end verbatim
3934 The values @code{CAF_REGTYPE_COARRAY_ALLOC_REGISTER_ONLY} and
3935 @code{CAF_REGTYPE_COARRAY_ALLOC_ALLOCATE_ONLY} are for allocatable components
3936 in derived type coarrays only.  The first one sets up the token without
3937 allocating memory for allocatable component.  The latter one only allocates the
3938 memory for an allocatable component in a derived type coarray.  The token
3939 needs to be setup previously by the REGISTER_ONLY.  This allows to have
3940 allocatable components un-allocated on some images.  The status whether an
3941 allocatable component is allocated on a remote image can be queried by
3942 @code{_caf_is_present} which used internally by the @code{ALLOCATED}
3943 intrinsic.
3945 @node caf_deregister_t
3946 @subsection @code{caf_deregister_t}
3948 @verbatim
3949 typedef enum caf_deregister_t {
3950   CAF_DEREGTYPE_COARRAY_DEREGISTER,
3951   CAF_DEREGTYPE_COARRAY_DEALLOCATE_ONLY
3953 caf_deregister_t;
3954 @end verbatim
3956 Allows to specifiy the type of deregistration of a coarray object.  The
3957 @code{CAF_DEREGTYPE_COARRAY_DEALLOCATE_ONLY} flag is only allowed for
3958 allocatable components in derived type coarrays.
3960 @node caf_reference_t
3961 @subsection @code{caf_reference_t}
3963 The structure used for implementing arbitrary reference chains.
3964 A @code{CAF_REFERENCE_T} allows to specify a component reference or any kind
3965 of array reference of any rank supported by gfortran.  For array references all
3966 kinds as known by the compiler/Fortran standard are supported indicated by
3967 a @code{MODE}.
3969 @verbatim
3970 typedef enum caf_ref_type_t {
3971   /* Reference a component of a derived type, either regular one or an
3972      allocatable or pointer type.  For regular ones idx in caf_reference_t is
3973      set to -1.  */
3974   CAF_REF_COMPONENT,
3975   /* Reference an allocatable array.  */
3976   CAF_REF_ARRAY,
3977   /* Reference a non-allocatable/non-pointer array.  I.e., the coarray object
3978      has no array descriptor associated and the addressing is done
3979      completely using the ref.  */
3980   CAF_REF_STATIC_ARRAY
3981 } caf_ref_type_t;
3982 @end verbatim
3984 @verbatim
3985 typedef enum caf_array_ref_t {
3986   /* No array ref.  This terminates the array ref.  */
3987   CAF_ARR_REF_NONE = 0,
3988   /* Reference array elements given by a vector.  Only for this mode
3989      caf_reference_t.u.a.dim[i].v is valid.  */
3990   CAF_ARR_REF_VECTOR,
3991   /* A full array ref (:).  */
3992   CAF_ARR_REF_FULL,
3993   /* Reference a range on elements given by start, end and stride.  */
3994   CAF_ARR_REF_RANGE,
3995   /* Only a single item is referenced given in the start member.  */
3996   CAF_ARR_REF_SINGLE,
3997   /* An array ref of the kind (i:), where i is an arbitrary valid index in the
3998      array.  The index i is given in the start member.  */
3999   CAF_ARR_REF_OPEN_END,
4000   /* An array ref of the kind (:i), where the lower bound of the array ref
4001      is given by the remote side.  The index i is given in the end member.  */
4002   CAF_ARR_REF_OPEN_START
4003 } caf_array_ref_t;
4004 @end verbatim
4006 @verbatim
4007 /* References to remote components of a derived type.  */
4008 typedef struct caf_reference_t {
4009   /* A pointer to the next ref or NULL.  */
4010   struct caf_reference_t *next;
4011   /* The type of the reference.  */
4012   /* caf_ref_type_t, replaced by int to allow specification in fortran FE.  */
4013   int type;
4014   /* The size of an item referenced in bytes.  I.e. in an array ref this is
4015      the factor to advance the array pointer with to get to the next item.
4016      For component refs this gives just the size of the element referenced.  */
4017   size_t item_size;
4018   union {
4019     struct {
4020       /* The offset (in bytes) of the component in the derived type.
4021          Unused for allocatable or pointer components.  */
4022       ptrdiff_t offset;
4023       /* The offset (in bytes) to the caf_token associated with this
4024          component.  NULL, when not allocatable/pointer ref.  */
4025       ptrdiff_t caf_token_offset;
4026     } c;
4027     struct {
4028       /* The mode of the array ref.  See CAF_ARR_REF_*.  */
4029       /* caf_array_ref_t, replaced by unsigend char to allow specification in
4030          fortran FE.  */
4031      unsigned char mode[GFC_MAX_DIMENSIONS];
4032       /* The type of a static array.  Unset for array's with descriptors.  */
4033       int static_array_type;
4034       /* Subscript refs (s) or vector refs (v).  */
4035       union {
4036         struct {
4037           /* The start and end boundary of the ref and the stride.  */
4038           index_type start, end, stride;
4039         } s;
4040         struct {
4041           /* nvec entries of kind giving the elements to reference.  */
4042           void *vector;
4043           /* The number of entries in vector.  */
4044           size_t nvec;
4045           /* The integer kind used for the elements in vector.  */
4046           int kind;
4047         } v;
4048       } dim[GFC_MAX_DIMENSIONS];
4049     } a;
4050   } u;
4051 } caf_reference_t;
4052 @end verbatim
4054 The references make up a single linked list of reference operations.  The
4055 @code{NEXT} member links to the next reference or NULL to indicate the end of
4056 the chain.  Component and array refs can be arbitrarly mixed as long as they
4057 comply to the Fortran standard.
4059 @emph{NOTES}
4060 The member @code{STATIC_ARRAY_TYPE} is used only when the @code{TYPE} is
4061 @code{CAF_REF_STATIC_ARRAY}.  The member gives the type of the data referenced.
4062 Because no array descriptor is available for a descriptor-less array and
4063 type conversion still needs to take place the type is transported here.
4065 At the moment @code{CAF_ARR_REF_VECTOR} is not implemented in the front end for
4066 descriptor-less arrays.  The library caf_single has untested support for it.
4069 @node Function ABI Documentation
4070 @section Function ABI Documentation
4072 @menu
4073 * _gfortran_caf_init:: Initialiation function
4074 * _gfortran_caf_finish:: Finalization function
4075 * _gfortran_caf_this_image:: Querying the image number
4076 * _gfortran_caf_num_images:: Querying the maximal number of images
4077 * _gfortran_caf_register:: Registering coarrays
4078 * _gfortran_caf_deregister:: Deregistering coarrays
4079 * _gfortran_caf_is_present:: Query whether an allocatable component in a derived type coarray is allocated
4080 * _gfortran_caf_send:: Sending data from a local image to a remote image
4081 * _gfortran_caf_get:: Getting data from a remote image
4082 * _gfortran_caf_sendget:: Sending data between remote images
4083 * _gfortran_caf_send_by_ref:: Sending data from a local image to a remote image using enhanced references
4084 * _gfortran_caf_get_by_ref:: Getting data from a remote image using enhanced references
4085 * _gfortran_caf_sendget_by_ref:: Sending data between remote images using enhanced references
4086 * _gfortran_caf_lock:: Locking a lock variable
4087 * _gfortran_caf_unlock:: Unlocking a lock variable
4088 * _gfortran_caf_event_post:: Post an event
4089 * _gfortran_caf_event_wait:: Wait that an event occurred
4090 * _gfortran_caf_event_query:: Query event count
4091 * _gfortran_caf_sync_all:: All-image barrier
4092 * _gfortran_caf_sync_images:: Barrier for selected images
4093 * _gfortran_caf_sync_memory:: Wait for completion of segment-memory operations
4094 * _gfortran_caf_error_stop:: Error termination with exit code
4095 * _gfortran_caf_error_stop_str:: Error termination with string
4096 * _gfortran_caf_atomic_define:: Atomic variable assignment
4097 * _gfortran_caf_atomic_ref:: Atomic variable reference
4098 * _gfortran_caf_atomic_cas:: Atomic compare and swap
4099 * _gfortran_caf_atomic_op:: Atomic operation
4100 * _gfortran_caf_co_broadcast:: Sending data to all images
4101 * _gfortran_caf_co_max:: Collective maximum reduction
4102 * _gfortran_caf_co_min:: Collective minimum reduction
4103 * _gfortran_caf_co_sum:: Collective summing reduction
4104 * _gfortran_caf_co_reduce:: Generic collective reduction
4105 @end menu
4108 @node _gfortran_caf_init
4109 @subsection @code{_gfortran_caf_init} --- Initialiation function
4110 @cindex Coarray, _gfortran_caf_init
4112 @table @asis
4113 @item @emph{Description}:
4114 This function is called at startup of the program before the Fortran main
4115 program, if the latter has been compiled with @option{-fcoarray=lib}.
4116 It takes as arguments the command-line arguments of the program.  It is
4117 permitted to pass to @code{NULL} pointers as argument; if non-@code{NULL},
4118 the library is permitted to modify the arguments.
4120 @item @emph{Syntax}:
4121 @code{void _gfortran_caf_init (int *argc, char ***argv)}
4123 @item @emph{Arguments}:
4124 @multitable @columnfractions .15 .70
4125 @item @var{argc} @tab intent(inout) An integer pointer with the number of
4126 arguments passed to the program or @code{NULL}.
4127 @item @var{argv} @tab intent(inout) A pointer to an array of strings with the
4128 command-line arguments or @code{NULL}.
4129 @end multitable
4131 @item @emph{NOTES}
4132 The function is modelled after the initialization function of the Message
4133 Passing Interface (MPI) specification.  Due to the way coarray registration
4134 works, it might not be the first call to the libaray.  If the main program is
4135 not written in Fortran and only a library uses coarrays, it can happen that
4136 this function is never called.  Therefore, it is recommended that the library
4137 does not rely on the passed arguments and whether the call has been done.
4138 @end table
4141 @node _gfortran_caf_finish
4142 @subsection @code{_gfortran_caf_finish} --- Finalization function
4143 @cindex Coarray, _gfortran_caf_finish
4145 @table @asis
4146 @item @emph{Description}:
4147 This function is called at the end of the Fortran main program, if it has
4148 been compiled with the @option{-fcoarray=lib} option.
4150 @item @emph{Syntax}:
4151 @code{void _gfortran_caf_finish (void)}
4153 @item @emph{NOTES}
4154 For non-Fortran programs, it is recommended to call the function at the end
4155 of the main program.  To ensure that the shutdown is also performed for
4156 programs where this function is not explicitly invoked, for instance
4157 non-Fortran programs or calls to the system's exit() function, the library
4158 can use a destructor function.  Note that programs can also be terminated
4159 using the STOP and ERROR STOP statements; those use different library calls.
4160 @end table
4163 @node _gfortran_caf_this_image
4164 @subsection @code{_gfortran_caf_this_image} --- Querying the image number
4165 @cindex Coarray, _gfortran_caf_this_image
4167 @table @asis
4168 @item @emph{Description}:
4169 This function returns the current image number, which is a positive number.
4171 @item @emph{Syntax}:
4172 @code{int _gfortran_caf_this_image (int distance)}
4174 @item @emph{Arguments}:
4175 @multitable @columnfractions .15 .70
4176 @item @var{distance} @tab As specified for the @code{this_image} intrinsic
4177 in TS18508. Shall be a nonnegative number.
4178 @end multitable
4180 @item @emph{NOTES}
4181 If the Fortran intrinsic @code{this_image} is invoked without an argument, which
4182 is the only permitted form in Fortran 2008, GCC passes @code{0} as
4183 first argument.
4184 @end table
4187 @node _gfortran_caf_num_images
4188 @subsection @code{_gfortran_caf_num_images} --- Querying the maximal number of images
4189 @cindex Coarray, _gfortran_caf_num_images
4191 @table @asis
4192 @item @emph{Description}:
4193 This function returns the number of images in the current team, if
4194 @var{distance} is 0 or the number of images in the parent team at the specified
4195 distance. If failed is -1, the function returns the number of all images at
4196 the specified distance; if it is 0, the function returns the number of
4197 nonfailed images, and if it is 1, it returns the number of failed images.
4199 @item @emph{Syntax}:
4200 @code{int _gfortran_caf_num_images(int distance, int failed)}
4202 @item @emph{Arguments}:
4203 @multitable @columnfractions .15 .70
4204 @item @var{distance} @tab the distance from this image to the ancestor.
4205 Shall be positive.
4206 @item @var{failed} @tab shall be -1, 0, or 1
4207 @end multitable
4209 @item @emph{NOTES}
4210 This function follows TS18508. If the num_image intrinsic has no arguments,
4211 the the compiler passes @code{distance=0} and @code{failed=-1} to the function.
4212 @end table
4215 @node _gfortran_caf_register
4216 @subsection @code{_gfortran_caf_register} --- Registering coarrays
4217 @cindex Coarray, _gfortran_caf_register
4219 @table @asis
4220 @item @emph{Description}:
4221 Registers memory for a coarray and creates a token to identify the coarray.  The
4222 routine is called for both coarrays with @code{SAVE} attribute and using an
4223 explicit @code{ALLOCATE} statement.  If an error occurs and @var{STAT} is a
4224 @code{NULL} pointer, the function shall abort with printing an error message
4225 and starting the error termination.  If no error occurs and @var{STAT} is
4226 present, it shall be set to zero.  Otherwise, it shall be set to a positive
4227 value and, if not-@code{NULL}, @var{ERRMSG} shall be set to a string describing
4228 the failure.  The routine shall register the memory provided in the
4229 @code{DATA}-component of the array descriptor @var{DESC}, when that component
4230 is non-@code{NULL}, else it shall allocate sufficient memory and provide a
4231 pointer to it in the @code{DATA}-component of @var{DESC}.  The array descriptor
4232 has rank zero, when a scalar object is to be registered and the array
4233 descriptor may be invalid after the call to @code{_gfortran_caf_register}.
4234 When an array is to be allocated the descriptor persists.
4236 For @code{CAF_REGTYPE_COARRAY_STATIC} and @code{CAF_REGTYPE_COARRAY_ALLOC},
4237 the passed size is the byte size requested.  For @code{CAF_REGTYPE_LOCK_STATIC},
4238 @code{CAF_REGTYPE_LOCK_ALLOC} and @code{CAF_REGTYPE_CRITICAL} it is the array
4239 size or one for a scalar.
4242 @item @emph{Syntax}:
4243 @code{void caf_register (size_t size, caf_register_t type, caf_token_t *token,
4244 gfc_descriptor_t *desc, int *stat, char *errmsg, int errmsg_len)}
4246 @item @emph{Arguments}:
4247 @multitable @columnfractions .15 .70
4248 @item @var{size} @tab For normal coarrays, the byte size of the coarray to be
4249 allocated; for lock types and event types, the number of elements.
4250 @item @var{type} @tab one of the caf_register_t types.
4251 @item @var{token} @tab intent(out) An opaque pointer identifying the coarray.
4252 @item @var{desc} @tab intent(inout) The (pseudo) array descriptor.
4253 @item @var{stat} @tab intent(out) For allocatable coarrays, stores the STAT=;
4254 may be NULL
4255 @item @var{errmsg} @tab intent(out) When an error occurs, this will be set to
4256 an error message; may be NULL
4257 @item @var{errmsg_len} @tab the buffer size of errmsg.
4258 @end multitable
4260 @item @emph{NOTES}
4261 Nonalloatable coarrays have to be registered prior use from remote images.
4262 In order to guarantee this, they have to be registered before the main
4263 program. This can be achieved by creating constructor functions. That is what
4264 GCC does such that also nonallocatable coarrays the memory is allocated and no
4265 static memory is used.  The token permits to identify the coarray; to the
4266 processor, the token is a nonaliasing pointer. The library can, for instance,
4267 store the base address of the coarray in the token, some handle or a more
4268 complicated struct.  The library may also store the array descriptor
4269 @var{DESC} when its rank is non-zero.
4271 For lock types, the value shall only used for checking the allocation
4272 status. Note that for critical blocks, the locking is only required on one
4273 image; in the locking statement, the processor shall always pass an
4274 image index of one for critical-block lock variables
4275 (@code{CAF_REGTYPE_CRITICAL}). For lock types and critical-block variables,
4276 the initial value shall be unlocked (or, respecitively, not in critical
4277 section) such as the value false; for event types, the initial state should
4278 be no event, e.g. zero.
4279 @end table
4282 @node _gfortran_caf_deregister
4283 @subsection @code{_gfortran_caf_deregister} --- Deregistering coarrays
4284 @cindex Coarray, _gfortran_caf_deregister
4286 @table @asis
4287 @item @emph{Description}:
4288 Called to free the memory of a coarray; the processor calls this function for
4289 automatic and explicit deallocation.  In case of an error, this function shall
4290 fail with an error message, unless the @var{STAT} variable is not null.  The
4291 library is only expected to free memory it allocated itself during a call to
4292 @code{_gfortran_caf_register}.
4294 @item @emph{Syntax}:
4295 @code{void caf_deregister (caf_token_t *token, caf_deregister_t type,
4296 int *stat, char *errmsg, int errmsg_len)}
4298 @item @emph{Arguments}:
4299 @multitable @columnfractions .15 .70
4300 @item @var{token} @tab the token to free.
4301 @item @var{type} @tab the type of action to take for the coarray.  A
4302 @code{CAF_DEREGTYPE_COARRAY_DEALLOCATE_ONLY} is allowed only for allocatable
4303 components of derived type coarrays.  The action only deallocates the local
4304 memory without deleting the token.
4305 @item @var{stat} @tab intent(out) Stores the STAT=; may be NULL
4306 @item @var{errmsg} @tab intent(out) When an error occurs, this will be set
4307 to an error message; may be NULL
4308 @item @var{errmsg_len} @tab the buffer size of errmsg.
4309 @end multitable
4311 @item @emph{NOTES}
4312 For nonalloatable coarrays this function is never called.  If a cleanup is
4313 required, it has to be handled via the finish, stop and error stop functions,
4314 and via destructors.
4315 @end table
4318 @node _gfortran_caf_is_present
4319 @subsection @code{_gfortran_caf_is_present} --- Query whether an allocatable component in a derived type coarray is allocated
4320 @cindex Coarray, _gfortran_caf_is_present
4322 @table @asis
4323 @item @emph{Description}:
4324 Used to query the coarray library whether an allocatable component in a derived
4325 type coarray is allocated on a remote image.
4327 @item @emph{Syntax}:
4328 @code{void _gfortran_caf_is_present (caf_token_t token, int image_index,
4329 gfc_reference_t *ref)}
4331 @item @emph{Arguments}:
4332 @multitable @columnfractions .15 .70
4333 @item @var{token} @tab An opaque pointer identifying the coarray.
4334 @item @var{image_index} @tab The ID of the remote image; must be a positive
4335 number.
4336 @item @var{ref} @tab A chain of references to address the allocatable component
4337 in the derived type coarray.  The object reffed needs to be a scalar or a full
4338 array ref, respectively.
4339 @end multitable
4341 @end table
4343 @node _gfortran_caf_send
4344 @subsection @code{_gfortran_caf_send} --- Sending data from a local image to a remote image
4345 @cindex Coarray, _gfortran_caf_send
4347 @table @asis
4348 @item @emph{Description}:
4349 Called to send a scalar, an array section or whole array from a local
4350 to a remote image identified by the image_index.
4352 @item @emph{Syntax}:
4353 @code{void _gfortran_caf_send (caf_token_t token, size_t offset,
4354 int image_index, gfc_descriptor_t *dest, caf_vector_t *dst_vector,
4355 gfc_descriptor_t *src, int dst_kind, int src_kind, bool may_require_tmp)}
4357 @item @emph{Arguments}:
4358 @multitable @columnfractions .15 .70
4359 @item @var{token} @tab intent(in)  An opaque pointer identifying the coarray.
4360 @item @var{offset} @tab By which amount of bytes the actual data is shifted
4361 compared to the base address of the coarray.
4362 @item @var{image_index} @tab The ID of the remote image; must be a positive
4363 number.
4364 @item @var{dest} @tab intent(in) Array descriptor for the remote image for the
4365 bounds and the size. The base_addr shall not be accessed.
4366 @item @var{dst_vector} @tab intent(in)  If not NULL, it contains the vector
4367 subscript of the destination array; the values are relative to the dimension
4368 triplet of the dest argument.
4369 @item @var{src} @tab intent(in) Array descriptor of the local array to be
4370 transferred to the remote image
4371 @item @var{dst_kind} @tab Kind of the destination argument
4372 @item @var{src_kind} @tab Kind of the source argument
4373 @item @var{may_require_tmp} @tab The variable is false it is known at compile
4374 time that the @var{dest} and @var{src} either cannot overlap or overlap (fully
4375 or partially) such that walking @var{src} and @var{dest} in element wise
4376 element order (honoring the stride value) will not lead to wrong results.
4377 Otherwise, the value is true.
4378 @end multitable
4380 @item @emph{NOTES}
4381 It is permitted to have image_id equal the current image; the memory of the
4382 send-to and the send-from might (partially) overlap in that case. The
4383 implementation has to take care that it handles this case, e.g. using
4384 @code{memmove} which handles (partially) overlapping memory. If
4385 @var{may_require_tmp} is true, the library might additionally create a
4386 temporary variable, unless additional checks show that this is not required
4387 (e.g. because walking backward is possible or because both arrays are
4388 contiguous and @code{memmove} takes care of overlap issues).
4390 Note that the assignment of a scalar to an array is permitted. In addition,
4391 the library has to handle numeric-type conversion and for strings, padding
4392 and different character kinds.
4393 @end table
4396 @node _gfortran_caf_get
4397 @subsection @code{_gfortran_caf_get} --- Getting data from a remote image
4398 @cindex Coarray, _gfortran_caf_get
4400 @table @asis
4401 @item @emph{Description}:
4402 Called to get an array section or whole array from a a remote,
4403 image identified by the image_index.
4405 @item @emph{Syntax}:
4406 @code{void _gfortran_caf_get (caf_token_t token, size_t offset,
4407 int image_index, gfc_descriptor_t *src, caf_vector_t *src_vector,
4408 gfc_descriptor_t *dest, int src_kind, int dst_kind, bool may_require_tmp)}
4410 @item @emph{Arguments}:
4411 @multitable @columnfractions .15 .70
4412 @item @var{token} @tab intent(in)  An opaque pointer identifying the coarray.
4413 @item @var{offset} @tab By which amount of bytes the actual data is shifted
4414 compared to the base address of the coarray.
4415 @item @var{image_index} @tab The ID of the remote image; must be a positive
4416 number.
4417 @item @var{dest} @tab intent(out) Array descriptor of the local array to store
4418 the data transferred from the remote image
4419 @item @var{src} @tab intent(in) Array descriptor for the remote image for the
4420 bounds and the size. The base_addr shall not be accessed.
4421 @item @var{src_vector} @tab intent(in)  If not NULL, it contains the vector
4422 subscript of the source array; the values are relative to the dimension
4423 triplet of the src argument.
4424 @item @var{dst_kind} @tab Kind of the destination argument
4425 @item @var{src_kind} @tab Kind of the source argument
4426 @item @var{may_require_tmp} @tab The variable is false it is known at compile
4427 time that the @var{dest} and @var{src} either cannot overlap or overlap (fully
4428 or partially) such that walking @var{src} and @var{dest} in element wise
4429 element order (honoring the stride value) will not lead to wrong results.
4430 Otherwise, the value is true.
4431 @end multitable
4433 @item @emph{NOTES}
4434 It is permitted to have image_id equal the current image; the memory of the
4435 send-to and the send-from might (partially) overlap in that case. The
4436 implementation has to take care that it handles this case, e.g. using
4437 @code{memmove} which handles (partially) overlapping memory. If
4438 @var{may_require_tmp} is true, the library might additionally create a
4439 temporary variable, unless additional checks show that this is not required
4440 (e.g. because walking backward is possible or because both arrays are
4441 contiguous and @code{memmove} takes care of overlap issues).
4443 Note that the library has to handle numeric-type conversion and for strings,
4444 padding and different character kinds.
4445 @end table
4448 @node _gfortran_caf_sendget
4449 @subsection @code{_gfortran_caf_sendget} --- Sending data between remote images
4450 @cindex Coarray, _gfortran_caf_sendget
4452 @table @asis
4453 @item @emph{Description}:
4454 Called to send a scalar, an array section or whole array from a remote image
4455 identified by the src_image_index to a remote image identified by the
4456 dst_image_index.
4458 @item @emph{Syntax}:
4459 @code{void _gfortran_caf_sendget (caf_token_t dst_token, size_t dst_offset,
4460 int dst_image_index, gfc_descriptor_t *dest, caf_vector_t *dst_vector,
4461 caf_token_t src_token, size_t src_offset, int src_image_index,
4462 gfc_descriptor_t *src, caf_vector_t *src_vector, int dst_kind, int src_kind,
4463 bool may_require_tmp)}
4465 @item @emph{Arguments}:
4466 @multitable @columnfractions .15 .70
4467 @item @var{dst_token} @tab intent(in)  An opaque pointer identifying the
4468 destination coarray.
4469 @item @var{dst_offset} @tab  By which amount of bytes the actual data is
4470 shifted compared to the base address of the destination coarray.
4471 @item @var{dst_image_index} @tab The ID of the destination remote image; must
4472 be a positive number.
4473 @item @var{dest} @tab intent(in) Array descriptor for the destination
4474 remote image for the bounds and the size. The base_addr shall not be accessed.
4475 @item @var{dst_vector} @tab intent(int)  If not NULL, it contains the vector
4476 subscript of the destination array; the values are relative to the dimension
4477 triplet of the dest argument.
4478 @item @var{src_token} @tab An opaque pointer identifying the source coarray.
4479 @item @var{src_offset} @tab By which amount of bytes the actual data is shifted
4480 compared to the base address of the source coarray.
4481 @item @var{src_image_index} @tab The ID of the source remote image; must be a
4482 positive number.
4483 @item @var{src} @tab intent(in) Array descriptor of the local array to be
4484 transferred to the remote image.
4485 @item @var{src_vector} @tab intent(in) Array descriptor of the local array to
4486 be transferred to the remote image
4487 @item @var{dst_kind} @tab Kind of the destination argument
4488 @item @var{src_kind} @tab Kind of the source argument
4489 @item @var{may_require_tmp} @tab The variable is false it is known at compile
4490 time that the @var{dest} and @var{src} either cannot overlap or overlap (fully
4491 or partially) such that walking @var{src} and @var{dest} in element wise
4492 element order (honoring the stride value) will not lead to wrong results.
4493 Otherwise, the value is true.
4494 @end multitable
4496 @item @emph{NOTES}
4497 It is permitted to have image_ids equal; the memory of the send-to and the
4498 send-from might (partially) overlap in that case. The implementation has to
4499 take care that it handles this case, e.g. using @code{memmove} which handles
4500 (partially) overlapping memory. If @var{may_require_tmp} is true, the library
4501 might additionally create a temporary variable, unless additional checks show
4502 that this is not required (e.g. because walking backward is possible or because
4503 both arrays are contiguous and @code{memmove} takes care of overlap issues).
4505 Note that the assignment of a scalar to an array is permitted. In addition,
4506 the library has to handle numeric-type conversion and for strings, padding and
4507 different character kinds.
4508 @end table
4510 @node _gfortran_caf_send_by_ref
4511 @subsection @code{_gfortran_caf_send_by_ref} --- Sending data from a local image to a remote image with enhanced referencing options
4512 @cindex Coarray, _gfortran_caf_send_by_ref
4514 @table @asis
4515 @item @emph{Description}:
4516 Called to send a scalar, an array section or whole array from a local to a
4517 remote image identified by the image_index.
4519 @item @emph{Syntax}:
4520 @code{void _gfortran_caf_send_by_ref (caf_token_t token, int image_index,
4521 gfc_descriptor_t *src, caf_reference_t *refs, int dst_kind, int src_kind,
4522 bool may_require_tmp, bool dst_reallocatable, int *stat)}
4524 @item @emph{Arguments}:
4525 @multitable @columnfractions .15 .70
4526 @item @var{token} @tab intent(in)  An opaque pointer identifying the coarray.
4527 @item @var{image_index} @tab The ID of the remote image; must be a positive
4528 number.
4529 @item @var{src} @tab intent(in) Array descriptor of the local array to be
4530 transferred to the remote image
4531 @item @var{refs} @tab intent(in) the references on the remote array to store
4532 the data given by src.  Guaranteed to have at least one entry.
4533 @item @var{dst_kind} @tab Kind of the destination argument
4534 @item @var{src_kind} @tab Kind of the source argument
4535 @item @var{may_require_tmp} @tab The variable is false it is known at compile
4536 time that the @var{dest} and @var{src} either cannot overlap or overlap (fully
4537 or partially) such that walking @var{src} and @var{dest} in element wise
4538 element order (honoring the stride value) will not lead to wrong results.
4539 Otherwise, the value is true.
4540 @item @var{dst_reallocatable} @tab set when the destination is of allocatable
4541 or pointer type and the refs will allow reallocation, i.e., the ref is a full
4542 array or component ref.
4543 @item @var{stat} @tab intent(out) when non-@code{NULL} give the result of the
4544 operation, i.e., zero on success and non-zero on error.  When @code{NULL} and
4545 error occurs, then an error message is printed and the program is terminated.
4546 @end multitable
4548 @item @emph{NOTES}
4549 It is permitted to have image_id equal the current image; the memory of the
4550 send-to and the send-from might (partially) overlap in that case.  The
4551 implementation has to take care that it handles this case, e.g. using
4552 @code{memmove} which handles (partially) overlapping memory.  If
4553 @var{may_require_tmp} is true, the library might additionally create a
4554 temporary variable, unless additional checks show that this is not required
4555 (e.g. because walking backward is possible or because both arrays are
4556 contiguous and @code{memmove} takes care of overlap issues).
4558 Note that the assignment of a scalar to an array is permitted.  In addition,
4559 the library has to handle numeric-type conversion and for strings, padding
4560 and different character kinds.
4562 Because of the more complicated references possible some operations may be
4563 unsupported by certain libraries.  The library is expected to issue a precise
4564 error message why the operation is not permitted.
4565 @end table
4568 @node _gfortran_caf_get_by_ref
4569 @subsection @code{_gfortran_caf_get_by_ref} --- Getting data from a remote image using enhanced references
4570 @cindex Coarray, _gfortran_caf_get_by_ref
4572 @table @asis
4573 @item @emph{Description}:
4574 Called to get a scalar, an array section or whole array from a a remote image
4575 identified by the image_index.
4577 @item @emph{Syntax}:
4578 @code{void _gfortran_caf_get_by_ref (caf_token_t token, int image_index,
4579 caf_reference_t *refs, gfc_descriptor_t *dst, int dst_kind, int src_kind,
4580 bool may_require_tmp, bool dst_reallocatable, int *stat)}
4582 @item @emph{Arguments}:
4583 @multitable @columnfractions .15 .70
4584 @item @var{token} @tab intent(in)  An opaque pointer identifying the coarray.
4585 @item @var{image_index} @tab The ID of the remote image; must be a positive
4586 number.
4587 @item @var{refs} @tab intent(in) the references to apply to the remote structure
4588 to get the data.
4589 @item @var{dst} @tab intent(in) Array descriptor of the local array to store
4590 the data transferred from the remote image.  May be reallocated where needed
4591 and when @var{DST_REALLOCATABLE} allows it.
4592 @item @var{dst_kind} @tab Kind of the destination argument
4593 @item @var{src_kind} @tab Kind of the source argument
4594 @item @var{may_require_tmp} @tab The variable is false it is known at compile
4595 time that the @var{dest} and @var{src} either cannot overlap or overlap (fully
4596 or partially) such that walking @var{src} and @var{dest} in element wise
4597 element order (honoring the stride value) will not lead to wrong results.
4598 Otherwise, the value is true.
4599 @item @var{dst_reallocatable} @tab set when @var{DST} is of allocatable
4600 or pointer type and its refs allow reallocation, i.e., the full array or a
4601 component is referenced.
4602 @item @var{stat} @tab intent(out) when non-@code{NULL} give the result of the
4603 operation, i.e., zero on success and non-zero on error.  When @code{NULL} and
4604 error occurs, then an error message is printed and the program is terminated.
4605 @end multitable
4607 @item @emph{NOTES}
4608 It is permitted to have image_id equal the current image; the memory of the
4609 send-to and the send-from might (partially) overlap in that case.  The
4610 implementation has to take care that it handles this case, e.g. using
4611 @code{memmove} which handles (partially) overlapping memory.  If
4612 @var{may_require_tmp} is true, the library might additionally create a
4613 temporary variable, unless additional checks show that this is not required
4614 (e.g. because walking backward is possible or because both arrays are
4615 contiguous and @code{memmove} takes care of overlap issues).
4617 Note that the library has to handle numeric-type conversion and for strings,
4618 padding and different character kinds.
4620 Because of the more complicated references possible some operations may be
4621 unsupported by certain libraries.  The library is expected to issue a precise
4622 error message why the operation is not permitted.
4623 @end table
4626 @node _gfortran_caf_sendget_by_ref
4627 @subsection @code{_gfortran_caf_sendget_by_ref} --- Sending data between remote images using enhanced references on both sides
4628 @cindex Coarray, _gfortran_caf_sendget_by_ref
4630 @table @asis
4631 @item @emph{Description}:
4632 Called to send a scalar, an array section or whole array from a remote image
4633 identified by the src_image_index to a remote image identified by the
4634 dst_image_index.
4636 @item @emph{Syntax}:
4637 @code{void _gfortran_caf_sendget_by_ref (caf_token_t dst_token,
4638 int dst_image_index, caf_reference_t *dst_refs,
4639 caf_token_t src_token, int src_image_index, caf_reference_t *src_refs,
4640 int dst_kind, int src_kind, bool may_require_tmp, int *dst_stat, int *src_stat)}
4642 @item @emph{Arguments}:
4643 @multitable @columnfractions .15 .70
4644 @item @var{dst_token} @tab intent(in)  An opaque pointer identifying the
4645 destination coarray.
4646 @item @var{dst_image_index} @tab The ID of the destination remote image; must
4647 be a positive number.
4648 @item @var{dst_refs} @tab intent(in) the references on the remote array to store
4649 the data given by src.  Guaranteed to have at least one entry.
4650 @item @var{src_token} @tab An opaque pointer identifying the source coarray.
4651 @item @var{src_image_index} @tab The ID of the source remote image; must be a
4652 positive number.
4653 @item @var{src_refs} @tab intent(in) the references to apply to the remote
4654 structure to get the data.
4655 @item @var{dst_kind} @tab Kind of the destination argument
4656 @item @var{src_kind} @tab Kind of the source argument
4657 @item @var{may_require_tmp} @tab The variable is false it is known at compile
4658 time that the @var{dest} and @var{src} either cannot overlap or overlap (fully
4659 or partially) such that walking @var{src} and @var{dest} in element wise
4660 element order (honoring the stride value) will not lead to wrong results.
4661 Otherwise, the value is true.
4662 @item @var{dst_stat} @tab intent(out) when non-@code{NULL} give the result of
4663 the send-operation, i.e., zero on success and non-zero on error.  When
4664 @code{NULL} and an error occurs, then an error message is printed and the
4665 program is terminated.
4666 @item @var{src_stat} @tab intent(out) when non-@code{NULL} give the result of
4667 the get-operation, i.e., zero on success and non-zero on error.  When
4668 @code{NULL} and an error occurs, then an error message is printed and the
4669 program is terminated.
4670 @end multitable
4672 @item @emph{NOTES}
4673 It is permitted to have image_ids equal; the memory of the send-to and the
4674 send-from might (partially) overlap in that case.  The implementation has to
4675 take care that it handles this case, e.g. using @code{memmove} which handles
4676 (partially) overlapping memory.  If @var{may_require_tmp} is true, the library
4677 might additionally create a temporary variable, unless additional checks show
4678 that this is not required (e.g. because walking backward is possible or because
4679 both arrays are contiguous and @code{memmove} takes care of overlap issues).
4681 Note that the assignment of a scalar to an array is permitted.  In addition,
4682 the library has to handle numeric-type conversion and for strings, padding and
4683 different character kinds.
4685 Because of the more complicated references possible some operations may be
4686 unsupported by certain libraries.  The library is expected to issue a precise
4687 error message why the operation is not permitted.
4688 @end table
4691 @node _gfortran_caf_lock
4692 @subsection @code{_gfortran_caf_lock} --- Locking a lock variable
4693 @cindex Coarray, _gfortran_caf_lock
4695 @table @asis
4696 @item @emph{Description}:
4697 Acquire a lock on the given image on a scalar locking variable or for the
4698 given array element for an array-valued variable. If the @var{aquired_lock}
4699 is @code{NULL}, the function return after having obtained the lock. If it is
4700 nonnull, the result is is assigned the value true (one) when the lock could be
4701 obtained and false (zero) otherwise.  Locking a lock variable which has already
4702 been locked by the same image is an error.
4704 @item @emph{Syntax}:
4705 @code{void _gfortran_caf_lock (caf_token_t token, size_t index, int image_index,
4706 int *aquired_lock, int *stat, char *errmsg, int errmsg_len)}
4708 @item @emph{Arguments}:
4709 @multitable @columnfractions .15 .70
4710 @item @var{token} @tab intent(in) An opaque pointer identifying the coarray.
4711 @item @var{index} @tab Array index; first array index is 0. For scalars, it is
4712 always 0.
4713 @item @var{image_index} @tab The ID of the remote image; must be a positive
4714 number.
4715 @item @var{aquired_lock} @tab intent(out) If not NULL, it returns whether lock
4716 could be obtained
4717 @item @var{stat} @tab intent(out) Stores the STAT=; may be NULL
4718 @item @var{errmsg} @tab intent(out) When an error occurs, this will be set to
4719 an error message; may be NULL
4720 @item @var{errmsg_len} @tab the buffer size of errmsg.
4721 @end multitable
4723 @item @emph{NOTES}
4724 This function is also called for critical blocks; for those, the array index
4725 is always zero and the image index is one.  Libraries are permitted to use other
4726 images for critical-block locking variables.
4727 @end table
4729 @node _gfortran_caf_unlock
4730 @subsection @code{_gfortran_caf_lock} --- Unlocking a lock variable
4731 @cindex Coarray, _gfortran_caf_unlock
4733 @table @asis
4734 @item @emph{Description}:
4735 Release a lock on the given image on a scalar locking variable or for the
4736 given array element for an array-valued variable. Unlocking a lock variable
4737 which is unlocked or has been locked by a different image is an error.
4739 @item @emph{Syntax}:
4740 @code{void _gfortran_caf_unlock (caf_token_t token, size_t index, int image_index,
4741 int *stat, char *errmsg, int errmsg_len)}
4743 @item @emph{Arguments}:
4744 @multitable @columnfractions .15 .70
4745 @item @var{token} @tab intent(in) An opaque pointer identifying the coarray.
4746 @item @var{index} @tab Array index; first array index is 0. For scalars, it is
4747 always 0.
4748 @item @var{image_index} @tab The ID of the remote image; must be a positive
4749 number.
4750 @item @var{stat} @tab intent(out) For allocatable coarrays, stores the STAT=;
4751 may be NULL
4752 @item @var{errmsg} @tab intent(out) When an error occurs, this will be set to
4753 an error message; may be NULL
4754 @item @var{errmsg_len} @tab the buffer size of errmsg.
4755 @end multitable
4757 @item @emph{NOTES}
4758 This function is also called for critical block; for those, the array index
4759 is always zero and the image index is one.  Libraries are permitted to use other
4760 images for critical-block locking variables.
4761 @end table
4763 @node _gfortran_caf_event_post
4764 @subsection @code{_gfortran_caf_event_post} --- Post an event
4765 @cindex Coarray, _gfortran_caf_event_post
4767 @table @asis
4768 @item @emph{Description}:
4769 Increment the event count of the specified event variable.
4771 @item @emph{Syntax}:
4772 @code{void _gfortran_caf_event_post (caf_token_t token, size_t index,
4773 int image_index, int *stat, char *errmsg, int errmsg_len)}
4775 @item @emph{Arguments}:
4776 @multitable @columnfractions .15 .70
4777 @item @var{token} @tab intent(in) An opaque pointer identifying the coarray.
4778 @item @var{index} @tab Array index; first array index is 0. For scalars, it is
4779 always 0.
4780 @item @var{image_index} @tab The ID of the remote image; must be a positive
4781 number; zero indicates the current image when accessed noncoindexed.
4782 @item @var{stat} @tab intent(out) Stores the STAT=; may be NULL
4783 @item @var{errmsg} @tab intent(out) When an error occurs, this will be set to
4784 an error message; may be NULL
4785 @item @var{errmsg_len} @tab the buffer size of errmsg.
4786 @end multitable
4788 @item @emph{NOTES}
4789 This acts like an atomic add of one to the remote image's event variable.
4790 The statement is an image-control statement but does not imply sync memory.
4791 Still, all preceeding push communications of this image to the specified
4792 remote image has to be completed before @code{event_wait} on the remote
4793 image returns.
4794 @end table
4798 @node _gfortran_caf_event_wait
4799 @subsection @code{_gfortran_caf_event_wait} --- Wait that an event occurred
4800 @cindex Coarray, _gfortran_caf_event_wait
4802 @table @asis
4803 @item @emph{Description}:
4804 Wait until the event count has reached at least the specified
4805 @var{until_count}; if so, atomically decrement the event variable by this
4806 amount and return.
4808 @item @emph{Syntax}:
4809 @code{void _gfortran_caf_event_wait (caf_token_t token, size_t index,
4810 int until_count, int *stat, char *errmsg, int errmsg_len)}
4812 @item @emph{Arguments}:
4813 @multitable @columnfractions .15 .70
4814 @item @var{token} @tab intent(in) An opaque pointer identifying the coarray.
4815 @item @var{index} @tab Array index; first array index is 0. For scalars, it is
4816 always 0.
4817 @item @var{until_count} @tab The number of events which have to be available
4818 before the function returns.
4819 @item @var{stat} @tab intent(out) Stores the STAT=; may be NULL
4820 @item @var{errmsg} @tab intent(out) When an error occurs, this will be set to
4821 an error message; may be NULL
4822 @item @var{errmsg_len} @tab the buffer size of errmsg.
4823 @end multitable
4825 @item @emph{NOTES}
4826 This function only operates on a local coarray. It acts like a loop checking
4827 atomically the value of the event variable, breaking if the value is greater
4828 or equal the requested number of counts. Before the function returns, the
4829 event variable has to be decremented by the requested @var{until_count} value.
4830 A possible implementation would be a busy loop for a certain number of spins
4831 (possibly depending on the number of threads relative to the number of available
4832 cores) followed by other waiting strategy such as a sleeping wait (possibly with
4833 an increasing number of sleep time) or, if possible, a futex wait.
4835 The statement is an image-control statement but does not imply sync memory.
4836 Still, all preceeding push communications to this image of images having
4837 issued a @code{event_push} have to be completed before this function returns.
4838 @end table
4842 @node _gfortran_caf_event_query
4843 @subsection @code{_gfortran_caf_event_query} --- Query event count
4844 @cindex Coarray, _gfortran_caf_event_query
4846 @table @asis
4847 @item @emph{Description}:
4848 Return the event count of the specified event count.
4850 @item @emph{Syntax}:
4851 @code{void _gfortran_caf_event_query (caf_token_t token, size_t index,
4852 int image_index, int *count, int *stat)}
4854 @item @emph{Arguments}:
4855 @multitable @columnfractions .15 .70
4856 @item @var{token} @tab intent(in) An opaque pointer identifying the coarray.
4857 @item @var{index} @tab Array index; first array index is 0. For scalars, it is
4858 always 0.
4859 @item @var{image_index} @tab The ID of the remote image; must be a positive
4860 number; zero indicates the current image when accessed noncoindexed.
4861 @item @var{count} @tab intent(out) The number of events currently posted to
4862 the event variable
4863 @item @var{stat} @tab intent(out) Stores the STAT=; may be NULL
4864 @end multitable
4866 @item @emph{NOTES}
4867 The typical use is to check the local even variable to only call
4868 @code{event_wait} when the data is available. However, a coindexed variable
4869 is permitted; there is no ordering or synchronization implied.  It acts like
4870 an atomic fetch of the value of the event variable.
4871 @end table
4873 @node _gfortran_caf_sync_all
4874 @subsection @code{_gfortran_caf_sync_all} --- All-image barrier
4875 @cindex Coarray, _gfortran_caf_sync_all
4877 @table @asis
4878 @item @emph{Description}:
4879 Synchronization of all images in the current team; the program only continues
4880 on a given image after this function has been called on all images of the
4881 current team.  Additionally, it ensures that all pending data transfers of
4882 previous segment have completed.
4884 @item @emph{Syntax}:
4885 @code{void _gfortran_caf_sync_all (int *stat, char *errmsg, int errmsg_len)}
4887 @item @emph{Arguments}:
4888 @multitable @columnfractions .15 .70
4889 @item @var{stat} @tab intent(out) Stores the status STAT= and may be NULL.
4890 @item @var{errmsg} @tab intent(out) When an error occurs, this will be set to
4891 an error message; may be NULL
4892 @item @var{errmsg_len} @tab the buffer size of errmsg.
4893 @end multitable
4894 @end table
4898 @node _gfortran_caf_sync_images
4899 @subsection @code{_gfortran_caf_sync_images} --- Barrier for selected images
4900 @cindex Coarray, _gfortran_caf_sync_images
4902 @table @asis
4903 @item @emph{Description}:
4904 Synchronization between the specified images; the program only continues on a
4905 given image after this function has been called on all images specified for
4906 that image. Note that one image can wait for all other images in the current
4907 team (e.g. via @code{sync images(*)}) while those only wait for that specific
4908 image.  Additionally, @code{sync images} it ensures that all pending data
4909 transfers of previous segment have completed.
4911 @item @emph{Syntax}:
4912 @code{void _gfortran_caf_sync_images (int count, int images[], int *stat,
4913 char *errmsg, int errmsg_len)}
4915 @item @emph{Arguments}:
4916 @multitable @columnfractions .15 .70
4917 @item @var{count} @tab the number of images which are provided in the next
4918 argument.  For a zero-sized array, the value is zero.  For @code{sync
4919 images (*)}, the value is @math{-1}.
4920 @item @var{images} @tab intent(in) an array with the images provided by the
4921 user. If @var{count} is zero, a NULL pointer is passed.
4922 @item @var{stat} @tab intent(out) Stores the status STAT= and may be NULL.
4923 @item @var{errmsg} @tab intent(out) When an error occurs, this will be set to
4924 an error message; may be NULL
4925 @item @var{errmsg_len} @tab the buffer size of errmsg.
4926 @end multitable
4927 @end table
4931 @node _gfortran_caf_sync_memory
4932 @subsection @code{_gfortran_caf_sync_memory} --- Wait for completion of segment-memory operations
4933 @cindex Coarray, _gfortran_caf_sync_memory
4935 @table @asis
4936 @item @emph{Description}:
4937 Acts as optimization barrier between different segments. It also ensures that
4938 all pending memory operations of this image have been completed.
4940 @item @emph{Syntax}:
4941 @code{void _gfortran_caf_sync_memory (int *stat, char *errmsg, int errmsg_len)}
4943 @item @emph{Arguments}:
4944 @multitable @columnfractions .15 .70
4945 @item @var{stat} @tab intent(out) Stores the status STAT= and may be NULL.
4946 @item @var{errmsg} @tab intent(out) When an error occurs, this will be set to
4947 an error message; may be NULL
4948 @item @var{errmsg_len} @tab the buffer size of errmsg.
4949 @end multitable
4951 @item @emph{NOTE} A simple implementation could be
4952 @code{__asm__ __volatile__ ("":::"memory")} to prevent code movements.
4953 @end table
4957 @node _gfortran_caf_error_stop
4958 @subsection @code{_gfortran_caf_error_stop} --- Error termination with exit code
4959 @cindex Coarray, _gfortran_caf_error_stop
4961 @table @asis
4962 @item @emph{Description}:
4963 Invoked for an @code{ERROR STOP} statement which has an integer argument.  The
4964 function should terminate the program with the specified exit code.
4967 @item @emph{Syntax}:
4968 @code{void _gfortran_caf_error_stop (int32_t error)}
4970 @item @emph{Arguments}:
4971 @multitable @columnfractions .15 .70
4972 @item @var{error} @tab the exit status to be used.
4973 @end multitable
4974 @end table
4978 @node _gfortran_caf_error_stop_str
4979 @subsection @code{_gfortran_caf_error_stop_str} --- Error termination with string
4980 @cindex Coarray, _gfortran_caf_error_stop_str
4982 @table @asis
4983 @item @emph{Description}:
4984 Invoked for an @code{ERROR STOP} statement which has a string as argument.  The
4985 function should terminate the program with a nonzero-exit code.
4987 @item @emph{Syntax}:
4988 @code{void _gfortran_caf_error_stop (const char *string, int32_t len)}
4990 @item @emph{Arguments}:
4991 @multitable @columnfractions .15 .70
4992 @item @var{string} @tab the error message (not zero terminated)
4993 @item @var{len} @tab the length of the string
4994 @end multitable
4995 @end table
4999 @node _gfortran_caf_atomic_define
5000 @subsection @code{_gfortran_caf_atomic_define} --- Atomic variable assignment
5001 @cindex Coarray, _gfortran_caf_atomic_define
5003 @table @asis
5004 @item @emph{Description}:
5005 Assign atomically a value to an integer or logical variable.
5007 @item @emph{Syntax}:
5008 @code{void _gfortran_caf_atomic_define (caf_token_t token, size_t offset,
5009 int image_index, void *value, int *stat, int type, int kind)}
5011 @item @emph{Arguments}:
5012 @multitable @columnfractions .15 .70
5013 @item @var{token} @tab intent(in) An opaque pointer identifying the coarray.
5014 @item @var{offset} @tab By which amount of bytes the actual data is shifted
5015 compared to the base address of the coarray.
5016 @item @var{image_index} @tab The ID of the remote image; must be a positive
5017 number; zero indicates the current image when used noncoindexed.
5018 @item @var{value} @tab intent(in) the value to be assigned, passed by reference.
5019 @item @var{stat} @tab intent(out) Stores the status STAT= and may be NULL.
5020 @item @var{type} @tab the data type, i.e. @code{BT_INTEGER} (1) or
5021 @code{BT_LOGICAL} (2).
5022 @item @var{kind} @tab The kind value (only 4; always @code{int})
5023 @end multitable
5024 @end table
5028 @node _gfortran_caf_atomic_ref
5029 @subsection @code{_gfortran_caf_atomic_ref} --- Atomic variable reference
5030 @cindex Coarray, _gfortran_caf_atomic_ref
5032 @table @asis
5033 @item @emph{Description}:
5034 Reference atomically a value of a kind-4 integer or logical variable.
5036 @item @emph{Syntax}:
5037 @code{void _gfortran_caf_atomic_ref (caf_token_t token, size_t offset,
5038 int image_index, void *value, int *stat, int type, int kind)}
5040 @item @emph{Arguments}:
5041 @item @emph{Arguments}:
5042 @multitable @columnfractions .15 .70
5043 @item @var{token} @tab intent(in) An opaque pointer identifying the coarray.
5044 @item @var{offset} @tab By which amount of bytes the actual data is shifted
5045 compared to the base address of the coarray.
5046 @item @var{image_index} @tab The ID of the remote image; must be a positive
5047 number; zero indicates the current image when used noncoindexed.
5048 @item @var{value} @tab intent(out) The variable assigned the atomically
5049 referenced variable.
5050 @item @var{stat} @tab intent(out) Stores the status STAT= and may be NULL.
5051 @item @var{type} @tab the data type, i.e. @code{BT_INTEGER} (1) or
5052 @code{BT_LOGICAL} (2).
5053 @item @var{kind} @tab The kind value (only 4; always @code{int})
5054 @end multitable
5055 @end table
5059 @node _gfortran_caf_atomic_cas
5060 @subsection @code{_gfortran_caf_atomic_cas} --- Atomic compare and swap
5061 @cindex Coarray, _gfortran_caf_atomic_cas
5063 @table @asis
5064 @item @emph{Description}:
5065 Atomic compare and swap of a kind-4 integer or logical variable. Assigns
5066 atomically the specified value to the atomic variable, if the latter has
5067 the value specified by the passed condition value.
5069 @item @emph{Syntax}:
5070 @code{void _gfortran_caf_atomic_cas (caf_token_t token, size_t offset,
5071 int image_index, void *old, void *compare, void *new_val, int *stat,
5072 int type, int kind)}
5074 @item @emph{Arguments}:
5075 @multitable @columnfractions .15 .70
5076 @item @var{token} @tab intent(in) An opaque pointer identifying the coarray.
5077 @item @var{offset} @tab By which amount of bytes the actual data is shifted
5078 compared to the base address of the coarray.
5079 @item @var{image_index} @tab The ID of the remote image; must be a positive
5080 number; zero indicates the current image when used noncoindexed.
5081 @item @var{old} @tab intent(out) the value which the atomic variable had
5082 just before the cas operation.
5083 @item @var{compare} @tab intent(in) The value used for comparision.
5084 @item @var{new_val} @tab intent(in) The new value for the atomic variable,
5085 assigned to the atomic variable, if @code{compare} equals the value of the
5086 atomic variable.
5087 @item @var{stat} @tab intent(out) Stores the status STAT= and may be NULL.
5088 @item @var{type} @tab the data type, i.e. @code{BT_INTEGER} (1) or
5089 @code{BT_LOGICAL} (2).
5090 @item @var{kind} @tab The kind value (only 4; always @code{int})
5091 @end multitable
5092 @end table
5096 @node _gfortran_caf_atomic_op
5097 @subsection @code{_gfortran_caf_atomic_op} --- Atomic operation
5098 @cindex Coarray, _gfortran_caf_atomic_op
5100 @table @asis
5101 @item @emph{Description}:
5102 Apply an operation atomically to an atomic integer or logical variable.
5103 After the operation, @var{old} contains the value just before the operation,
5104 which, respectively, adds (GFC_CAF_ATOMIC_ADD) atomically the @code{value} to
5105 the atomic integer variable or does a bitwise AND, OR or exclusive OR of the
5106 between the atomic variable and @var{value}; the result is then stored in the
5107 atomic variable.
5109 @item @emph{Syntax}:
5110 @code{void _gfortran_caf_atomic_op (int op, caf_token_t token, size_t offset,
5111 int image_index, void *value, void *old, int *stat, int type, int kind)}
5113 @item @emph{Arguments}:
5114 @multitable @columnfractions .15 .70
5115 @item @var{op} @tab the operation to be performed; possible values
5116 @code{GFC_CAF_ATOMIC_ADD} (1), @code{GFC_CAF_ATOMIC_AND} (2),
5117 @code{GFC_CAF_ATOMIC_OR} (3), @code{GFC_CAF_ATOMIC_XOR} (4).
5118 @item @var{token} @tab intent(in) An opaque pointer identifying the coarray.
5119 @item @var{offset} @tab By which amount of bytes the actual data is shifted
5120 compared to the base address of the coarray.
5121 @item @var{image_index} @tab The ID of the remote image; must be a positive
5122 number; zero indicates the current image when used noncoindexed.
5123 @item @var{old} @tab intent(out) the value which the atomic variable had
5124 just before the atomic operation.
5125 @item @var{val} @tab intent(in) The new value for the atomic variable,
5126 assigned to the atomic variable, if @code{compare} equals the value of the
5127 atomic variable.
5128 @item @var{stat} @tab intent(out) Stores the status STAT= and may be NULL.
5129 @item @var{type} @tab the data type, i.e. @code{BT_INTEGER} (1) or
5130 @code{BT_LOGICAL} (2).
5131 @item @var{kind} @tab The kind value (only 4; always @code{int})
5132 @end multitable
5133 @end table
5138 @node _gfortran_caf_co_broadcast
5139 @subsection @code{_gfortran_caf_co_broadcast} --- Sending data to all images
5140 @cindex Coarray, _gfortran_caf_co_broadcast
5142 @table @asis
5143 @item @emph{Description}:
5144 Distribute a value from a given image to all other images in the team. Has to
5145 be called collectively.
5147 @item @emph{Syntax}:
5148 @code{void _gfortran_caf_co_broadcast (gfc_descriptor_t *a,
5149 int source_image, int *stat, char *errmsg, int errmsg_len)}
5151 @item @emph{Arguments}:
5152 @multitable @columnfractions .15 .70
5153 @item @var{a} @tab intent(inout) And array descriptor with the data to be
5154 breoadcasted (on @var{source_image}) or to be received (other images).
5155 @item @var{source_image} @tab The ID of the image from which the data should
5156 be taken.
5157 @item @var{stat} @tab intent(out) Stores the status STAT= and may be NULL.
5158 @item @var{errmsg} @tab intent(out) When an error occurs, this will be set to
5159 an error message; may be NULL
5160 @item @var{errmsg_len} @tab the buffer size of errmsg.
5161 @end multitable
5162 @end table
5166 @node _gfortran_caf_co_max
5167 @subsection @code{_gfortran_caf_co_max} --- Collective maximum reduction
5168 @cindex Coarray, _gfortran_caf_co_max
5170 @table @asis
5171 @item @emph{Description}:
5172 Calculates the for the each array element of the variable @var{a} the maximum
5173 value for that element in the current team; if @var{result_image} has the
5174 value 0, the result shall be stored on all images, otherwise, only on the
5175 specified image. This function operates on numeric values and character
5176 strings.
5178 @item @emph{Syntax}:
5179 @code{void _gfortran_caf_co_max (gfc_descriptor_t *a, int result_image,
5180 int *stat, char *errmsg, int a_len, int errmsg_len)}
5182 @item @emph{Arguments}:
5183 @multitable @columnfractions .15 .70
5184 @item @var{a} @tab intent(inout) And array descriptor with the data to be
5185 breoadcasted (on @var{source_image}) or to be received (other images).
5186 @item @var{result_image} @tab The ID of the image to which the reduced
5187 value should be copied to; if zero, it has to be copied to all images.
5188 @item @var{stat} @tab intent(out) Stores the status STAT= and may be NULL.
5189 @item @var{errmsg} @tab intent(out) When an error occurs, this will be set to
5190 an error message; may be NULL
5191 @item @var{a_len} @tab The string length of argument @var{a}.
5192 @item @var{errmsg_len} @tab the buffer size of errmsg.
5193 @end multitable
5195 @item @emph{NOTES}
5196 If @var{result_image} is nonzero, the value on all images except of the
5197 specified one become undefined; hence, the library may make use of this.
5198 @end table
5202 @node _gfortran_caf_co_min
5203 @subsection @code{_gfortran_caf_co_min} --- Collective minimum reduction
5204 @cindex Coarray, _gfortran_caf_co_min
5206 @table @asis
5207 @item @emph{Description}:
5208 Calculates the for the each array element of the variable @var{a} the minimum
5209 value for that element in the current team; if @var{result_image} has the
5210 value 0, the result shall be stored on all images, otherwise, only on the
5211 specified image. This function operates on numeric values and character
5212 strings.
5214 @item @emph{Syntax}:
5215 @code{void _gfortran_caf_co_min (gfc_descriptor_t *a, int result_image,
5216 int *stat, char *errmsg, int a_len, int errmsg_len)}
5218 @item @emph{Arguments}:
5219 @multitable @columnfractions .15 .70
5220 @item @var{a} @tab intent(inout) And array descriptor with the data to be
5221 breoadcasted (on @var{source_image}) or to be received (other images).
5222 @item @var{result_image} @tab The ID of the image to which the reduced
5223 value should be copied to; if zero, it has to be copied to all images.
5224 @item @var{stat} @tab intent(out) Stores the status STAT= and may be NULL.
5225 @item @var{errmsg} @tab intent(out) When an error occurs, this will be set to
5226 an error message; may be NULL
5227 @item @var{a_len} @tab The string length of argument @var{a}.
5228 @item @var{errmsg_len} @tab the buffer size of errmsg.
5229 @end multitable
5231 @item @emph{NOTES}
5232 If @var{result_image} is nonzero, the value on all images except of the
5233 specified one become undefined; hence, the library may make use of this.
5234 @end table
5238 @node _gfortran_caf_co_sum
5239 @subsection @code{_gfortran_caf_co_sum} --- Collective summing reduction
5240 @cindex Coarray, _gfortran_caf_co_sum
5242 @table @asis
5243 @item @emph{Description}:
5244 Calculates the for the each array element of the variable @var{a} the sum
5245 value for that element in the current team; if @var{result_image} has the
5246 value 0, the result shall be stored on all images, otherwise, only on the
5247 specified image. This function operates on numeric values.
5249 @item @emph{Syntax}:
5250 @code{void _gfortran_caf_co_sum (gfc_descriptor_t *a, int result_image,
5251 int *stat, char *errmsg, int errmsg_len)}
5253 @item @emph{Arguments}:
5254 @multitable @columnfractions .15 .70
5255 @item @var{a} @tab intent(inout) And array descriptor with the data to be
5256 breoadcasted (on @var{source_image}) or to be received (other images).
5257 @item @var{result_image} @tab The ID of the image to which the reduced
5258 value should be copied to; if zero, it has to be copied to all images.
5259 @item @var{stat} @tab intent(out) Stores the status STAT= and may be NULL.
5260 @item @var{errmsg} @tab intent(out) When an error occurs, this will be set to
5261 an error message; may be NULL
5262 @item @var{errmsg_len} @tab the buffer size of errmsg.
5263 @end multitable
5265 @item @emph{NOTES}
5266 If @var{result_image} is nonzero, the value on all images except of the
5267 specified one become undefined; hence, the library may make use of this.
5268 @end table
5272 @node _gfortran_caf_co_reduce
5273 @subsection @code{_gfortran_caf_co_reduce} --- Generic collective reduction
5274 @cindex Coarray, _gfortran_caf_co_reduce
5276 @table @asis
5277 @item @emph{Description}:
5278 Calculates the for the each array element of the variable @var{a} the reduction
5279 value for that element in the current team; if @var{result_image} has the
5280 value 0, the result shall be stored on all images, otherwise, only on the
5281 specified image. The @var{opr} is a pure function doing a mathematically
5282 commutative and associative operation.
5284 The @var{opr_flags} denote the following; the values are bitwise ored.
5285 @code{GFC_CAF_BYREF} (1) if the result should be returned
5286 by value; @code{GFC_CAF_HIDDENLEN} (2) whether the result and argument
5287 string lengths shall be specified as hidden argument;
5288 @code{GFC_CAF_ARG_VALUE} (4) whether the arguments shall be passed by value,
5289 @code{GFC_CAF_ARG_DESC} (8) whether the arguments shall be passed by descriptor.
5292 @item @emph{Syntax}:
5293 @code{void _gfortran_caf_co_reduce (gfc_descriptor_t *a,
5294 void * (*opr) (void *, void *), int opr_flags, int result_image,
5295 int *stat, char *errmsg, int a_len, int errmsg_len)}
5297 @item @emph{Arguments}:
5298 @multitable @columnfractions .15 .70
5299 @item @var{opr} @tab Function pointer to the reduction function.
5300 @item @var{opr_flags} @tab Flags regarding the reduction function
5301 @item @var{a} @tab intent(inout) And array descriptor with the data to be
5302 breoadcasted (on @var{source_image}) or to be received (other images).
5303 @item @var{result_image} @tab The ID of the image to which the reduced
5304 value should be copied to; if zero, it has to be copied to all images.
5305 @item @var{stat} @tab intent(out) Stores the status STAT= and may be NULL.
5306 @item @var{errmsg} @tab intent(out) When an error occurs, this will be set to
5307 an error message; may be NULL
5308 @item @var{a_len} @tab The string length of argument @var{a}.
5309 @item @var{errmsg_len} @tab the buffer size of errmsg.
5310 @end multitable
5312 @item @emph{NOTES}
5313 If @var{result_image} is nonzero, the value on all images except of the
5314 specified one become undefined; hence, the library may make use of this.
5315 For character arguments, the result is passed as first argument, followed
5316 by the result string length, next come the two string arguments, followed
5317 by the two hidden arguments. With C binding, there are no hidden arguments
5318 and by-reference passing and either only a single character is passed or
5319 an array descriptor.
5320 @end table
5323 @c Intrinsic Procedures
5324 @c ---------------------------------------------------------------------
5326 @include intrinsic.texi
5329 @tex
5330 \blankpart
5331 @end tex
5333 @c ---------------------------------------------------------------------
5334 @c Contributing
5335 @c ---------------------------------------------------------------------
5337 @node Contributing
5338 @unnumbered Contributing
5339 @cindex Contributing
5341 Free software is only possible if people contribute to efforts
5342 to create it.
5343 We're always in need of more people helping out with ideas
5344 and comments, writing documentation and contributing code.
5346 If you want to contribute to GNU Fortran,
5347 have a look at the long lists of projects you can take on.
5348 Some of these projects are small,
5349 some of them are large;
5350 some are completely orthogonal to the rest of what is
5351 happening on GNU Fortran,
5352 but others are ``mainstream'' projects in need of enthusiastic hackers.
5353 All of these projects are important!
5354 We will eventually get around to the things here,
5355 but they are also things doable by someone who is willing and able.
5357 @menu
5358 * Contributors::
5359 * Projects::
5360 * Proposed Extensions::
5361 @end menu
5364 @node Contributors
5365 @section Contributors to GNU Fortran
5366 @cindex Contributors
5367 @cindex Credits
5368 @cindex Authors
5370 Most of the parser was hand-crafted by @emph{Andy Vaught}, who is
5371 also the initiator of the whole project.  Thanks Andy!
5372 Most of the interface with GCC was written by @emph{Paul Brook}.
5374 The following individuals have contributed code and/or
5375 ideas and significant help to the GNU Fortran project
5376 (in alphabetical order):
5378 @itemize @minus
5379 @item Janne Blomqvist
5380 @item Steven Bosscher
5381 @item Paul Brook
5382 @item Tobias Burnus
5383 @item Fran@,{c}ois-Xavier Coudert
5384 @item Bud Davis
5385 @item Jerry DeLisle
5386 @item Erik Edelmann
5387 @item Bernhard Fischer
5388 @item Daniel Franke
5389 @item Richard Guenther
5390 @item Richard Henderson
5391 @item Katherine Holcomb
5392 @item Jakub Jelinek
5393 @item Niels Kristian Bech Jensen
5394 @item Steven Johnson
5395 @item Steven G. Kargl
5396 @item Thomas Koenig
5397 @item Asher Langton
5398 @item H. J. Lu
5399 @item Toon Moene
5400 @item Brooks Moses
5401 @item Andrew Pinski
5402 @item Tim Prince
5403 @item Christopher D. Rickett
5404 @item Richard Sandiford
5405 @item Tobias Schl@"uter
5406 @item Roger Sayle
5407 @item Paul Thomas
5408 @item Andy Vaught
5409 @item Feng Wang
5410 @item Janus Weil
5411 @item Daniel Kraft
5412 @end itemize
5414 The following people have contributed bug reports,
5415 smaller or larger patches,
5416 and much needed feedback and encouragement for the
5417 GNU Fortran project: 
5419 @itemize @minus
5420 @item Bill Clodius
5421 @item Dominique d'Humi@`eres
5422 @item Kate Hedstrom
5423 @item Erik Schnetter
5424 @item Joost VandeVondele
5425 @end itemize
5427 Many other individuals have helped debug,
5428 test and improve the GNU Fortran compiler over the past few years,
5429 and we welcome you to do the same!
5430 If you already have done so,
5431 and you would like to see your name listed in the
5432 list above, please contact us.
5435 @node Projects
5436 @section Projects
5438 @table @emph
5440 @item Help build the test suite
5441 Solicit more code for donation to the test suite: the more extensive the
5442 testsuite, the smaller the risk of breaking things in the future! We can
5443 keep code private on request.
5445 @item Bug hunting/squishing
5446 Find bugs and write more test cases! Test cases are especially very
5447 welcome, because it allows us to concentrate on fixing bugs instead of
5448 isolating them.  Going through the bugzilla database at
5449 @url{https://gcc.gnu.org/@/bugzilla/} to reduce testcases posted there and
5450 add more information (for example, for which version does the testcase
5451 work, for which versions does it fail?) is also very helpful.
5453 @end table
5456 @node Proposed Extensions
5457 @section Proposed Extensions
5459 Here's a list of proposed extensions for the GNU Fortran compiler, in no particular
5460 order.  Most of these are necessary to be fully compatible with
5461 existing Fortran compilers, but they are not part of the official
5462 J3 Fortran 95 standard.
5464 @subsection Compiler extensions:
5465 @itemize @bullet
5466 @item
5467 User-specified alignment rules for structures.
5469 @item
5470 Automatically extend single precision constants to double.
5472 @item
5473 Compile code that conserves memory by dynamically allocating common and
5474 module storage either on stack or heap.
5476 @item
5477 Compile flag to generate code for array conformance checking (suggest -CC).
5479 @item
5480 User control of symbol names (underscores, etc).
5482 @item
5483 Compile setting for maximum size of stack frame size before spilling
5484 parts to static or heap.
5486 @item
5487 Flag to force local variables into static space.
5489 @item
5490 Flag to force local variables onto stack.
5491 @end itemize
5494 @subsection Environment Options
5495 @itemize @bullet
5496 @item
5497 Pluggable library modules for random numbers, linear algebra.
5498 LA should use BLAS calling conventions.
5500 @item
5501 Environment variables controlling actions on arithmetic exceptions like
5502 overflow, underflow, precision loss---Generate NaN, abort, default.
5503 action.
5505 @item
5506 Set precision for fp units that support it (i387).
5508 @item
5509 Variable for setting fp rounding mode.
5511 @item
5512 Variable to fill uninitialized variables with a user-defined bit
5513 pattern.
5515 @item
5516 Environment variable controlling filename that is opened for that unit
5517 number.
5519 @item
5520 Environment variable to clear/trash memory being freed.
5522 @item
5523 Environment variable to control tracing of allocations and frees.
5525 @item
5526 Environment variable to display allocated memory at normal program end.
5528 @item
5529 Environment variable for filename for * IO-unit.
5531 @item
5532 Environment variable for temporary file directory.
5534 @item
5535 Environment variable forcing standard output to be line buffered (Unix).
5537 @end itemize
5540 @c ---------------------------------------------------------------------
5541 @c GNU General Public License
5542 @c ---------------------------------------------------------------------
5544 @include gpl_v3.texi
5548 @c ---------------------------------------------------------------------
5549 @c GNU Free Documentation License
5550 @c ---------------------------------------------------------------------
5552 @include fdl.texi
5556 @c ---------------------------------------------------------------------
5557 @c Funding Free Software
5558 @c ---------------------------------------------------------------------
5560 @include funding.texi
5562 @c ---------------------------------------------------------------------
5563 @c Indices
5564 @c ---------------------------------------------------------------------
5566 @node Option Index
5567 @unnumbered Option Index
5568 @command{gfortran}'s command line options are indexed here without any
5569 initial @samp{-} or @samp{--}.  Where an option has both positive and
5570 negative forms (such as -foption and -fno-option), relevant entries in
5571 the manual are indexed under the most appropriate form; it may sometimes
5572 be useful to look up both forms.
5573 @printindex op
5575 @node Keyword Index
5576 @unnumbered Keyword Index
5577 @printindex cp
5579 @bye